两种语言实现设计模式（C++和Java）（一：工厂模式）

本篇开始记录实现设计模式在工作中的两种常见语言上的实现。

本篇介绍最简单的工厂模式。

工厂模式有一种非常形象的描述，建立对象的类就如一个工厂，而需要被建立的对象就是一个个产品；在工厂中加工产品，使用产品的人，不用在乎产品是如何生产出来的。从软件开发的角度来说，这样就有效的降低了模块之间的耦合。

使用情景：

在不确定会有多少个处理操作时应该考虑使用简单工厂模式，如针对同样的接收到的数据，处理的逻辑可能会不同，可能以后还会增加新的操作。

案例：

如果实现计算器的功能时，对于同样的输入数据，可能执行加、减、乘、除，甚至其他的功能。因此可以抽象出一个操作的抽象类或是接口，提供一个统一的处理方法(此处为process)，然后每种操作创建出一个子类出来。而判断具体使用哪个具体的实现类是在工厂类中进行判断的(将存放操作的变量传递给工厂的生产方法)。工厂类始终返回的是这个抽象类，这样如果对原有功能进行更改或是新添加新的功能，也不会对原来的其他类做修改，只编译修改的那个类或是新的类就可以了。

这样就做到了把耦合降到最低，同时也便于维护。

简单工厂：针对同样的数据，不同的操作用同一个接口

工厂方法：针对同样的数据，不同的操作用不同的接口

抽象工厂：针对不同的数据，不同的操作用不同的接口

一：简单工厂模式

1.简单工厂C++中的实现：

 1 #include <iostream>
 2 
 3 using namespace std;
 4 
 5 class ICarFactory{
 6 public:
 7     ICarFactory(){}
 8     virtual ~ICarFactory(){}
 9     virtual void produceCar() = 0;
10 };
11 
12 class CarFactoryBenz:public ICarFactory{
13 public:
14     void produceCar(){
15         cout<<"Produce a car of Benz"<<endl;
16     }
17 };
18 
19 class CarFactoryVolkswagen: public ICarFactory{
20 public:
21     void produceCar(){
22         cout<<"Produce a car of Volkswagen"<<endl;
23     }
24 };
25 
26 int main()
27 {
28     ICarFactory *car1 = new CarFactoryBenz();
29     ICarFactory *car2 = new CarFactoryVolkswagen();
30     car1->produceCar();
31     car2->produceCar();
32     return 0;
33 }

2.简单工厂Java中的实现：

 1 public interface ICarFactory {
 2     public void produceCar();
 3 }
 4 
 5 public class FactoryBenz implements ICarFactory{
 6 
 7     public void produceCar() {
 8         System.out.println("Produce a car of Benz");
 9     }
10 }
11 
12 public class FactoryToyota implements ICarFactory{
13     public void produceCar() {
14         System.out.println("Produce a car of Toyota");
15     }
16 }
17 
18 public class Main {
19 
20     public static void main(String[] args){
21         FactoryBenz factoryBenz = new FactoryBenz();
22         FactoryToyota factoryToyota = new FactoryToyota();
23         factoryBenz.produceCar();
24         factoryToyota.produceCar();
25     }
26 
27 }

二：工厂方法模式

1.工厂方法模式在C++中的实现

核心思想：将工厂抽象出来，将产品抽象出来，子工厂负责new 子产品指针，返回抽象产品类指针，外面调用时只需要生成基类工厂指针，调用创建产品函数，就可以对该产品进行具体的操作，优点是能够将添加产品完全独立出来不再修改内部代码。

与简单工厂比较：修正了简单工厂模式中不遵循开放---封闭原则，例如添加新产品时仍需要修改工厂基类内容，工厂方法模式将判断移动到客户端实现。

 1 #include <iostream>
 2 
 3 using namespace std;
 4 
 5 class ICar{
 6 public:
 7     ICar(void){}
 8     ~ICar(void){}
 9     virtual void printInfo() = 0;
10 };
11 
12 class CarBenz:public ICar{
13 public:
14     CarBenz(){}
15     ~CarBenz(){}
16     void printInfo(){
17         cout<<"The brand is Benz"<<endl;
18     }
19 };
20 
21 class CarToyota:public ICar{
22 public:
23     CarToyota(){}
24     ~CarToyota(){}
25     void printInfo(){
26         cout<<"The brand is Toyota"<<endl;
27     }
28 };
29 
30 class IFactory{
31 public:
32     IFactory(void){}
33     ~IFactory(void){}
34     virtual ICar* produceCar() = 0;
35 };
36 
37 class FactoryBenz:public IFactory{
38 public:
39     FactoryBenz(){}
40     ~FactoryBenz(){}
41     ICar* produceCar(){
42         cout<<"Produce a car of Benz"<<endl;
43         ICar* car = new CarBenz();
44         return car;
45     }
46 };
47 
48 class FactoryToyota:public IFactory{
49 public:
50     FactoryToyota(){}
51     ~FactoryToyota(){}
52     ICar* produceCar(){
53         cout<<"Produce a car of Toyota"<<endl;
54         ICar* car = new CarToyota();
55         return car;
56     }
57 };
58 
59 int main()
60 {
61     IFactory* factory = new FactoryBenz();
62     ICar* car = factory->produceCar();
63     car->printInfo();
64     IFactory* factory2 = new FactoryToyota();
65     ICar* car2 = factory2   ->produceCar();
66     car2->printInfo();
67     return 0;
68 }

输出：

Produce a car of Benz

The brand is Benz

Produce a car of Toyota

The brand is Toyota

2.工厂方法模式在Java中的实现

 1 public interface ICar {
 2     void printInfo();
 3 }
 4 
 5 public class CarBenz implements ICar {
 6 
 7     public void printInfo(){
 8         System.out.println("The brand is Benz");
 9     }
10 }
11 
12 public class CarToyota implements ICar{
13 
14     public void printInfo(){
15         System.out.println("The brand is toyota");
16     }
17 
18 }
19 
20 public interface ICarFactory {
21     ICar produceCar();
22 }
23 
24 public class FactoryBenz implements ICarFactory{
25 
26     public ICar produceCar(){
27         System.out.println("Produce a Benz car");
28         return new CarBenz();
29     }
30 }
31 
32 public class FactoryToyota implements ICarFactory{
33 
34     public ICar produceCar(){
35         System.out.println("Produce a Toyota car");
36         return new CarToyota();
37     }
38 
39 }
40 
41 public class Main {
42 
43     public static void main(String[] args){
44         ICarFactory factoryBenz = new FactoryBenz();
45         ICarFactory factoryToyota = new FactoryToyota();
46 
47         ICar benz = factoryBenz.produceCar();
48         ICar toyota = factoryToyota.produceCar();
49 
50         benz.printInfo();
51         toyota.printInfo();
52 
53     }
54 }

输出：

Produce a Benz car
Produce a Toyota car
The brand is Benz
The brand is toyota

三：抽象工厂模式

1.C++实现抽象工厂

  1 #include <iostream>
  2 
  3 using namespace std;
  4 
  5 class ICarToyota{
  6 public:
  7     ICarToyota(){}
  8     ~ICarToyota(){}
  9     virtual void printInfo() = 0;
 10 };
 11 
 12 class CarToyotaChr:public ICarToyota{
 13 public:
 14     CarToyotaChr(){}
 15     ~CarToyotaChr(){}
 16     void printInfo(){
 17         cout<< "The car is Toyota C-HR"<<endl;
 18     }
 19 };
 20 
 21 class CarToyotaCarolla:public ICarToyota{
 22 public:
 23     CarToyotaCarolla(){}
 24     ~CarToyotaCarolla(){}
 25     void printInfo(){
 26         cout<< "The car is Toyota Carolla"<<endl;
 27     }
 28 };
 29 
 30 class ICarAudi{
 31 public:
 32     ICarAudi(){}
 33     ~ICarAudi(){}
 34     virtual void printInfo()=0;
 35 };
 36 
 37 class CarAudiA3:public ICarAudi{
 38 public:
 39     CarAudiA3(){}
 40     ~CarAudiA3(){}
 41     void printInfo(){
 42         cout<< "The car is audi a3"<<endl;
 43     }
 44 };
 45 
 46 class CarAudiQ5:public ICarAudi{
 47 public:
 48     CarAudiQ5(){}
 49     ~CarAudiQ5(){}
 50     void printInfo(){
 51         cout<< "The car is audi q5"<<endl;
 52     }
 53 };
 54 
 55 class IFactory{
 56 public:
 57     IFactory(){}
 58     ~IFactory(){}
 59     virtual ICarToyota* produceCarToyota()=0;
 60     virtual ICarAudi* produceCarAudi()=0;
 61 };
 62 
 63 class FactoryCompact:public IFactory{
 64 public:
 65     FactoryCompact(){}
 66     ~FactoryCompact(){}
 67     ICarAudi* produceCarAudi(){
 68         cout<<"Produce a audi compact car"<<endl;
 69         return new CarAudiA3;
 70     }
 71     ICarToyota* produceCarToyota(){
 72         cout<<"Produce a toyota compact car"<<endl;
 73         return new CarToyotaCarolla;
 74     }
 75 };
 76 
 77 class FactorySuv:public IFactory{
 78 public:
 79     FactorySuv(){}
 80     ~FactorySuv(){}
 81     ICarAudi* produceCarAudi(){
 82         cout<<"Produce a audi suv"<<endl;
 83         return new CarAudiQ5;
 84     }
 85     ICarToyota* produceCarToyota(){
 86         cout<<"Produce a toyota suv"<<endl;
 87         return new CarToyotaChr;
 88     }
 89 };
 90 
 91 int main()
 92 {
 93     FactoryCompact factory1;
 94     FactorySuv factory2;
 95     ICarAudi* audi1;
 96     ICarAudi* audi2;
 97     ICarToyota* toyota1;
 98     ICarToyota* toyota2;
 99     audi1 = factory1.produceCarAudi();
100     audi1->printInfo();
101     audi2 = factory2.produceCarAudi();
102     audi2->printInfo();
103     toyota1 = factory1.produceCarToyota();
104     toyota1->printInfo();
105     toyota2 = factory2.produceCarToyota();
106     toyota2->printInfo();
107 }

输出：

Produce a audi compact car

The car is audi a3

Produce a audi suv

The car is audi q5

Produce a toyota compact car

The car is Toyota Carolla

Produce a toyota suv

The car is Toyota C-HR

2.Java实现抽象工厂

 1 public interface ICarAudi {
 2     void printInfo();
 3 }
 4 
 5 public class CarAudiA3 implements ICarAudi {
 6     public void printInfo() {
 7         System.out.println("The car is Audi A3");
 8     }
 9 }
10 
11 public class CarAudiQ5 implements ICarAudi {
12     public void printInfo() {
13         System.out.println("The car is Audi Q5");
14     }
15 }
16 
17 public interface ICarToyota {
18     void printInfo();
19 }
20 
21 public class CarToyotaCarolla implements ICarToyota {
22     public void printInfo() {
23         System.out.println("The car is Toyota Carolla");
24     }
25 }
26 
27 public class CarToyotaChr implements ICarToyota {
28     public void printInfo() {
29         System.out.println("The vehicle is toyota C-HR");
30     }
31 }
32 
33 public interface IFactory {
34     ICarAudi produceAudi();
35     ICarToyota produceToyota();
36 }
37 
38 public class FactoryCompact implements IFactory {
39     public ICarAudi produceAudi() {
40         System.out.println("Produce an audi compact");
41         return new CarAudiA3();
42     }
43 
44     public ICarToyota produceToyota() {
45         System.out.println("Produce a toyota compact");
46         return new CarToyotaCarolla();
47     }
48 }
49 
50 public class FactoryCompact implements IFactory {
51     public ICarAudi produceAudi() {
52         System.out.println("Produce an audi compact");
53         return new CarAudiA3();
54     }
55 
56     public ICarToyota produceToyota() {
57         System.out.println("Produce a toyota compact");
58         return new CarToyotaCarolla();
59     }
60 }
61 
62 
63 public class Main {
64 
65     public static void main(String[] args){
66         FactoryCompact factoryCompact = new FactoryCompact();
67         FactorySuv factorySuv = new FactorySuv();
68         ICarAudi c1 = factoryCompact.produceAudi();
69         c1.printInfo();
70         ICarAudi c2 = factorySuv.produceAudi();
71         c2.printInfo();
72         ICarToyota c3 = factoryCompact.produceToyota();
73         c3.printInfo();
74         ICarToyota c4 = factorySuv.produceToyota();
75         c4.printInfo();
76     }
77 
78 }

输出：

Produce an audi compact
The car is Audi A3
Produce an audi suv
The car is Audi Q5
Produce a toyota compact
The car is Toyota Carolla
Produce an Toyota suv
The vehicle is toyota C-HR

posted @ 2019-04-19 19:42 Asp1rant 阅读(407) 评论(0) 编辑收藏举报

会员力量，点亮园子希望

刷新页面返回顶部

Asp1rant

两种语言实现设计模式（C++和Java）（一：工厂模式）

公告