工厂设计模式(Factory Pattern)

描述： 工厂设计模式是用来生产对象的，在java中万般皆对象，如果创建的时候使用new 关键字会出现耦合严重，如果我们的对象名称换了那么所有出现此对象的地方都要进行修改。维护起来会十分的麻烦，所以就会使用工厂设计模式。

工厂设计模式的种类：

  • 简单工厂(Simple Factory Pattern)
  • 工厂方法(Factory Method)
  • 抽象工厂(Abstract Factory)
简单工厂设计模式(Simple Factory Pattern) /静态工厂方法

示例：

  • 电脑的抽象类
1
2
3
4
public  interface Computer {
     String getRAM();//内存
     String getCPU();//cpu
}
  • 联想电脑厂家
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
public class Lianxiang  implements  Computer{
    String ram;
    String cpu;
    public  Lianxiang(String ram,String cpu){
        this.cpu=cpu;
        this.ram=ram;
    }
    @Override
    public String getRAM() {
        return "联想的cpu是"+cpu;
    }
    @Override
    public String getCPU() {
        return "联想的ram是"+ram;
    }
}
  • 华为电脑厂家
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
public class Huawei implements   Computer {
    String ram;
    String cpu;
    public  Huawei(String ram,String cpu){
        this.cpu=cpu;
        this.ram=ram;
    }
    @Override
    public String getRAM() {
        return "华为的cpu是"+cpu;
    }
    @Override
    public String getCPU() {
        return "华为的ram是"+ram;
    }
}
  • 电脑工厂生产电脑对象
1
2
3
4
5
6
7
8
9
10
public class ComputerFactory {
    public  static Computer getComputer(String type,String cpu,String ram){
        if("Huawei".equals(type)){
            return  new Huawei(ram,cpu);
        }else if("Lianxiang".equals(type)){
            return  new Lianxiang(ram,cpu);
        }
        return  null;
    }
}
  • 客户端的调用
1
2
3
4
5
6
public class test {
    public static void main(String[] args) {
        Computer computer = ComputerFactory.getComputer("Huawei", "32G", "Inter");
        System.out.println(computer.getCPU()+computer.getRAM());
    }
}

优点： 上下解耦， 如联想的命名改变，则客户端是不需要知道的

缺点： 违反开闭原则，当我要增加一种品牌的电脑时休要修改工厂类，因此它只适用于产品对象较少的需求。

附图：

简单工厂设计模式UML

工厂方法设计模式(Factory Method)

描述： 主要用来创建单个产品的

示例：

  • 电脑的抽象类
1
2
3
4
public  interface Computer {
     String getRAM();
     String getCPU();
}
  • 电脑工厂的抽象
1
2
3
public interface ComputerFactory {
     Computer getComputer( String cpu, String ram);
}
  • 华为电脑厂家
1
2
3
4
5
6
7
8
9
10
11
12
13
14
public class Huawei implements Computer {
    String ram;
    String cpu;
    public  Huawei(String ram,String cpu){
        this.cpu=cpu;
        this.ram=ram;
    }
    public String getRAM() {
        return "华为的cpu是"+cpu;
    }
    public String getCPU() {
        return "华为的ram是"+ram;
    }
}
  • 电脑工厂生产华为电脑厂家
1
2
3
4
5
public class HuaweiFactory implements  ComputerFactory {
    public Computer getComputer(String cpu, String ram) {
        return new Huawei(ram , cpu);
    }
}
  • 客户端的调用
1
2
3
4
5
6
public static void main(String[] args) {
        HuaweiFactory huaweiFactory = new HuaweiFactory();
        Computer inter = huaweiFactory.getComputer("inter", "32G");
        System.out.println(inter);
    }
}

优点： 符合开闭原则 ， 上下解耦 。 如果要增加一个电脑工厂不用修改任何代码，直接实现Computer 和 ComputerFactory 即可

缺点： 如果电脑的厂家很多的话会造成类的爆炸式增长，

附图：

工厂方法设计模式UML

抽象工厂设计模式(Abstract Factory)

描述： 抽象工厂设计模式主要是用来创建 一系列的产品

应用场景： 当我们的一系列的产品簇趋向于稳定的时候，生产厂家可以变动，也就是华为只生产电脑和手机，不在扩展其他业务的时候使用它，而生产厂家可以有多个，不只华为一家

示例：

  • 各种类型电脑的抽象类
1
2
3
4
5
6
7
public interface DianNaoFactory {
//各种系列的电脑
    void hdiannao();
    void ldiannao();
    void qdiannao();
    void xdiannao();
}
  • 各种手机的抽象类
1
2
3
4
5
6
7
public interface ShowJiFactory {
   //各种系列的手机
    void p9shouji();
    void p3shouji();
    void p4shouji();
    void p8shouji();
}
  • 华为厂家造电脑
1
2
3
4
5
6
7
8
9
10
11
12
13
14
public class HuaweiDiaNao implements  DianNaoFactory {
    public void hdiannao() {
        System.out.println("h系类的电脑");
    }
    public void ldiannao() {
        System.out.println("l系类的电脑");
    }
    public void qdiannao() {
        System.out.println("q系类的电脑");
    }
    public void xdiannao() {
        System.out.println("x系类的电脑");
    }
}
  • 华为厂家造手机
1
2
3
4
5
6
7
8
9
10
11
12
13
14
public class HuaweiShouJi implements ShowJiFactory {
    public void p9shouji() {
        System.out.println("p9系类的手机");
    }
    public void p3shouji() {
        System.out.println("p3系类的手机");
    }
    public void p4shouji() {
        System.out.println("p4系类的手机");
    }
    public void p8shouji() {
        System.out.println("p8系类的手机");
    }
}
  • 电子产品类的 抽象接口
1
2
3
4
5
6
7
public interface JiadainFactory {
    //电脑的生产者
    DianNaoFactory   dianNaoFactory();
    //手机的生产者
    ShowJiFactory   showJiFactory();
}

  • 华为生产电子产品
1
2
3
4
5
6
7
8
public class Huawei implements  JiadainFactory{
    public DianNaoFactory dianNaoFactory() {
        return new HuaweiDiaNao() ;
    }
    public ShowJiFactory showJiFactory() {
        return new HuaweiShouJi();
    }
}
  • 客户端的调用
1
2
3
4
5
6
7
    public static void main(String[] args) {
        JiadainFactory jiadain = new Huawei();
             jiadain.dianNaoFactory().hdiannao();
             jiadain.showJiFactory().p3shouji();

    }
}

优点： 具体的产品代码隔离，无需关注创建的细节，将一个系列的产品在一起创建。也就是我们增加生产厂家的时候是很容易的。

缺点： 显而易见，当我们要怎加一个产平簇的时候是很麻烦的，我们要修改生产厂家的接口，违反开闭原则。

附图：

抽象工厂设计模式UML