Java设计模式之工厂模式

发表于 | 分类于 | | 阅读次数

前言

一、设计模式的分类

总体来说设计模式分为三大类：

创建型模式，共五种：工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式。

结构型模式，共七种：适配器模式、装饰器模式、代理模式、外观模式、桥接模式、组合模式、享元模式。

行为型模式，共十一种：策略模式、模板方法模式、观察者模式、迭代子模式、责任链模式、命令模式、备忘录模式、状态模式、访问者模式、中介者模式、解释器模式。

其实还有两类：并发型模式和线程池模式。

二、设计模式的六大原则

1.开闭原则:对扩展开放，对修改关闭。所以我们要尽可能面向接口编程，而不是面向实现编程。

2.里氏代换原则:里氏代换是对开闭原则的补充,实现开闭原则的关键是抽象编程，而子类和基类是实现具体化的步骤。所以里氏代换是对具体化的规范。

3.依赖倒转:针对接口编程，依赖于抽象而不依赖于具体。

4.迪米特法则(最少知道):每个类应该尽可能少的和其他类有联系，就是平时所说的低耦合，使得系统功能模块相对独立。

5.合成复用模式:尽可能使用组合模式，而不是使用集成。

接下来将学习大部分的设计模式!

正文


这次要学习的是工厂模式

工厂模式总共有三种: 简单工厂模式、抽象工厂方法模式、抽象工厂模式。

1.首先来说说简单工厂模式，先看UML图

logo

工厂根据produce方法传进的type来确定生产的是什么车，但是返回的类型并不是具体的车，而是那些具体类的接口。

具体代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
public interface Car{
  void describe();
}
//宝马
public class BMW implements Car{
  public void describe(){
    System.out.println("Yep,this is BMW");
  }
}
//奔驰
public class Benz implements Car{
  public void describe(){
    System.out.println("Wow, this is Benz");
  }
}
//工厂
public class CarFactory{
  public Car produceCar(String carType){
     Car car = null;
     switch(carType){
       case "BMW":
          car = new BMW();
          break;
       case "Benz":
          car = new Benz();
          break;
     }
     return Car;
  }
}

2.工厂方法模式

一个抽象产品类，可以派生出多个具体产品类。
一个抽象工厂类，可以派生出多个具体工厂类。
每个具体工厂类只能创建一个具体产品类的实例。

UML图
logo

具体代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
//抽象工厂
public interface Factory{
  Car produce();
}
//宝马生产工厂
public class BMWFactory implements Factory{
  public Car produce(){
    return new BMW();
  }
}
//奔驰生产工厂
public class BenzFactory implements Factory{
  public Car produce(){
    return new BenzFactory();
  }
}
//抽象类汽车
public interface Car{
   void describe();
}
//宝马
public class Car implements Car{
  void describe(){
    System.out.println("BWM!!!");
  }
}
//奔驰
public class Benz implements Car{
  void describe(){
    System.out.println("Benz!!!!");
  }
}
//程序入口
public static void main(String[] args){
  //生产宝马
  Factory bmwFactory = new BMWFactory();
  Car bmwCar = bmwFactory.produce();
  //生产奔驰
  Factory benzFactory = new BenzFactory();
  Car benzCar = benzFactory.produce();
}

3.抽象工厂模式

抽象工厂模式是工厂方法模式的进一步升级, 其英文原话”Provide an interface for creating families of related or dependent objects without specifying their concrete classes”,翻译，“为创建一组相关或相互依赖的对象提供一个借口，无需指定它们的具体类”。抽象工厂模式通常是用于创一族产品，并且这族产品分不同的等级；不同的具体工厂类生产不同等级的一族产品。抽象工厂模式也有四种角色：抽象工厂、具体工厂、抽象产品和具体产品。

UML图,还是拿汽车生产举例。

logo

具体代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
public interface Factory{
  BMW produceBMW();//生产宝马系列
  Benz produceBenz();//生产奔驰系列
}
//FactoryA生产BMW1和Benz1
public class FactoryA implements Factory{
  public BMW produceBMW(){
     return new BMW1();
  }
  public Benz produceBenz(){
    return new Benz1();
  }
}
//FactoryB生产BMW2和Benz2
public class FactoryB implements Factory{
  public BMW produceBMW(){
    return new BMW2();
  }
  public Benz produceBenz(){
    return new Benz2();
  }
}
//宝马车系列
interface BMW{
  void describe();
}
//奔驰系列
interface Benz{
  void describe();
}
//具体宝马车型号
public class BMW1 implements BMW{
  public void describe(){
    System.out.println("宝马1");
  }
}
public class BMW2 implements BMW{
  public void describe(){
    System.out.println("宝马2");
  }
}
//具体奔驰型号
public class Benz1 implements Benz{
  public void describe(){
    System.out.println("奔驰1");
}
public class Benz1 implements Benz{
  public void describe(){
    System.out.println("奔驰2");
  }
}
//程序入口
public class client{
  public static void main(String[] args){
    Factory factoryA = new FactoryA();
    factoryA.produceBMW();
    factoryA.produceBenz();
    Factory factoryB = new FactoryB();
    factoryB.produceBMW();
    factoryB.produceBenz();
  }
}

好了，工厂模式的三种形式就说到这了!