2020_常用整理

• 目錄

1. UML
2.Simple Factory
3.Strategy Pattern
4.Observer
5.Singleton

=============================
0.Design Pattern

OOP 主要的好處為透過 封裝,繼承,多型 降低偶合度.

Design Pattern 設計模式（Design pattern）是一套被反覆使用、多數人知曉的、經過分類編目的、代碼設計經驗的總結。

1. UML

透過UML 類別圖,可了解物件之間的基本關係.

•  類別圖 Class Diagram

最上面為class name=>Animal
第二層為var ; (-) 表示private;回傳 String=>-type:String
第三層為fun; (+) 表示public;回傳 String=>+getType()
p.s.(#)表示protected

-----------------------
|      Animal           |     
-----------------------
|   -type:String      |
-----------------------
|+getType():String|
-----------------------

• Relationships 關係

Instance-level 物件層級(物件關係)

• Dependency 依賴
• Association 關聯
• Aggregation 聚合
• Composition 組合

Class-level 類別層級(上下關係)

• Realization / Implementation 實現 / 實作
• Generalization / Inheritance 泛化 / 繼承

======================================

• Dependency 依賴

public void Order ()
{
  public void processPayment(PaymentSystem ps){
       ps.getTransaction();
   }
}

public void PaymentSystem()
{
public int getTransaction(){}
}

表示class order 暫時傭有class PaymentSystem 並使用  processPayment

Association 關聯

Aggregation 聚合

定義

• 聚合，弱 整體與部分的關係
• 整體可以脫離部分而單獨存在
• 整體與部分具有各自的生命周期

• class Car has a class Passenger
• 車子裡面有多少乘客
• 車子可以沒有乘客
• 類別並不負責新增或消滅附屬的類別
• 指標變數自己的生命週期(lifecycle)
• 當物件Car被消滅時，物件Passenger仍然存在

Composition 組合

定義

• 組合，強 整體與部分的關係
• 整體不可脫離部分而存在
• 整體的生命周期結束 也就意味著 部分的生命周期結束

一台電腦就必須有一顆CPU，而且CPU壞掉就會造成電腦無法運作，以下列出它的特性：

• class Laptop own a class CPU_I7
• 筆電擁有一個CPU
• 沒有CPU，筆電無法運作
• 類別負責產生和消滅附屬的類別
• 變數 與 擁有者生命週期相同
• 當物件Laptop被消滅，CPU也被消滅

二. 繼承關係

https://chenglearning.blogspot.com/2015/02/classrelationship.html

https://spicyboyd.blogspot.com/2018/07/umlclass-diagram-introduction.html

https://spicyboyd.blogspot.com/2018/07/umlclass-diagram-relationships.html

2.Simple Factory

// 冒險者(Product)
public interface Adventurer {
    //告訴別人你是哪種冒險者
    String getType();
}

// 弓箭手(ConcreteProduct)
public class Archer implements Adventurer {
    @Override
    public String getType() {
        System.out.println("我是弓箭手");
        return  this.getClass().getSimpleName();
    }
}

// 鬥士(ConcreteProduct)
public class Warrior implements Adventurer {
    @Override
    public String getType() {
        System.out.println("我是鬥士");    
        return  this.getClass().getSimpleName();
    }
}

public class TrainingCamp {
    public static Adventurer trainAdventurer(String type){
        switch(type){
            case "archer" : {
                System.out.println("訓練一個弓箭手");
                return new Archer();             
            }
            case "warrior": {
                System.out.println("訓練一個鬥士");
                return new Warrior();                
            }
            // 假如冒險者種類新增，增加case就可以
            default : return null;
        }
    }
}

Adventurer memberA = Village.trainAdventurer("archer");

3.Strategy Pattern

strategy & simple factory 相似
*factory 重點在 依類型(如int, string 等) , 決定使用哪個物件

• 簡單工廠模式是用來建立物件的模式，關注物件如何被產生

*strategy 重點在 傳入物件,決定如何運作

• 策略模式是一種行為模式，關注的是行為的封裝

兩者可結合, 可先透過"類型" 到factory 中取物件, 再把物件給strategy 去做動作.

public interface FlightStrategy {
    /**
     * 執行戰鬥策略
     */
    void execute();
}

/**
 * 一般攻擊(ConcreteStrategy)
 */
public class NormalAttack implements FlightStrategy {

    @Override
    public void execute() {
        System.out.println("使用一般攻擊");        
    }
}

/**
 * 使用技能(ConcreteStrategy)
 */
public class UseSkill implements FlightStrategy {
    @Override
    public void execute() {
        System.out.println("使用超級痛的技能攻擊");        
    }
}

/**
 * 使用道具(ConcretStratey)
 */
public class UseItem implements FlightStrategy {
    @Override
    public void execute() {
        System.out.println("使用道具，丟火把");
    }
}

[新增]為了合併factory

public class shootStategy implements FlightStrategy {
    @Override
    public void execute() {
        System.out.println("shoot");
    }

public class Adventurer {
    FlightStrategy flightStrategy;  //不同戰鬥方式效果不同(strategy)
    /**
     * 攻擊
     */
    public void attack(){
        // 預設為普通攻擊
        if(flightStrategy == null){
            flightStrategy = new NormalAttack();
        }
        flightStrategy.execute();
    }

    /**
     * 選擇不同的武器(策略)
     */
    public void choiceStrategy(FlightStrategy strategy){
        this.flightStrategy = strategy;
    }
}

Adventurer ad = new Adventurer(); 
ad.choiceStrategy(new NormalAttack());
ad.attack();

=====================

如:

Adventurer memberA = Village.trainAdventurer("archer");

多個 FlightStrategy strage=memberA .getAttackMode()

ad.choiceStrategy(strage);
ad.attack();

public interface Adventurer {
    //告訴別人你是哪種冒險者
    String getType();
FlightStrategy getAttackMode(); //依攻擊手類型區分
//如射手只能射, 戰士只能砍
}


public class Archer implements Adventurer {
    @Override
    public String getType() {
        System.out.println("我是弓箭手");
        return  this.getClass().getSimpleName();
    }
   public FlightStrategy getAttackMode()
 {
     return new shootStategy();//extends FlightStrategy
  }
}


https://skyyen999.gitbooks.io/-study-design-pattern-in-java/content/strategySimpleFactory.html

4.Observer

5.Singleton

目的：保證一個類別只會產生一個物件，而且要提供存取該物件的統一方法.

---------------------------
| Singleton                  |
---------------------------
| -instance:Singleton   |
--------------------------
| -Singleton()              |
| +GetInstance()         |
--------------------------

public class Singleton {
    private static Singleton instance;

    private Singleton(){
        // 這裡面跑很了多code，建立物件需要花費很多資源
    }

    public static Singleton getInstance(){
        // 第一次被呼叫的時候再建立物件
        if(instance == null){
            instance = new Singleton();
        } 
        return instance;
    }
}

thread 創建需注意:

可以用synchronized修飾來解決這個問題，讓getInstance方法被調用的時候被lock住.

public static synchronized Singleton getInstance(){
        if(instance == null){
            instance = new Singleton();
        } 
        return instance;
    }