工厂设计模式

佚名 5年前 (2019-04-23) 随笔 1629人围观抢沙发百度已收录

简单工厂模式：

　　简单工厂模式又叫做静态工厂（Static Factory）模式，但不属于23种GOF设计模式之一。简单工厂模式是根据传入的参数决定创建出哪一种产品类的实例。简单工厂模式是工厂模式家族中最简单但最实用的模式。

下面以生产车的工厂案例来展示简单工厂模式：

SRE实战互联网时代守护先锋，助力企业售后服务体系运筹帷幄！一键直达领取阿里云限量特价优惠。

//抽象产品类
public interface Car {
    void run();
}

//具体产品类
public class Audi implements  Car {
    @Override
    public void run() {
        System.out.println("奥迪runing");
    }
}

//具体产品类
public class Byd implements Car {
    @Override
    public void run() {
        System.out.println("比亚迪runing");
    }
}

//生产车的工厂类
public class CarFactory {

    public static Car createCar(String type) {
        if("奥迪".equals(type)) {
            return  new Audi();
        }else if ("比亚迪".equals(type)) {
            return new Byd();
        }else {
            return null;
        }
    }
}

//调用者类
public class FactoryDemo01 {

    public static void main(String[] args) {
        Car c1 = CarFactory.createCar("奥迪");
        Car c2 = CarFactory.createCar("比亚迪");
        c1.run();
        c2.run();
    }
}

工厂方法模式：　　

　　由于简单工厂模式对于增加新产品无能为力，不修改代码的话，无法扩展，也就是不完全符合开闭原则。工厂方法模式可以避免这个缺点，工厂方法模式和简单工厂模式最大的不同在于，简单工厂模式只有一个（对于一个项目或者一个独立模块而言）工厂类，而工厂方法模式有一组实现了相同接口的工厂类。

 1 //抽象工厂类
 2 public interface CarFactorys {
 3     Car createCar();
 4 }
 5 
 6 //抽象产品类
 7 public interface Car {
 8     void run();
 9 }
10 
11 //具体工厂类
12 public class AudiFactory implements CarFactorys {
13     @Override
14     public Car createCar() {
15         return new Audi();
16     }
17 }
18 
19 //具体工厂类
20 public class BydFactory implements CarFactorys {
21     @Override
22     public Car createCar() {
23         return new Byd();
24     }
25 }
26 
27 //调用者类
28 public class FactoryDemo2 {
29 
30     public static void main(String[] args) {
31         Car c1 = new AudiFactory().createCar();
32         Car c2 = new BydFactory().createCar();
33         c1.run();
34         c2.run();
35     }
36 }

简单工厂模式和工厂方法模式比较：

结构复杂度：

　　　　从这个角度看，简单工厂模式显然更占优势，因为它只需一个工厂类，而工厂方法需要为每个产品类设置工厂类，这无疑使类的个数越来越多，从而导致结构更复杂。

代码复杂度：

　　　　代码复杂度和结构复杂度是一对矛盾，简单工厂模式的工厂类随着产品类的增加需要增加很多方法，而工厂方法模式每个具体工厂类只完成单一任务，代码简洁。

客户端编程难度：

　　　　工厂方法模式虽然在工厂类结构中引入了接口从而满足了开闭原则，但是在客户端编码中需要对工厂类进行实例化，而简单工厂模式的工厂类是个静态类，在客户端无需实例　　　　　　　　　　　　化，这无疑是个吸引人的优点。

管理上的难度：

　　　　首先从扩展性上来说，工厂方法模式完全满足开闭原则，即拥有非常良好的扩展性，那是否说明简单工厂模式就没有扩展性呢？答案是否定的，简单工厂模式同样具备良好的扩展性--扩展的时候仅需修改少了代码（工厂类的代码）就可以达到扩展的要求然后从维护性上来说，假如某个具体产品类需要进行一定的修改，很可能需要修改对应的工厂类。当同时需要修改多个产品类的时候，对工厂类的修改会变得相当麻烦，反而简单工厂没有这些麻烦，当多个产品类需要修改时，简单工厂模式仍然仅需修改唯一的工厂类。

选择：根据设计理论建议是选择工厂方法模式，但实际上，一般是用简单工厂模式。

抽象工厂模式：

用来生产不同产品族的全部产品（对于增加新的产品无能为力，支持增加产品族）
抽象工厂模式是工厂方法的升级版，在有多个业务品种、业务分类时，通过抽象工厂模式产生需要的对象是一种非常好的解决方式。

  1 //抽象产品类
  2 public interface Engine {
  3 
  4     void run();
  5     void start();
  6 }
  7 
  8 //具体产品类
  9 class LuxuryEngine implements Engine{
 10     @Override
 11     public void run() {
 12 
 13         System.out.println("转的飞快");
 14     }
 15     @Override
 16     public void start() {
 17 
 18         System.out.println("启动快！");
 19     }
 20 }
 21 
 22 //具体产品类
 23 class LowEngine implements Engine{
 24 
 25     @Override
 26     public void run() {
 27         System.out.println("转的慢");
 28     }
 29 
 30     @Override
 31     public void start() {
 32         System.out.println("启动慢！");
 33     }
 34     
 35 }
 36 
 37 //抽象产品类
 38 public interface Seat {
 39 
 40     void massage();
 41 }
 42 
 43 //具体产品类
 44 class LuxurySeat implements Seat{
 45     @Override
 46     public void massage() {
 47         System.out.println("可以自动按摩");
 48     }
 49 }
 50 
 51 //具体产品类
 52 class LowSeat implements Seat{
 53     @Override
 54     public void massage() {
 55         System.out.println("不能按摩！");
 56     }
 57 }
 58 
 59 //抽象产品类
 60 public interface Tyre {
 61     void revolve();
 62 }
 63 
 64 //具体产品类
 65 class LuxuryTyre implements Tyre{
 66     @Override
 67     public void revolve() {
 68         System.out.println("橡胶耐磨！");
 69     }
 70 }
 71 
 72 //具体产品类
 73 class LowTyre implements Tyre{
 74     @Override
 75     public void revolve() {
 76         System.out.println("橡胶磨损快！");
 77     }
 78 }
 79 
 80 //抽象工厂类
 81 public interface CarFactory {
 82 
 83     Engine createEngine();
 84     Seat createSeat();
 85     Tyre createTyre();
 86 }
 87 
 88 //具体工厂类（生产的是一个产品族）
 89 public class LowCarFactory implements CarFactory{
 90     @Override
 91     public Engine createEngine() {
 92         return new LowEngine();
 93     }
 94     
 95     @Override
 96     public Seat createSeat() {
 97         return new LowSeat();
 98     }
 99     
100     @Override
101     public Tyre createTyre() {
102         return new LowTyre();
103     }
104 }
105 
106 //具体工厂类（生产的是一个产品族）
107 public class LuxuryCarFactory implements CarFactory{
108 
109     @Override
110     public Engine createEngine() {
111         return new LuxuryEngine();
112     }
113 
114     @Override
115     public Seat createSeat() {
116         return new LuxurySeat();
117     }
118 
119     @Override
120     public Tyre createTyre() {
121         return new LowTyre();
122     }
123 }
124 
125 //调用者类
126 public class Client {
127 
128     public static void main(String[] args) {
129         CarFactory factory = new LuxuryCarFactory();
130         Engine e = factory.createEngine();
131         e.run();
132         e.start();
133     }
134 }