Design pattern - part 1

Design Pattern
part 1
Jieyi Wu
2017/10/25

GoF
Design Pattern
× Creational Patterns
× Structural Patterns
× Behavioral Patterns
1

Creational Pattern
2
× Singleton
× Simple Factory
× Factory
× Abstract Factory
× Builder
× Prototype

1.
Singleton
Pattern
• A class of which only a single instance can exist
3

Roles of the pattern
× Singleton
✦ Classic
✦ Thread-safe
✦ Synchronize the critical
✦ Thread-safe & Initialized
✦ Ultimate Thread-safe & efficient
5

Classic
Singleton
class Singleton {
private static Singleton instance = null;
private Singleton() {
}
public static Singleton getInstance() {
if (instance == null) {
instance = new Singleton();
}
return instance;
}
}
6

Thread-safe
Singleton
class Singleton {
}
public static synchronized Singleton getInstance() {
}
return instance;
}
}
7

Synchronize
the critical
Singleton
class Singleton {
}
synchronized (Singleton.class) {
}
}
}
return instance;
}
}
8

Thread-safe &
Initialized
Singleton
class Singleton {
private static Singleton instance = new
Singleton();
}
return instance;
}
}
9

Ultimate
Thread-safe &
efficient
Singleton
class Singleton {
}
private static class SingletonHolder {
private final static Singleton instance =
new Singleton();
}
return SingletonHolder.instance;
}
}
10

Pros. & Cons.
✓ Providing an unique object.
✓ Saving the system resource and improving the system performance.
✗ No interface layer.
✗ Over-responsibility and anti SRP(Single Responsibility Principle).
✗ Abusing this pattern is easy to cause problems.
11

2.
Simple Factory
Pattern
12
12

× Client
× Factory
× Product
× Concrete Product
14

Product &
Concrete
Product
abstract class Weapon {
public String name;
public Double attack;
public Double defense;
}
class Sword extends Weapon {}
class Blade extends Weapon {}
class Dagger extends Weapon {}
15

Simple
Factory
class WeaponFactory {
public Weapon create(String category) {
if ("sword".equals(category)) {
return new Sword();
}
else if ("blade".equals(category)) {
return new Blade();
}
else if ("dagger".equals(category)) {
return new Dagger();
}
return null;
}
}
16

Client
class Client {
public void main(String[] args) {
Weapon dagger = new
WeaponFactory().create("dagger");
Weapon sword = new
WeaponFactory().create("sword");
Weapon blade = new
WeaponFactory().create("blade");
User pokk = new User();
pokk.wield(dagger);
pokk.wield(blade);
}
}
17

Pros. & Cons.
✓ The business logic is inside of the factory.
✓ Don’t have to know the class name of a product.
✓ Adding a new product in factory without modifying on client.
✗ Gathering all creating process.
✗ It’s not easy to expend and maintain.
✗ Factory isn’t able to inherited.
18

3.
Factory
Pattern
• Creates an instance of several derived classes
19

× Client
× Factory
× Concrete Factory
× Product
× Concrete Product
21

interface IWeaponFactory {
Weapon create(String level);
}
class SwordFactory implements IWeaponFactory {
public Weapon create(String level) {
if ("normal".equals(level)) {
return new Sword();
}
else if ("advanced".equals(level)) {
return new AdvancedSword();
}
return null;
}
}
class DaggerFactory implements IWeaponFactory
{
public Weapon create(String level) {
if ("normal".equals(level)) {
return new Dagger();
}
else if ("advanced".equals(level)) {
return new AdvancedDagger();
}
return null;
}
}
…
Factory &
Concrete
Factory
22

public String name;
}
class Sword extends Weapon {}
class AdvancedSword extends Weapon {}
class Blade extends Weapon {}
class AdvancedBlade extends Weapon {}
class Dagger extends Weapon {}
class AdvancedDagger extends Weapon {}
Product &
Concrete
Product
23

class Client {
Weapon dagger = new
DaggerFactory().create("advanced");
Weapon sword = new
SwordFactory().create("normal");
Weapon blade = new
BladeFactory().create("advanced");
User pokk = new User();
pokk.wield(sword);
pokk.wield(blade);
}
}
Client
24

✓ Don’t have to care about the detail.
✓ Factories are also called polymorphism factory pattern.
✗ Concrete Factory class will increase.
Pros. & Cons.
25

4.
Abstract
Factory Pattern
• Creates an instance of several families of classes
26

× Client
× Factory
× Concrete Factory
× Abstract Product
× Concrete Product
28

Product
public String name;
}
abstract class Equipment {
public String name;
}
abstract class Wrist extends Equipment {}
abstract class Armor extends Equipment {}
abstract class Boot extends Equipment {}
abstract class Helmet extends Equipment {}
29

class FireSword extends Weapon {}
class MagicStaff extends Weapon {}
class DragonWrist extends Wrist {}
class MagicGloves extends Wrist {}
class MerlinCloth extends Armor {}
class DragonArmor extends Armor {}
class MerlinShoes extends Boot {}
class DragonBoot extends Boot {}
class MerlinHat extends Helmet {}
class DragonHelmet extends Helmet {}
Concrete
Product
30

class WizardSetFactory implements ISetEquipment {
@Override
public Weapon createWeapon() {
return new MagicStaff();
}
@Override
public Wrist createWrist() {
return new MagicGloves();
}
@Override
public Armor createArmor() {
return new MerlinCloth();
}
@Override
public Boot createBoot() {
return new MerlinShoes();
}
@Override
public Helmet createHelmet() {
return new MerlinHat();
}
}
Concrete
Factory A
31

interface ISetEquipment {
Weapon createWeapon();
Wrist createWrist();
Armor createArmor();
Boot createBoot();
Helmet createHelmet();
}
Factory
32

class WarriorSetFactory implements ISetEquipment {
@Override
public Weapon createWeapon() {
return new FireSword();
}
@Override
public Wrist createWrist() {
return new DragonWrist();
}
@Override
public Armor createArmor() {
return new DragonArmor();
}
@Override
public Boot createBoot() {
return new DragonBoot();
}
@Override
public Helmet createHelmet() {
return new DragonHelmet();
}
}
Concrete
Factory B
33

class Client {
WizardSetFactory wizardSetFactory = new
WizardSetFactory();
Weapon sword = wizardSetFactory.createWeapon();
Helmet helmet = wizardSetFactory.createHelmet();
Wrist wrist = wizardSetFactory.createWrist();
Armor armor = wizardSetFactory.createArmor();
Boot boot = wizardSetFactory.createBoot();
Warrior jieyi = new Warrior();
jieyi.wield(sword);
jieyi.wear(helmet, wrist, armor, boot);
WizardSetFactory wizardSetFactory = new
WizardSetFactory();
Weapon staff = wizardSetFactory.createWeapon();
Helmet hat = wizardSetFactory.createHelmet();
Wrist gloves = wizardSetFactory.createWrist();
Armor cloth = wizardSetFactory.createArmor();
Boot shoes = wizardSetFactory.createBoot();
Wizard pokk = new Wizard();
pokk.wield(staff);
pokk.wear(hat, gloves, cloth, shoes);
}
}
Client
34

Pros. & Cons.
✓ Separating the abstract factory and the product group.
✓ Guaranteeing the product group to work together.
✓ It’s easy to create a new concrete factory and following
OCP(Open Closed Principle).
✗ It’s not easy to add new category of products.
✗ Skewing OCP(Open Closed Principle).
35

5.
Builder
Pattern
• Separates object construction from its representation
36

Role of the pattern
× Director
× Builder
× Concrete Builder
× Product
38

Product
class Minion {
public String name;
public Weapon weapon;
public Equipment helmet;
public Equipment armor;
public Equipment boot;
public int money;
}
39

Builder
abstract class MinionBuilder {
protected Minion minion;
public abstract void buildName();
public abstract void buildWeapon();
public abstract void buildHelmet();
public abstract void buildArmor();
public abstract void buildBoot();
public Minion build() {
return minion;
}
}
40

Concrete
Builder A
class MinionA extends MinionBuilder {
@Override
public void buildName() {
minion.name = "MinionA";
}
@Override
public void buildWeapon() {
minion.weapon = new IceSword();
// To add some attributes from the weapon.
}
@Override
public void buildHelmet() {
minion.helmet = new Helmet();
}
@Override
public void buildArmor() {
minion.armor = new Armor();
}
@Override
public void buildBoot() {
minion.boot = new Boot();
}
}
41

Concrete
Builder B
class MinionB extends MinionBuilder {
@Override
public void buildName() {
minion.name = "Big Minion";
}
@Override
public void buildWeapon() {
minion.weapon = new Axe();
}
@Override
public void buildHelmet() {
minion.helmet = new KnightHelmet();
}
@Override
public void buildArmor() {
minion.helmet = new KnightArmor();
}
@Override
public void buildBoot() {
minion.boot = new KnightBoot();
}
}
42

Director
class Boss {
private MinionBuilder minionBuilder;
Boss(MinionBuilder minionBuilder) {
this.minionBuilder = minionBuilder;
}
public Minion summonMinion() {
minionBuilder.buildName();
minionBuilder.buildWeapon();
minionBuilder.buildHelmet();
minionBuilder.buildArmor();
minionBuilder.buildBoot();
return minionBuilder.build();
}
public void setBuilder(MinionBuilder minionBuilder) {
this.minionBuilder = minionBuilder;
}
}
43

Client
class Client {
MinionA minionA = new MinionA();
MinionB minionB = new MinionB();
Boss worldBoss = new Boss(minionA);
for (int index = 0 ; 10 > index ; index++) {
worldBoss.summonMinion();
}
worldBoss.setBuilder(minionB);
}
}
}
44

Alternative
Builder
There’s another common way to implement
the builder pattern.
45

Product &
Builder
class Minion {
public String name;
public Weapon weapon;
public Equipment helmet;
public Equipment armor;
public Equipment boot;
public int money;
public Minion(String name, Weapon weapon,
Equipment helmet, Equipment armor, Equipment
boot, int money) {
this.name = name;
this.weapon = weapon;
this.helmet = helmet;
this.armor = armor;
this.boot = boot;
this.money = money;
}
public static class MinionBuilder {
…
}
}
46

Builder
public static class MinionBuilder {
private String name;
private Weapon weapon;
private Equipment helmet;
private Equipment armor;
private Equipment boot;
private int money;
public MinionBuilder name(String name) {
this.name = name;
return this;
}
public MinionBuilder weapon(Weapon weapon) {
this.weapon = weapon;
return this;
}
public MinionBuilder helmet(Equipment helmet) {
this.helmet = helmet;
return this;
}
public MinionBuilder armor(Equipment armor) {
this.armor = armor;
return this;
}
public MinionBuilder boot(Equipment boot) {
this.boot = boot;
return this;
}
public MinionBuilder money(int money) {
this.money = money;
return this;
}
public Minion build() { return new Minion(name, weapon, helmet,
armor, boot, money); }
} 47

Director
class Boss {
public Minion summonMinion() {
return new Minion.MinionBuilder()
.name("Dragon Minion")
.weapon(new Claw())
.armor(new DragonArmor())
.helmet(new DragonHelmet())
.money(154000)
.build();
}
}
48

Client
class Client {
Boss worldBoss = new Boss();
}
}
}
49

Pros. & Cons.
✓ Decoupling the processing and the the products.
✓ Each of concrete builders is independent.
✓ Be able to control the processing detail.
✓ Expendable and following the OCP(Open Closed Principle).
✗ For the similar products.
✗ To fit the internal builder is complex, the builder might become
huge.
50

6.
Prototype
Pattern
• A fully initialized instance to be copied or cloned
51

Role of the pattern
× Client
× Prototype
× Concrete Prototype
53

Prototype
abstract class Weapon implements Cloneable {
public String name;
public Effect attackEffect;
}
54

Object
class Sword extends Weapon {
@Override
protected Object clone() {
Object clone = null;
try {
clone = super.clone();
((Weapon) clone).attackEffect = attackEffect.clone();
}
catch (CloneNotSupportedException e) {
e.printStackTrace();
}
return clone;
}
}
55

Client
class Client {
Sword sword = new Sword();
Warrior pokk = new Warrior();
pokk.wield(sword);
Sword dupSword = (Sword) sword.clone();
}
}
56

Pros. & Cons.
✓ Creating a same object is easy.
✓ Keeping the same object state.
✓ Simplifying the construction.
✗ It’s complex when implementing deep clone.
✗ Implementing the clone interface to each of the classes.
57

Design pattern - part 1

More Related Content

What's hot (20)

Viewers also liked (11)

Similar to Design pattern - part 1 (20)

More from Jieyi Wu (8)

Recently uploaded (20)

Design pattern - part 1