COMP2511

25T2 Week 7

Friday 1-2pm (F13A)

 

Start 1:05pm

 

By: Sam Zheng (z5418112)

This Week

  • General Admin
  • Assignment 1 Feedback
  • Singleton Pattern
  • Abstract Factory Pattern
  • Decorator Pattern

General Admin

  • Assignment 2 is out - please start early!
    • Any pair/group work issues, please let me know as soon as possible (Teams or email)
    • Make sure to update  your blogs as you go - no blogs = no marks
    • Please keep each task to one PR only
  • Assignment 1 manual marking is done! You can find feedback on the Marking merge request in your repo
    • Please take this feedback into consideration for assignment 2
    • Any questions feel free to ask in lab
    • Final assignment marks should be out by early next week
    • You should also be able to check whether your project compiled on the compilation branch on your repo. If not, you can submit a rerun request on the forum with a penalty.

Assignment 1 Feedback

  • Some tips/feedback from marking the assignments:
    • UML:
      • Remember that abstract classes/methods are denoted with italics and interfaces <<like this>>
      • Static variables/methods can be denoted with an underline
      • Concrete implementations of abstract methods should be shown in their subclasses
      • Don't forget constructors
    • Coupling/Cohesion:
      • The getInfo methods in TrainsController could've been moved to their subclasses to reduce coupling and feature envy
    • Talk more about why you made certain design decisions in your blog :)
    • Careful about magic numbers throughout your code (use constants!)
    • Avoid type checking using hard coded strings - prefer instanceof or polymorphism to avoid type checking completely

Singleton Pattern

Singleton Pattern

What type of pattern?

Creational pattern

The singleton pattern ensures that a class has only one instance. It provides a global access point to this instance.

It helps avoid initialisation overhead when only 1 copy of an instance is needed.

Code Demo

Heist.java

Abstract Factory Pattern

  • Abstract factories can be used to create different types of families of objects
  • Consider making a GUI app with a light and dark mode. We might create an abstract factory to provide a common interface for our different factory types
// Abstract Products
interface Button { void render(); }
class LightButton implements Button { public void render() { System.out.println("🟡 Light Button"); } }
class DarkButton implements Button { public void render() { System.out.println("⚫ Dark Button"); } }

// Abstract Factory
interface GUIFactory { Button createButton(); }
class LightFactory implements GUIFactory { public Button createButton() { return new LightButton(); } }
class DarkFactory implements GUIFactory { public Button createButton() { return new DarkButton(); } }

// Client Code
public class AbstractFactoryExample {
    public static void main(String[] args) {
        GUIFactory factory = new DarkFactory(); // Switch to LightFactory for light mode
        factory.createButton().render(); // ⚫ Dark Button
    }
}

Code Demo

Thrones.java Part 1 - Abstract Factory Pattern

Code Demo

We want to simulate the board game with the added change that pieces can be made from different materials, either Wood, Plastic or Metal. We want to be able to pick and choose which material we create a board with. Each material has its own construction requirements:

  • Metal pieces are heavy and hence can only be set with 0 <= x <= 5, and y = 0
  • Plastic pieces are lightweight and can be placed anywhere within a given bound (provided to the factory)
  • Wooden pieces are large and bulky, and take up a nxn grid, meaning they can only be placed on tiles with x and y values which divide n (n is provided to the factory)

Decorator Pattern

Decorator Pattern

  • The Decorator Pattern is essentially a wrapper around a class
  • It is a structural pattern
  • We can make our base item and wrapper implement the same interface
  • This allows us to add and change behaviour dynamically
  • It also allows us to have multiple layers of decorators
  • Consider:
    • It's cold outside, and you are wearing a t-shirt. What do you do?
    • Put on a jacket (decorator), and you "extend" your basic state and are now warmer 😎
    • You're still cold, so you now wear a scarf 🧣
interface Coffee { double cost(); }

// Concrete Component
class SimpleCoffee implements Coffee {
    public double cost() { return 5.00; }
}

// Decorator
abstract class CoffeeDecorator implements Coffee {
    protected Coffee coffee;
    public CoffeeDecorator(Coffee coffee) { this.coffee = coffee; }
    public double cost() { return coffee.cost(); }
}

// Concrete Decorators
class MilkDecorator extends CoffeeDecorator {
    public MilkDecorator(Coffee coffee) { super(coffee); }
    public double cost() { return coffee.cost() + 1.50; }
}
class SugarDecorator extends CoffeeDecorator {
    public SugarDecorator(Coffee coffee) { super(coffee); }
    public double cost() { return coffee.cost() + 0.75; }
}

public class DecoratorExample {
    public static void main(String[] args) {
        Coffee coffee = new SimpleCoffee();
        coffee = new MilkDecorator(coffee);
        coffee = new SugarDecorator(coffee);
        System.out.println("Total cost: $" + coffee.cost()); // $7.25
    }
}

Code Demo

Thrones.java Part 2 - Decorator Pattern

Code Demo

Now we want our game to support adding different armour types for our pieces:

 

  • Helmet - reduces incoming damage by 1
  • Chain mail - halves incoming damage (rounded down)
  • Chest plate - caps the amount of damage to 7, but also slows the character down. If the character is otherwise capable of moving more than one square at a time then this armour restricts each move to distances of 3 squares or less (by manhattan distance).

 

We can use the Decorator Pattern implement this really easily!

Made with Slides.com