Modèle d'usine abstraite
introduction de base
1) Une interface est définie pour créer un cluster d'objets liés ou dépendants sans spécifier la classe spécifique.2
) Le modèle de fabrique abstraite peut intégrer le modèle de fabrique simple et le modèle de méthode de fabrique .
3) Du point de vue de la conception , le modèle d'usine abstrait est une amélioration du modèle d'usine simple (ou appelé abstraction supplémentaire).
4) L' usine est abstraite en deux couches , AbsFactory (usine abstraite) et des sous-classes d'usine implémentées concrètement . Le programmeur peut utiliser la sous-classe d'usine correspondante en fonction du type d'objet créé . Cela transforme une classe d'usine simple en un cluster d'usine, ce qui est plus propice à la maintenance et à l'expansion du code.
Diagramme de classe
Le modèle abstrait d'usine complète le projet de pizza en
utilisant le diagramme de classe de M. Han de Shang Silicon Valley
L'amélioration est la suivante : Notre usine est abstraite en deux couches. Il s'agissait auparavant de commandes dans différentes régions, mais maintenant c'est une usine à différents endroits, mais il n'y a qu'une seule classe de commande. Différentes commandes sont complétées par différentes sous-classes d'implémentation d'usine.
Code
Tout d'abord, nos 5 pizzas
/**
* @author 王庆华
* @version 1.0
* @date 2020/12/21 20:06
* @Description TODO
* @pojectname 披萨抽象类 设置为抽象类
*/
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;
}
}
/**
* @author 王庆华
* @version 1.0
* @date 2020/12/25 20:47
* @Description TODO
* @pojectname 代码
*/
public class HNCheesePizza extends Pizza{
@Override
public void prepare() {
setName("河南的奶酪披萨");
System.out.println("给河南奶酪披萨准备原材料");
}
}
/**
* @author 王庆华
* @version 1.0
* @date 2020/12/25 20:49
* @Description TODO
* @pojectname 代码
*/
public class HNPepperPizza extends Pizza {
@Override
public void prepare() {
setName("河南的胡椒披萨");
System.out.println("给河南胡椒披萨准备原材料");
}
}
/**
* @author 王庆华
* @version 1.0
* @date 2020/12/25 20:47
* @Description TODO
* @pojectname 代码
*/
public class LDCheesePizza extends Pizza{
@Override
public void prepare() {
setName("伦敦的奶酪披萨");
System.out.println("给伦敦奶酪披萨准备原材料");
}
}
/**
* @author 王庆华
* @version 1.0
* @date 2020/12/25 20:47
* @Description TODO
* @pojectname 代码
*/
public class LDPepperPizza extends Pizza{
@Override
public void prepare() {
setName("伦敦的胡椒披萨");
System.out.println("给伦敦胡椒披萨准备原材料");
}
}
Ensuite, nous surveillons nos changements! ! !
Notre modèle de méthode d'usine est que la classe de commande est transformée en une classe abstraite et contient une méthode abstraite. Cette méthode abstraite est responsable de la création d'instances de différentes saveurs à différents endroits, n'est-ce pas?
Regardons notre modèle d'usine simple . Il définit une usine simple SimpleFactory pour lui permettre de créer des objets.
Alors regardez notre modèle d'usine abstrait
Tout d'abord , il définit une interface d'usine AbsFactory
/**
* @author 王庆华
* @version 1.0
* @date 2020/12/26 12:18
* @Description TODO
* @pojectname 抽象工厂模式的抽象层（接口）
*/
public interface AbsFactory {
//让下面的工厂子类具体实现创建什么种类的实例对象
public Pizza createPizza(String orderType);
}
Qu'il existe une méthode , qu'elle est utilisée pour créer différents goûts de différentes pizzerias , que notre usine est simple à réaliser leur propre classe, la méthode d'usine consiste à créer une sous-classe, et maintenant il est l'interface, le Qui l'a créé?
Ce sont les sous-catégories d'usine responsables de différents goûts dans différents endroits: HNFactory et LDFactory
/**
* @author 王庆华
* @version 1.0
* @date 2020/12/26 12:20
* @Description TODO
* @pojectname 河南工厂子类
*/
public class HNFactory implements AbsFactory {
@Override
public Pizza createPizza(String orderType) {
System.out.println("使用的是抽象工厂模式");
Pizza pizza = null;
if (orderType.equals("cheese")){
pizza = new HNCheesePizza();
}else if (orderType.equals("pepper")){
pizza = new HNPepperPizza();
}
return pizza;
}
}
/**
* @author 王庆华
* @version 1.0
* @date 2020/12/26 12:20
* @Description TODO
* @pojectname 伦敦工厂子类
*/
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;
}
}
Alors, que fait notre catégorie de commande ? Dans le modèle de méthode de fabrique précédent , différents objets d'instance étaient créés dans la commande . Ce travail est maintenant transféré à la sous-classe de fabrique. À quoi sert la commande?
/**
* @author 王庆华
* @version 1.0
* @date 2020/12/26 12:26
* @Description TODO
* @pojectname 订单代码
*/
public class OrderPizza {
AbsFactory factory;
//构造器
public OrderPizza(AbsFactory factory){
setFactory(factory);
}
//通过接口依赖
private void setFactory(AbsFactory factory){
Pizza pizza = null;
String orderType = "";//用户输入种类
this.factory = factory;
do {
orderType = getType();
// factory可能是北京的工厂子类，也可能是伦敦的工厂子类
pizza = factory.createPizza(orderType);
if (pizza!=null){
pizza.prepare();
pizza.bake();
pizza.cut();
pizza.box();
}else {
System.out.println("订购失败");
break;
}
}while (true);
}
//获取客户订购的披萨种类
private String getType(){
try {
BufferedReader strin = new BufferedReader(new InputStreamReader(System.in));
System.out.println("input pizza 种类:");
String str = strin.readLine();
return str;
} catch (IOException e) {
e.printStackTrace();
return "";
}
}
}
Nous avons constaté que le constructeur de la classe order a été passé dans un objet d'interface , et que l'interface ne peut pas être nouvelle, c'est donc équivalent à passer une classe d'implémentation de l'objet d'interface, c'est-à-dire HNFactory ou LDFactory ! C'est-à-dire que lorsque la classe de commande est initialisée, vous avez déjà la fabrique de quelle saveur à cet endroit . Dans la méthode setFactory de la classe de commande, pizza obtient le type de saveur et vous pouvez obtenir vos propres objets d'instance saveur dans différentes usines! ! !
/**
* @author 王庆华
* @version 1.0
* @date 2020/12/26 12:34
* @Description TODO
* @pojectname 代码
*/
public class PizzaStore {
public static void main(String[] args) {
new OrderPizza(new HNFactory());
}
}
Jusqu'à présent, notre modèle d'usine abstrait est complet
Analyse du code source et supplément
Par exemple, classe de calendrier de la classe java-util-Calendar
import java.util.Calendar;
/**
* @author 王庆华
* @version 1.0
* @date 2020/12/26 12:53
* @Description TODO
* @pojectname 工厂模式源码分析
*/
public class test {
public static void main(String[] args) {
Calendar cal = Calendar.getInstance();
System.out.println("年："+cal.get(Calendar.YEAR));
System.out.println("月："+(cal.get(Calendar.MONTH)+1));
System.out.println("日："+cal.get(Calendar.DAY_OF_MONTH));
System.out.println("时："+cal.get(Calendar.HOUR_OF_DAY));
System.out.println("分："+cal.get(Calendar.MINUTE));
System.out.println("分："+cal.get(Calendar.SECOND));
}
}
1. Notre calendrier pour créer une instance lorsque nous avons trouvé via le nom de classe .getInstance pour créer une instance , c'est-à-dire une méthode statique getInstance Calendar, nous sommes allés voir la source du point
public static Calendar getInstance()
{
return createCalendar(TimeZone.getDefault(), Locale.getDefault(Locale.Category.FORMAT));
}
Eh! ! ! J'ai trouvé qu'il appelait une méthode createCalendar. Contrairement à notre méthode createPizza, elle passe le fuseau horaire et ainsi de suite. On passe le goût, est-ce très similaire! ! 1
2. Cliquez sur la méthode createCalendar
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;
}
}
}
Nous ne prêtons attention qu'aux endroits qui nous intéressent, à certains endroits, peu importe si vous ne comprenez pas
Calendrier cal = null; prêt à créer une autre instance! ! !
Voyez comment il a créé ** if (aLocale.hasExtensions ()) {** pour déterminer quel est le suffixe
case "buddhis t":
cal = new BuddhistCalendar (zone, aLocale);
break; Est-ce pour créer différents objets d'instance basés sur différents suffixes, comme notre modèle de méthode d'usine! !