學習了一下關於工廠的設計模式，寫個例子整理一下，例子是生產不同廠商的滑鼠，可能不太合適，記錄一下想法。

1.簡單工廠

這個模式在factory裡面動態選擇使用哪個類

public class Factory {
  public static Made getMade(String o) {
    Made made = null;
    switch (o) {
      case "logutech":
        made = new LogitechMade();
        break;
      case "lenovo":
        made = new
 
 LenovoMade();
        break;
      default:
        made = new LogitechMade();
    }
    return made;
  }
}

Made類是一個抽象類，規定了製作的方法。

public abstract class Made {
  public abstract void made();
}

在工廠中通過客戶端傳入的需求，例項化不同的made物件。兩個廠商的made類繼承自Made類。另一個相同，重寫抽象類的生產方法

public class LogitechMade extends Made {
 

  @Override
  public void made() {
    System.out.println("logutech made mouse");
  }
}

接下來是main客戶端

public class Main {

  public static void main(String[] args) {
    Made made = Factory.getMade("lenovo");
    made.made();
  }
}

首先宣告一個Made的例項物件，從factory裡面獲得，根據使用者數需求例項化不同的廠商made物件，然後例項物件執行made製造方法，就製造了相應廠商的滑鼠。
這就是簡單工廠模式。
專案結構截圖

2.工廠模式

通過觀察，簡單工廠擴充套件性很差，每次增加廠商都要修改工廠類factory。工廠模式來解決，工廠模式只是增強了可擴充套件性，為每個生產類增加了一個工廠，類的數量增多，工廠類factory負擔減少。

首先是工廠類，這裡做成抽象類，減輕負擔，只規定了一個獲得生產方法的方法。

public abstract class AbstractFactory {
  public abstract Made getMade();
}

然後每個廠商都有一個工廠類，繼承自這個抽象的工廠類。重寫獲取製造方法的方法，這裡由於就是羅技的工廠，所以在獲取製造方法的方法裡直接返回與簡單工廠相同的類LogitechMade。這個類也是繼承自Made類，這裡與簡單工廠相同。

public class LogutechFactory extends AbstractFactory {
  @Override
  public Made getMade() {
    return new LogitechMade();
  }
}

剩下的類基本與簡單工廠一樣，接下來是mian。宣告一個AbstractFactory的引用，申請為LogitechFactory，這樣factory就是LogitechFactory的factory。然後從這個factory裡面獲得made製造方法，然後呼叫made.made方法。就是呼叫的LogitechMade的製造方法，製造出的就是Logitech的滑鼠。

public class Main {

  public static void main(String[] args) {
    AbstractFactory factory = new LogitechFactory();
    Made made = factory.getMade();
    made.made();
  }
}

工廠模式就是為每個執行方法的類做一個工廠，這樣達到了便於擴充套件的目的。
專案的截圖：

3.抽象工廠

然後是每個廠商不只是生產滑鼠，還要生產鍵盤，涉及到產品族的問題，就要用到抽象工廠。
這裡想放上專案的結構的截圖：

Mouse類：類似於之前的Made類，為抽象類，有一個製作滑鼠的方法，Keyboard與這個相同。

public abstract class Mouse {
  public abstract void MouseMade();
}

LogitechMouseMade為具體的生產類，繼承Mouse類，重寫mousemade方法，made包下的製造類分貝繼承device包下的類。

public class LogitechMouseMade extends Mouse {
  @Override
  public void MouseMade() {
    System.out.println("LogitechMouse");
  }
}

這裡的工廠增加了獲取製造鍵盤的的方法的抽象方法。

public abstract class AbstractFactory {
  public abstract Mouse madeMouse();
  public abstract Keyboard madeKeyboard();
}

具體廠商的工廠繼承抽象工廠，重寫方法：在方法中呼叫相應的類。

public class LogitechFactory extends AbstractFactory {
  @Override
  public Mouse madeMouse() {
    return new LogitechMouseMade();
  }

  @Override
  public Keyboard madeKeyboard() {
    return new LogitechKeyboardMade();
  }
}

main：還是獲得一個羅技的工廠，呼叫羅技工廠的做滑鼠方法和做鍵盤方法，就製作出來了。

public class Main {

  public static void main(String[] args) {
    AbstractFactory factory = new LogitechFactory();
    Mouse mouse = factory.madeMouse();
    Keyboard keyboard = factory.madeKeyboard();
    mouse.MouseMade();
    keyboard.KeyboardMade();
  }
}

3種模式各有利弊，在不同的情況用不同的方式，使程式碼易維護，可擴充套件。