【设计模式】——抽象工厂Abstract Factory工厂模式。

模式图

  提供靶的应用接口,隐藏对象的创办过程。

怕是时间一模一样长远而来混了简短工厂模式、工厂方法模式及虚幻工厂模式,还是输出一下咔嚓。这几乎种植模式说简练,倒是真的容易,就是友善怎么利用到平日档面临失去,这点给自家杀是头疼
。这首文章我非会见生细致地代码UML图相结合来介绍这几乎种模式,如果是小白,可以看就员四月葡萄
写的Android的设计模式,可以说凡是老大友好全面了,今天自家第一就啰嗦两词我觉得要之触发,以便以后一看就是记起。

模式组织

图片 1

AbstractFactory 提供创建对象的接口。

ConcreteFactory 提供真正创建对象的实现类,用于组合并创建不同的对象,实现一个产品族。

AbstractProduct 提供对象的使用接口。

ConcreteProduct 提供真正的适用对象,隐藏该对象的创建过程,是工厂创建的对象。

Client 使用者,通过抽象工厂接口,使用不同的具体工厂方法创建对象组合,从而直接使用对象,无需关注对象的创建过程。

 

(一)简单工厂模式

优点是代码解耦,创建实例的做事与祭实例的行事分别,使用者不必关心类对象如何创造。

简工厂模式有一个极度特别的题材——一旦现在接口的子类增加了,那么工厂类肯定用改,这样违反了开闭原则(OCP)。因此得以应用反射来创造实例对象。

packagecn.mldn.demo;
interface Fruit {
    public void eat() ;
}

class Apple implements Fruit {
    public void eat() {
        System.out.println("吃苹果。");
    };
}

class Orange implements Fruit {
    public void eat() {
        System.out.println("吃橘子。");
    };
}

class Factory {

    public static <T extends Fruit> T create(Class<T> clz) {
        Fruit f = null;
        try{
            //看这儿看这儿~反射出实例
            f = (Fruit) Class.forName(clz.getName()).newInstance() ;
        } catch(Exception e) {
            e.printStackTrace();
        }
        return (T)f ;
    }
}

public class FactoryDemo {
    public static void main(String[] args) {
        //调用方式
        Factory.create(Orange.class).eat();
        Factory.create(Apple.class).eat();
    }
}

下反射后哪怕多了接口的子类,工厂类还是可以成功目标的实例化操作,这个才是当真的厂类,可以答应于持有的扭转。但就此反射的话,性能是一个题材,反射相当给同多级解释操作,通知jvm要召开的事务,性能比直接的java代码要磨磨蹭蹭很多。且不安全,通过反射机制我们能拿到接近的个人成员

原先自己对简易工厂模式特别有偏见,因为觉得她违反开闭原则的弱项实在是绝显眼了。而于骨子里项目面临我哉会刻画来缺点很明显的代码,很气,但就是无晓怎么改善。或许我事先这么鄙视简单工厂模式,其实是于薄写臭臭代码的友爱呀。只能多读多思量了。而且简工厂模式真的是出其亮点的远在的呀,创建实例的做事以及祭实例的行事分别~
参考:Java的反射机制

副场景

  1
系统独立于它们的出品创建、组合和象征。即无论是需关注内部对象时怎么创造的,怎么开创的,什么意义。

  2
体系要多个产品组合中之一个布置。由于目标多,能够成有之重组非常多,而网只是使用某个一个构成。

  3 强调的靶子的组成结果,而非是她们实际的接口及贯彻。

 

(二)工厂方法模式

不要紧值得说之,拷贝一个UML图下吓了。工厂方法模式每个工厂只能创造同种植档次的产品。

工厂方法模式UML类图

工厂方法模式有抽象工厂类,简单工厂模式尚未抽象工厂类都该工厂类的厂方法是静态的

代码结构

  AbstractFactory.java

interface AbstractFactory {
    public AbstractProductA CreateProductA();
    public AbstractProductB CreateProductB();
}

  ConcreteFactory.java

class ConcreteFactory1 implements AbstractFactory{

    @Override
    public AbstractProductA CreateProductA() {
        return new ConcreteProductA1();
    }

    @Override
    public AbstractProductB CreateProductB() {
        return new ConcreteProductB1();
    }

}

  AbstractProduct.java

interface AbstractProductA {
    public void use();
}
interface AbstractProductB {
    public void use();
}

  ConcreteProduct.java

class ConcreteProductA1 implements AbstractProductA{

    @Override
    public void use() {
        // TODO Auto-generated method stub
        System.out.println("use A1 product!");
    }

}
class ConcreteProductB1 implements AbstractProductB{

    @Override
    public void use() {
        // TODO Auto-generated method stub
        System.out.println("use B1 product!");
    }

}

  使用方法

    public static void main(String[] args){
        AbstractProductA pa;
        AbstractProductB pb;

        AbstractFactory fa1 = new ConcreteFactory1();
        pa = fa1.CreateProductA();
        pb = fa1.CreateProductB();
        pa.use();
        pb.use();

        AbstractFactory fa2 = new ConcreteFactory2();
        pa = fa2.CreateProductA();
        pb = fa2.CreateProductB();
        pa.use();
        pb.use();

    }

  全部代码

图片 2图片 3

 1 package com.designer;
 2 interface AbstractFactory {
 3     public AbstractProductA CreateProductA();
 4     public AbstractProductB CreateProductB();
 5 }
 6 interface AbstractProductA {
 7     public void use();
 8 }
 9 interface AbstractProductB {
10     public void use();
11 }
12 class ConcreteFactory1 implements AbstractFactory{
13 
14     @Override
15     public AbstractProductA CreateProductA() {
16         return new ConcreteProductA1();
17     }
18 
19     @Override
20     public AbstractProductB CreateProductB() {
21         return new ConcreteProductB1();
22     }
23 
24 }
25 class ConcreteFactory2 implements AbstractFactory{
26 
27     @Override
28     public AbstractProductA CreateProductA() {
29         return new ConcreteProductA2();
30     }
31 
32     @Override
33     public AbstractProductB CreateProductB() {
34         return new ConcreteProductB2();
35     }
36 
37 }
38 class ConcreteProductA1 implements AbstractProductA{
39 
40     @Override
41     public void use() {
42         // TODO Auto-generated method stub
43         System.out.println("use A1 product!");
44     }
45 
46 }
47 class ConcreteProductA2 implements AbstractProductA{
48 
49     @Override
50     public void use() {
51         // TODO Auto-generated method stub
52         System.out.println("use A2 product!");
53     }
54 
55 }
56 class ConcreteProductB1 implements AbstractProductB{
57 
58     @Override
59     public void use() {
60         // TODO Auto-generated method stub
61         System.out.println("use B1 product!");
62     }
63 
64 }
65 class ConcreteProductB2 implements AbstractProductB{
66 
67     @Override
68     public void use() {
69         // TODO Auto-generated method stub
70         System.out.println("use B2 product!");
71     }
72 
73 }
74 public class Client {
75     public static void main(String[] args){
76         AbstractProductA pa;
77         AbstractProductB pb;
78         
79         AbstractFactory fa1 = new ConcreteFactory1();
80         pa = fa1.CreateProductA();
81         pb = fa1.CreateProductB();
82         pa.use();
83         pb.use();
84         
85         AbstractFactory fa2 = new ConcreteFactory2();
86         pa = fa2.CreateProductA();
87         pb = fa2.CreateProductB();
88         pa.use();
89         pb.use();
90         
91     }
92 }

View Code

(三)抽象工厂模式

泛泛工厂模式UML

事实上大家看就图,很容易好扣押下要多新的成品,抽象工厂模式需改抽象工厂和有着的求实工厂,也违背了开闭原则。这便是纸上谈兵工厂模式之紧缺点了。

相比一下厂子方法模式及虚幻工厂模式——

当厂方法模式中切实工厂负责生产实际的产品,每一个切实工厂对许一律种植具体产品,工厂方法有唯一性。架空工厂模式则好能创立多种类型的制品,应用场景也生育多单产品组合的靶子。抽象工厂模式代码解耦,创建实例的做事和以实例的行事分别,使用者不必关心类对象如何创造。

温故知新。工厂模式的初衷是解耦解耦解耦,创建实例的行事和行使实例的办事分别,使用者不必关心类对象如何创建。

参考:
Android
设计模式之各种工厂方法模式

存备受之设计模式

  在生活中,我们经常会遇到以同一多级东西的上。比如,我们甘愿吃炸鸡配啤酒,喜欢吃爆米花配可乐。我们不体贴炸鸡怎么炸的,啤酒怎么酿的,爆米花怎么爆的,而只关心我们吃啊,喝啊,这即是卓越的泛工厂。 

  例如,大部分程序猿们都来吃早餐的惯,当然多人喜欢睡懒觉也来不及吃,但是以身体健康,还是如按时吃饭才行!扯远了…

图片 4

  有人爱吃中式的,有人喜欢吃西式的。那么去餐饮店我们不会见错过咨询,包子怎么开的,面包怎么烤的,仅仅是付费吃饭而已。而榜上有名一般是豆浆油条,西式面包牛奶。这种搭配都形成了同样栽习惯,也就算是默认的产品组合。

图片 5

  因此,我们以进就时,只要指定早餐的体裁,就可了。下面就是是咱吃早餐,使用早餐工厂的流程…

interface BreakfastFactory{
    public StapleFood MakeStapleFood();
    public Drinks MakeDrinks();
}
interface StapleFood{
    public void eating();
}
interface Drinks{
    public void drinking();
}
class BreakfastCStyle implements BreakfastFactory{

    @Override
    public StapleFood MakeStapleFood() {
        return new DeepFriedDoughSticks();
    }

    @Override
    public Drinks MakeDrinks() {
        return new SoybeanMilk();
    }

}
class BreakfastWStyle implements BreakfastFactory {

    @Override
    public StapleFood MakeStapleFood() {
        return new Bread();
    }

    @Override
    public Drinks MakeDrinks() {
        return new Milk();
    }

}
class DeepFriedDoughSticks implements StapleFood{
    @Override
    public void eating() {
        System.out.println("我在吃油条!...");
    }
}
class SoybeanMilk implements Drinks{
    @Override
    public void drinking() {
        System.out.println("我在喝豆浆!...");
    }
}
class Bread implements StapleFood{
    @Override
    public void eating() {
        System.out.println("我在吃面包!...");
    }
}
class Milk implements Drinks{
    @Override
    public void drinking() {
        System.out.println("我在喝牛奶!...");
    }
}
public class Breakfast{
    public static void main(String[] args){
        StapleFood sf;
        Drinks dk;
        System.out.println("——————————————————第一天——————————————————————————");
        System.out.println("我要吃中式早餐");
        BreakfastFactory bf1 = new BreakfastCStyle();
        sf = bf1.MakeStapleFood();
        dk = bf1.MakeDrinks();
        sf.eating();
        dk.drinking();
        System.out.println("——————————————————第二天——————————————————————————");
        System.out.println("我要吃西式早餐");
        BreakfastFactory bf2 = new BreakfastWStyle();
        sf = bf2.MakeStapleFood();
        dk = bf2.MakeDrinks();
        sf.eating();
        dk.drinking();
    }
}

  可以见到,非常便于的饶迟到了取和西式的早饭,而省掉了大量炸油长达,烤面包的日子。

——————————————————第一天——————————————————————————
我要吃中式早餐
我在吃油条!...
我在喝豆浆!...
——————————————————第二天——————————————————————————
我要吃西式早餐
我在吃面包!...
我在喝牛奶!...

  这即是一个简练的虚幻工厂的下。

【转载声明】: by
xingoo

相关文章