Beispielcode-Analyse für Java-Factory-Muster

Einfaches Fabrikmodell

Sehen Sie sich eine spezifische Anforderung an

Sehen Sie sich ein Pizzaprojekt an: Es muss einfach zu erweiternde Pizzatypen und leicht zu warten sein

1) Es gibt viele Pizzasorten (z. B. GreekPizz, CheesePizz). , usw.)

2 ) Die Pizzazubereitung umfasst Vorbereiten, Backen, Schneiden, Verpacken

3) Vervollständigen Sie die Pizzashop-Bestellfunktion.

package com.example.demo.simplefactory.pizzastore.pizza;

/**
 * 将Pizza 类做成抽象
 * @author Administrator
 *
 */
public abstract class Pizza {
  /**
   * 名字
   */
  protected String name;
  
  /**
   * 准备原材料，不同的披萨不一样，因此，我们做成抽象方法
   */
  public abstract void prepare();
  
  public void bake() {
    System.out.println(name + " baking;");
  }
  
  public void cut() {
    System.out.println(name + " cutting;");
  }
  
  public void box() {
    System.out.println(name + " boxing");
  }
  
  public void setName(String name) {
    this.name = name;
  }
  
}
package com.example.demo.simplefactory.pizzastore.pizza;

public class GreekPizza extends Pizza{

  @Override
  public void prepare() {
    System.out.println(" 给希腊披萨 准备原材料");
  }

}
package com.example.demo.simplefactory.pizzastore.pizza;

public class CheesePizza extends Pizza{

  @Override
  public void prepare() {
    System.out.println(" 给制作奶酪披萨，准备原材料");
  }

}
package com.example.demo.simplefactory.pizzastore.order;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

import com.example.demo.simplefactory.pizzastore.pizza.CheesePizza;
import com.example.demo.simplefactory.pizzastore.pizza.GreekPizza;
import com.example.demo.simplefactory.pizzastore.pizza.Pizza;

public class OrderPizza {
  
  /**
   * 构造器
   */
  public OrderPizza() {
    Pizza pizza = null;
    // 订购披萨的类型
    String orderType;
    do {
      orderType = getType();
      if (orderType.equals("greek")) {
        pizza = new GreekPizza();
        pizza.setName(" 希腊披萨 ");
      } else if (orderType.equals("cheese")) {
        pizza = new CheesePizza();
        pizza.setName(" 奶酪披萨 ");
      } else {
        break;
      }
      // 输出pizza 制作过程
      pizza.prepare();
      pizza.bake();
      pizza.cut();
      pizza.box();
    } while (true);
  }
  
  /**
   * 写一个方法，可以获取客户希望订购的披萨种类
   * @return
   */
  private String getType() {
    try {
      BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(System.in));
      System.out.println("input pizza type : ");
      String string = bufferedReader.readLine();
      return string;
    } catch(IOException e) {
      e.printStackTrace();
      return "";
    }
  }
}
package com.example.demo.simplefactory.pizzastore.order;

/**
 * 相当于一个客户端，发出订购
 * @author Administrator
 *
 */
public class PizzaStore {

  public static void main(String[] args) {
    new OrderPizza();
  }

}

Vor- und Nachteile der traditionellen Methode:

1) Der Vorteil ist, dass sie einfacher zu verstehen und einfacher zu bedienen ist.

2) Der Nachteil besteht darin, dass es gegen das OCP-Prinzip des Entwurfsmusters verstößt, das offen für Erweiterungen und geschlossen für Änderungen ist. Das heißt, wenn wir einer Klasse neue Funktionen hinzufügen, versuchen wir, den Code nicht oder so wenig wie möglich zu ändern.

3) Wenn wir beispielsweise jetzt eine neue Pizzasorte hinzufügen möchten, müssen wir diese wie folgt ändern.

package com.example.demo.simplefactory.pizzastore.pizza;

public class PepperPizza extends Pizza{

  @Override
  public void prepare() {
    System.out.println(" 给胡椒披萨准备原材料 ");
  }

}
package com.example.demo.simplefactory.pizzastore.order;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

import com.example.demo.simplefactory.pizzastore.pizza.CheesePizza;
import com.example.demo.simplefactory.pizzastore.pizza.GreekPizza;
import com.example.demo.simplefactory.pizzastore.pizza.PepperPizza;
import com.example.demo.simplefactory.pizzastore.pizza.Pizza;

public class OrderPizza {
  
  /**
   * 构造器
   */
  public OrderPizza() {
    Pizza pizza = null;
    // 订购披萨的类型
    String orderType;
    do {
      orderType = getType();
      if (orderType.equals("greek")) {
        pizza = new GreekPizza();
        pizza.setName(" 希腊披萨 ");
      } else if (orderType.equals("cheese")) {
        pizza = new CheesePizza();
        pizza.setName(" 奶酪披萨 ");
      } else if (orderType.equals("pepper")) {
        pizza = new PepperPizza();
        pizza.setName("胡椒披萨");
      } else {
        break;
      }
      // 输出pizza 制作过程
      pizza.prepare();
      pizza.bake();
      pizza.cut();
      pizza.box();
    } while (true);
  }
  
  /**
   * 写一个方法，可以获取客户希望订购的披萨种类
   * @return
   */
  private String getType() {
    try {
      BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(System.in));
      System.out.println("input pizza type : ");
      String string = bufferedReader.readLine();
      return string;
    } catch(IOException e) {
      e.printStackTrace();
      return "";
    }
  }
}

4) Analyse verbesserter Ideen
Analyse: Das Ändern des Codes ist akzeptabel, aber wenn wir auch an anderen Stellen Code zum Erstellen von Pizza haben, bedeutet das, dass dieser ebenfalls geändert werden muss, und der Code zum Erstellen von Pizza ist häufig geändert worden mehrere Orte.
Idee: Kapseln Sie die Erstellung von Pizza-Objekten in einer Klasse, sodass wir bei einem neuen Pizzatyp nur die Klasse ändern müssen und andere Codes, die Pizza-Objekte erstellen, nicht geändert werden müssen

Einfaches Factory-Muster

Grundlegende Einführung

1) Das einfache Fabrikmuster ist ein Schöpfungsmuster und eine Art Fabrikmuster. Das einfache Factory-Muster verwendet ein Factory-Objekt, um zu entscheiden, welche Produktklasseninstanz erstellt werden soll. Das einfache Factory-Muster ist das einfachste und praktischste Muster in der Factory-Musterfamilie Wenn wir in der Softwareentwicklung eine große Anzahl von Objekten eines bestimmten Typs, Typs oder einer bestimmten Charge erstellen, verwenden wir das Factory-Muster.

package com.example.demo.simplefactory.pizzastore.order;

import com.example.demo.simplefactory.pizzastore.pizza.CheesePizza;
import com.example.demo.simplefactory.pizzastore.pizza.GreekPizza;
import com.example.demo.simplefactory.pizzastore.pizza.PepperPizza;
import com.example.demo.simplefactory.pizzastore.pizza.Pizza;

/**
 * 简单工厂类
 * @author Administrator
 *
 */
public class SimpleFactory {

  public Pizza createPizza(String orderType) {
    Pizza pizza = null;
    System.out.println("使用简单工厂模式");
    if (orderType.equals("greek")) {
      pizza = new GreekPizza();
      pizza.setName(" 希腊披萨 ");
    } else if (orderType.equals("cheese")) {
      pizza = new CheesePizza();
      pizza.setName(" 奶酪披萨 ");
    } else if (orderType.equals("pepper")) {
      pizza = new PepperPizza();
      pizza.setName("胡椒披萨");
    } 
    return pizza;
  }
  
}
package com.example.demo.simplefactory.pizzastore.order;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

import com.example.demo.simplefactory.pizzastore.pizza.CheesePizza;
import com.example.demo.simplefactory.pizzastore.pizza.GreekPizza;
import com.example.demo.simplefactory.pizzastore.pizza.PepperPizza;
import com.example.demo.simplefactory.pizzastore.pizza.Pizza;

public class OrderPizza {
  
  /**
   * 构造器
   */
  /*
   * public OrderPizza() { Pizza pizza = null; // 订购披萨的类型 String orderType; do {
   * orderType = getType(); if (orderType.equals("greek")) { pizza = new
   * GreekPizza(); pizza.setName(" 希腊披萨 "); } else if (orderType.equals("cheese"))
   * { pizza = new CheesePizza(); pizza.setName(" 奶酪披萨 "); } else if
   * (orderType.equals("pepper")) { pizza = new PepperPizza();
   * pizza.setName("胡椒披萨"); } else { break; } // 输出pizza 制作过程 pizza.prepare();
   * pizza.bake(); pizza.cut(); pizza.box(); } while (true); }
   */
  
  /**
   * 构造器
   * @param simpleFactory
   */
  public OrderPizza(SimpleFactory simpleFactory) {
    setFactory(simpleFactory);
  }
  
  /**
   * 定义一个简单工厂对象
   */
  private SimpleFactory simpleFactory;
  private Pizza pizza = null;
  private void setFactory(SimpleFactory simpleFactory) {
    // 用户输入的
    String orderTypeString = "";
    // 设置简单工厂对象
    this.simpleFactory = simpleFactory;
    do {
      orderTypeString = getType();
      pizza = this.simpleFactory.createPizza(orderTypeString);
      // 输出pizza
      // 订购成功
      if (pizza != null) {
        pizza.prepare();
        pizza.bake();
        pizza.cut();
        pizza.box();
      } else {
        System.out.println(" 订购披萨失败 ");
        break;
      }
    } while (true);
  }
  
  /**
   * 写一个方法，可以获取客户希望订购的披萨种类
   * @return
   */
  private String getType() {
    try {
      BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(System.in));
      System.out.println("input pizza type : ");
      String string = bufferedReader.readLine();
      return string;
    } catch(IOException e) {
      e.printStackTrace();
      return "";
    }
  }
}
package com.example.demo.simplefactory.pizzastore.order;

/**
 * 相当于一个客户端，发出订购
 * @author Administrator
 *
 */
public class PizzaStore {

  public static void main(String[] args) {
    //new OrderPizza();
    
    // 使用简单工厂模式
    new OrderPizza(new SimpleFactory());
    System.out.println("~~退出程序~~");
  }

}

Fabrikmethodenmuster

Sehen Sie sich eine neue Anforderung an

Neue Anforderung für Pizzaprojekt: Wenn Kunden Pizza bestellen, können sie verschiedene Pizzageschmacksrichtungen bestellen, z. B. Peking-Käse-Pizza, Peking-Pfeffer-Pizza oder London-Pizza-Käse Pizza, Londoner Pfefferpizza.

Idee 1

Verwenden Sie das einfache Fabrikmuster, um verschiedene einfache Fabrikklassen zu erstellen, z. B. BJPizzaSimpleFactory, LDPizzaSimpleFactory usw. Aus dem aktuellen Fall ist dies auch möglich, jedoch unter Berücksichtigung des Umfangs des Projekts und der Machbarkeit Die Wartung und Skalierbarkeit der Software ist nicht besonders gut

Idee 2

Verwenden Sie das Factory-Methodenmuster

Einführung in das Factory-Methodenmuster

Designplan für Factory-Methodenmuster: Abstrahieren Sie die Instanziierungsfunktion des Pizza-Projekts in eine abstrakte Methode, die speziell in verschiedenen Unterklassen der Geschmacksreihenfolge implementiert wird.

Factory-Methodenmuster: Definiert eine abstrakte Methode zum Erstellen von Objekten, und die Unterklasse bestimmt die zu instanziierende Klasse. Das Factory-Methodenmuster verschiebt die Instanziierung eines -Objekts auf eine Unterklasse

.

package com.example.demo.factorymethod.pizzastore.order;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

import com.example.demo.simplefactory.pizzastore.pizza.Pizza;
import com.fasterxml.jackson.databind.deser.ValueInstantiator.Gettable;

public abstract class OrderPizza {
  
  public OrderPizza() {
    Pizza pizza = null;
    // 订购披萨的类型
    String orderType;
    do {
      orderType = getType();
      createPizza(orderType);
      // 输出Pizza 制作过程
      pizza.prepare();
      pizza.bake();
      pizza.cut();
      pizza.box();
    } while (true);
  }
  
  /**
   * 定义一个抽象方法，createPizza,让各个工厂子类自己实现
   * @param orderType
   * @return
   */
  abstract Pizza createPizza(String orderType);
  
  /**
   * 写一个方法，可以获取客户希望订购的披萨种类
   * @return
   */
  private String getType() {
    try {
      BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(System.in));
      System.out.println("input pizza type : ");
      String string = bufferedReader.readLine();
      return string;
    } catch(IOException e) {
      e.printStackTrace();
      return "";
    }
  }
}
package com.example.demo.factorymethod.pizzastore.order;

import org.apache.tomcat.util.security.Escape;

import com.example.demo.factorymethod.pizzastore.pizza.LDCheesePizza;
import com.example.demo.factorymethod.pizzastore.pizza.LDPepperPizza;
import com.example.demo.simplefactory.pizzastore.pizza.Pizza;

public class LDOrderPizza extends OrderPizza{

  @Override
  Pizza createPizza(String orderType) {
    Pizza pizza = null;
    if (orderType.equals("cheese")) {
      pizza = new LDCheesePizza();
    } else if (orderType.equals("pepper")) {
      pizza = new LDPepperPizza();
    }
    return pizza;
  }

}
package com.example.demo.factorymethod.pizzastore.order;

import com.example.demo.factorymethod.pizzastore.pizza.BJCheesPizza;
import com.example.demo.factorymethod.pizzastore.pizza.BJPepperPizza;
import com.example.demo.simplefactory.pizzastore.pizza.Pizza;

public class BJOrderPizza extends OrderPizza{

  @Override
  Pizza createPizza(String orderType) {
    Pizza pizza = null;
    if (orderType.equals("cheese")) {
      pizza = new BJCheesPizza();
    } else if (orderType.equals("pepper")) {
      pizza = new BJPepperPizza();
    }
    return pizza;
  }

}
package com.example.demo.factorymethod.pizzastore.pizza;

import com.example.demo.simplefactory.pizzastore.pizza.Pizza;

public class BJCheesPizza extends Pizza{

  @Override
  public void prepare() {
    setName("北京的奶酪pizza");
    System.out.println(" 北京的奶酪pizza 准备原材料 ");
  }

}
package com.example.demo.factorymethod.pizzastore.pizza;

import com.example.demo.simplefactory.pizzastore.pizza.Pizza;

public class BJPepperPizza extends Pizza{

  @Override
  public void prepare() {
    setName(" 北京的胡椒pizza ");
    System.out.println(" 北京的胡椒pizza 准备原材料  ");
  }

}
package com.example.demo.factorymethod.pizzastore.pizza;

import com.example.demo.simplefactory.pizzastore.pizza.Pizza;

public class LDCheesePizza extends Pizza{

  @Override
  public void prepare() {
    setName(" 伦敦的奶酪pizza ");
    System.out.println(" 伦敦的奶酪pizza 准备原材料 ");
  }

}
package com.example.demo.factorymethod.pizzastore.pizza;

import com.example.demo.simplefactory.pizzastore.pizza.Pizza;

public class LDPepperPizza extends Pizza{

  @Override
  public void prepare() {
    setName(" 伦敦的胡椒pizza ");
    System.out.println(" 伦敦的胡椒pizza 准备原材料 ");
  }

}
package com.example.demo.factorymethod.pizzastore.order;

public class PizzaStore {

  public static void main(String[] args) {
    // 创建北京口味的各种Pizza
    new BJOrderPizza();
  }

}

Abstraktes Fabrikmuster

Grundlegende Einführung

1) Abstraktes Fabrikmuster: Definiert eine

Schnittstelle

, die zum Erstellen verwandter oder abhängiger Objektcluster ohne Angabe spezifischer Klassen verwendet wird

2) Abstraktes Fabrikmuster Das

Einfache Fabrikmuster

und das Factory Method Pattern kann integriert werden

3) Aus gestalterischer Sicht ist das Abstract Factory Pattern eine Verbesserung (oder weitere Abstraktion) des Simple Factory Pattern. 4) Abstraktion der Fabrik in zwei Schichten, AbsFactory (abstrakte Fabrik) und konkret implementierte Fabrikunterklassen. Programmierer können entsprechende Factory-Unterklassen basierend auf der Art der von ihnen erstellten Objekte verwenden. Dadurch wird aus einer einzelnen einfachen Factory-Klasse ein Factory-Cluster, der sich besser für die Wartung und Erweiterung des Codes eignet.

package com.example.demo.absfactory.pizzastore.order;

import com.example.demo.simplefactory.pizzastore.pizza.Pizza;

/**
 * 一个抽象工厂模式的抽象层（接口）
 * @author Administrator
 *
 */
public interface AbsFactory {
  
  /**
   * 让下面的工厂子类来   具体实现
   * @param orderType
   * @return
   */
  Pizza createPizza(String orderType);
}
package com.example.demo.absfactory.pizzastore.order;

import com.example.demo.absfactory.pizzastore.pizza.BJCheesPizza;
import com.example.demo.factorymethod.pizzastore.pizza.BJPepperPizza;
import com.example.demo.simplefactory.pizzastore.pizza.Pizza;

/**
 * 这是工厂子类
 * @author Administrator
 *
 */
public class BJFactory implements AbsFactory{

  @Override
  public Pizza createPizza(String orderType) {
    System.out.println("~使用的是抽象工厂模式~");
    Pizza pizza = null;
    if (orderType.equals("cheese")) {
      pizza = new BJCheesPizza();
    } else if (orderType.equals("pepper") ) {
      pizza = new BJPepperPizza();
    }
    return pizza;
  }

}
package com.example.demo.absfactory.pizzastore.order;

import com.example.demo.absfactory.pizzastore.pizza.LDCheesePizza;
import com.example.demo.absfactory.pizzastore.pizza.LDPepperPizza;
import com.example.demo.simplefactory.pizzastore.pizza.Pizza;

public class LDFactory implements AbsFactory{

  @Override
  public Pizza createPizza(String orderType) {
    System.out.println("~使用的是抽象工厂模式~");
    Pizza pizza = null;
    if (orderType.equals("cheese")) {
      pizza = new LDCheesePizza();
    } else if (orderType.equals("pepper")) {
      pizza = new LDPepperPizza();
    }
    return pizza;
  }

}
package com.example.demo.absfactory.pizzastore.order;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

import com.example.demo.simplefactory.pizzastore.pizza.Pizza;

public class OrderPizza {
  
  private AbsFactory factory;
  
  /**
   * 构造器
   * @param factory
   */
  public OrderPizza(AbsFactory factory) {
    setFactory(factory);
  }
  
  private void setFactory(AbsFactory factory) {
    Pizza pizza = null;
    // 用户输入
    String orderTypeString = "";
    this.factory = factory;
    do {
      orderTypeString = getType();
      pizza = factory.createPizza(orderTypeString);
      if (pizza != null) {
        pizza.prepare();
        pizza.bake();
        pizza.cut();
        pizza.box();
      } else {
        System.out.println("~订购失败~");
        break;
      }
    } while (true);
  }

  /**
   * 写一个方法，可以获取客户希望订购的披萨种类
   * @return
   */
  private String getType() {
    try {
      BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(System.in));
      System.out.println("input pizza type : ");
      String string = bufferedReader.readLine();
      return string;
    } catch(IOException e) {
      e.printStackTrace();
      return "";
    }
  }
}
package com.example.demo.absfactory.pizzastore.pizza;

import com.example.demo.simplefactory.pizzastore.pizza.Pizza;

public class BJCheesPizza extends Pizza{

  @Override
  public void prepare() {
    setName("北京的奶酪pizza");
    System.out.println(" 北京的奶酪pizza 准备原材料 ");
  }

}
package com.example.demo.absfactory.pizzastore.pizza;

import com.example.demo.simplefactory.pizzastore.pizza.Pizza;

public class BJPepperPizza extends Pizza{

  @Override
  public void prepare() {
    setName(" 北京的胡椒pizza ");
    System.out.println(" 北京的胡椒pizza 准备原材料  ");
  }

}
package com.example.demo.absfactory.pizzastore.pizza;

import com.example.demo.simplefactory.pizzastore.pizza.Pizza;

public class LDCheesePizza extends Pizza{

  @Override
  public void prepare() {
    setName(" 伦敦的奶酪pizza ");
    System.out.println(" 伦敦的奶酪pizza 准备原材料 ");
  }

}
package com.example.demo.absfactory.pizzastore.pizza;

import com.example.demo.simplefactory.pizzastore.pizza.Pizza;

public class LDPepperPizza extends Pizza{

  @Override
  public void prepare() {
    setName(" 伦敦的胡椒pizza ");
    System.out.println(" 伦敦的胡椒pizza 准备原材料 ");
  }

}
package com.example.demo.absfactory.pizzastore.order;

public class PizzaStore {
  public static void main(String[] args) {
    new OrderPizza(new BJFactory());
  }
}

Factory-Muster in der Quellcode-Analyse der JDK-Calendar-Anwendung
1) In der Calendar-Klasse in JDK wird das einfache Factory-Muster verwendet

public static Calendar getInstance()
    {
        return createCalendar(TimeZone.getDefault(), Locale.getDefault(Locale.Category.FORMAT));
    }
private static Calendar createCalendar(TimeZone zone,
                                           Locale aLocale)
    {
        CalendarProvider provider =
            LocaleProviderAdapter.getAdapter(CalendarProvider.class, aLocale)
                                 .getCalendarProvider();
        if (provider != null) {
            try {
                return provider.getInstance(zone, aLocale);
            } catch (IllegalArgumentException iae) {
                // fall back to the default instantiation
            }
        }

        Calendar cal = null;

        if (aLocale.hasExtensions()) {
            String caltype = aLocale.getUnicodeLocaleType("ca");
            if (caltype != null) {
                switch (caltype) {
                case "buddhist":
                cal = new BuddhistCalendar(zone, aLocale);
                    break;
                case "japanese":
                    cal = new JapaneseImperialCalendar(zone, aLocale);
                    break;
                case "gregory":
                    cal = new GregorianCalendar(zone, aLocale);
                    break;
                }
            }
        }
        if (cal == null) {
            // If no known calendar type is explicitly specified,
            // perform the traditional way to create a Calendar:
            // create a BuddhistCalendar for th_TH locale,
            // a JapaneseImperialCalendar for ja_JP_JP locale, or
            // a GregorianCalendar for any other locales.
            // NOTE: The language, country and variant strings are interned.
            if (aLocale.getLanguage() == "th" && aLocale.getCountry() == "TH") {
                cal = new BuddhistCalendar(zone, aLocale);
            } else if (aLocale.getVariant() == "JP" && aLocale.getLanguage() == "ja"
                       && aLocale.getCountry() == "JP") {
                cal = new JapaneseImperialCalendar(zone, aLocale);
            } else {
                cal = new GregorianCalendar(zone, aLocale);
            }
        }
        return cal;
    }

Das obige ist der detaillierte Inhalt vonBeispielcode-Analyse für Java-Factory-Muster. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!