Java设计模式编程中简单工厂与抽象工厂模式的使用实例

时间:2021-07-29 04:19:38

简单工厂模式
类图

Java设计模式编程中简单工厂与抽象工厂模式的使用实例

通过一个工厂类,以一个条件来创建对应的对象

?
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
//业务功能
public interface ICalculation {
  double getResult(double numA, double numB);
}
 
public class CalcAdd implements ICalculation {
 
  @Override
  public double getResult(double numA, double numB) {
    System.out.println("加法");
    return numA + numB;
  }
 
}
 
public class CalcSubtract implements ICalculation {
 
  @Override
  public double getResult(double numA, double numB) {
    System.out.println("减法");
    return numA - numB;
  }
 
}
 
/*
 * 简单工厂模式 关注:对象的创建
 * 建立一个工厂类,对实现了同一接口的或者是存在继承关系的一些类进行实例的创建
 */
public class Test4Simple {
  public static void main(String[] args) {
//   String operation = "/";
    String operation = "+";
//   String operation = "-";
//   String operation = "*";
    double numA = 182, numB = 33;
    ICalculation createCalc = CalcSimpleFactory.createCalc(operation);
    double result = createCalc.getResult(numA, numB);
    System.out.println(result);
  }
}

简单工厂的缺陷: 简单工厂创建产品时需要传递相应的参数,如果传递不正确就取不到对象了。
改进:多方法创建不同产品
类图

Java设计模式编程中简单工厂与抽象工厂模式的使用实例

?
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
public class CalcMultipleFactory {
   
  public static ICalculation produceAdd() {
    return new CalcAdd();
  }
   
  public static ICalculation produceSubtract() {
    return new CalcSubtract();
  }
   
  public static ICalculation produceMultiply() {
    return new CalcMultiply();
  }
   
  public static ICalculation produceDivide() {
    return new CalcDivide();
  }
}
 
public class Test4Multiple {
 
  public static void main(String[] args) {
    double numA = 182, numB = 33;
     
    ICalculation createCalc = CalcMultipleFactory.produceAdd();
    double result = createCalc.getResult(numA, numB);
    System.out.println(result);
     
    createCalc = CalcMultipleFactory.produceSubtract();
    result = createCalc.getResult(numA, numB);
    System.out.println(result);
     
    createCalc = CalcMultipleFactory.produceMultiply();
    result = createCalc.getResult(numA, numB);
    System.out.println(result);
     
    createCalc = CalcMultipleFactory.produceDivide();
    result = createCalc.getResult(numA, numB);
    System.out.println(result);
  }
}

抽象工厂模式
里面有几个概念:抽象工厂、实体工厂、抽象产品、实体产品
抽象工厂:定义创建产品的抽象方法
实体工厂:具体的创建哪种产品
抽象产品:一个接口或基类
实体产品:实现具体功能,或派生
类图

Java设计模式编程中简单工厂与抽象工厂模式的使用实例

?
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
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
//抽象产品1
public interface IProduct1 {
  public void show();
}
 
//抽象产品2
public interface IProduct2 {
  public void show();
}
 
//实体产品1
public class Product1 implements IProduct1 { 
  public void show() { 
    System.out.println("创建了1型产品"); 
  
 
//实体产品2
public class Product2 implements IProduct2 {
  public void show() {
    System.out.println("创建了2型产品");
  }
}
 
/*
 * 1A 1B属于Product1 同一产品等级结构中
 * 2A 2B属于Product2
 */
public class GradeProduct1A extends Product1 {
 
  @Override
  public void show() {
    super.show();
    System.out.println("这是产品1下的:产品A");
  }
   
}
 
public class GradeProduct1B extends Product1 {
 
  @Override
  public void show() {
    super.show();
    System.out.println("这是产品1下的:产品B");
  }
}
 
public class GradeProduct2A extends Product2 {
 
  @Override
  public void show() {
    super.show();
    System.out.println("这是产品2下的:产品A");
  }
}
 
public class GradeProduct2B extends Product2 {
 
  @Override
  public void show() {
    super.show();
    System.out.println("这是产品2下的:产品B");
  }
}
 
//抽象工厂 创建不同的抽象产品
public interface IFactory {
  public IProduct1 createProduct1A();//1类产品 型号A
  public IProduct1 createProduct1B();//1类产品 型号B
  public IProduct2 createProduct2A();//2类产品 型号A
  public IProduct2 createProduct2B();//2类产品 型号B
}
 
//实体工厂 创建实体产品,返回类型为抽象产品
public class Factory implements IFactory {
 
  public IProduct1 createProduct1A() {
    return new GradeProduct1A();
  }
 
  public IProduct1 createProduct1B() {
    return new GradeProduct1B();
  }
 
  public IProduct2 createProduct2A() {
    return new GradeProduct2A();
  }
 
  public IProduct2 createProduct2B() {
    return new GradeProduct2B();
  }
}
 
/*
 * 抽象工厂模式:用来创建一组相关或者相互依赖的对象
 *
 * 流程:抽象工厂,实体工厂   生产产品
 *   抽象产品,实体产品    实现产品功能
 * 缺点:当需要增加一个产品(由抽象和实体构成),工厂都需要更改
 */
public class Test4Abstract {
  public static void main(String[] args) {
    IFactory factory = new Factory();
    IProduct1 product1a = factory.createProduct1A();
    product1a.show();
    IProduct1 product1b = factory.createProduct1B();
    product1b.show();
     
    IProduct2 product2a = factory.createProduct2A();
    product2a.show();
    IProduct2 product2b = factory.createProduct2B();
    product2b.show();
  }
}