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

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

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

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

使用情景：

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

案例：

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

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

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

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

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

一：简单工厂模式

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

 #include <iostream>

 using namespace std;

 class ICarFactory{
 public:
     ICarFactory(){}
     virtual ~ICarFactory(){}
     virtual void produceCar() = ;
 };

 class CarFactoryBenz:public ICarFactory{
 public:
     void produceCar(){
         cout<<"Produce a car of Benz"<<endl;
     }
 };

 class CarFactoryVolkswagen: public ICarFactory{
 public:
     void produceCar(){
         cout<<"Produce a car of Volkswagen"<<endl;
     }
 };

 int main()
 {
     ICarFactory *car1 = new CarFactoryBenz();
     ICarFactory *car2 = new CarFactoryVolkswagen();
     car1->produceCar();
     car2->produceCar();
     return ;
 }

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

 public interface ICarFactory {
     public void produceCar();
 }

 public class FactoryBenz implements ICarFactory{

     public void produceCar() {
         System.out.println("Produce a car of Benz");
     }
 }

 public class FactoryToyota implements ICarFactory{
     public void produceCar() {
         System.out.println("Produce a car of Toyota");
     }
 }

 public class Main {

     public static void main(String[] args){
         FactoryBenz factoryBenz = new FactoryBenz();
         FactoryToyota factoryToyota = new FactoryToyota();
         factoryBenz.produceCar();
         factoryToyota.produceCar();
     }

 }

二：工厂方法模式

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

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

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

 #include <iostream>

 using namespace std;

 class ICar{
 public:
     ICar(void){}
     ~ICar(void){}
     virtual void printInfo() = ;
 };

 class CarBenz:public ICar{
 public:
     CarBenz(){}
     ~CarBenz(){}
     void printInfo(){
         cout<<"The brand is Benz"<<endl;
     }
 };

 class CarToyota:public ICar{
 public:
     CarToyota(){}
     ~CarToyota(){}
     void printInfo(){
         cout<<"The brand is Toyota"<<endl;
     }
 };

 class IFactory{
 public:
     IFactory(void){}
     ~IFactory(void){}
     virtual ICar* produceCar() = ;
 };

 class FactoryBenz:public IFactory{
 public:
     FactoryBenz(){}
     ~FactoryBenz(){}
     ICar* produceCar(){
         cout<<"Produce a car of Benz"<<endl;
         ICar* car = new CarBenz();
         return car;
     }
 };

 class FactoryToyota:public IFactory{
 public:
     FactoryToyota(){}
     ~FactoryToyota(){}
     ICar* produceCar(){
         cout<<"Produce a car of Toyota"<<endl;
         ICar* car = new CarToyota();
         return car;
     }
 };

 int main()
 {
     IFactory* factory = new FactoryBenz();
     ICar* car = factory->produceCar();
     car->printInfo();
     IFactory* factory2 = new FactoryToyota();
     ICar* car2 = factory2   ->produceCar();
     car2->printInfo();
     return ;
 }

输出：

Produce a car of Benz

The brand is Benz

Produce a car of Toyota

The brand is Toyota

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

 public interface ICar {
     void printInfo();
 }

 public class CarBenz implements ICar {

     public void printInfo(){
         System.out.println("The brand is Benz");
     }
 }

 public class CarToyota implements ICar{

     public void printInfo(){
         System.out.println("The brand is toyota");
     }

 }

 public interface ICarFactory {
     ICar produceCar();
 }

 public class FactoryBenz implements ICarFactory{

     public ICar produceCar(){
         System.out.println("Produce a Benz car");
         return new CarBenz();
     }
 }

 public class FactoryToyota implements ICarFactory{

     public ICar produceCar(){
         System.out.println("Produce a Toyota car");
         return new CarToyota();
     }

 }

 public class Main {

     public static void main(String[] args){
         ICarFactory factoryBenz = new FactoryBenz();
         ICarFactory factoryToyota = new FactoryToyota();

         ICar benz = factoryBenz.produceCar();
         ICar toyota = factoryToyota.produceCar();

         benz.printInfo();
         toyota.printInfo();

     }
 }

输出：

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

三：抽象工厂模式

1.C++实现抽象工厂

 #include <iostream>

 using namespace std;

 class ICarToyota{
 public:
     ICarToyota(){}
     ~ICarToyota(){}
     virtual void printInfo() = ;
 };

 class CarToyotaChr:public ICarToyota{
 public:
     CarToyotaChr(){}
     ~CarToyotaChr(){}
     void printInfo(){
         cout<< "The car is Toyota C-HR"<<endl;
     }
 };

 class CarToyotaCarolla:public ICarToyota{
 public:
     CarToyotaCarolla(){}
     ~CarToyotaCarolla(){}
     void printInfo(){
         cout<< "The car is Toyota Carolla"<<endl;
     }
 };

 class ICarAudi{
 public:
     ICarAudi(){}
     ~ICarAudi(){}
     virtual void printInfo()=;
 };

 class CarAudiA3:public ICarAudi{
 public:
     CarAudiA3(){}
     ~CarAudiA3(){}
     void printInfo(){
         cout<< "The car is audi a3"<<endl;
     }
 };

 class CarAudiQ5:public ICarAudi{
 public:
     CarAudiQ5(){}
     ~CarAudiQ5(){}
     void printInfo(){
         cout<< "The car is audi q5"<<endl;
     }
 };

 class IFactory{
 public:
     IFactory(){}
     ~IFactory(){}
     virtual ICarToyota* produceCarToyota()=;
     virtual ICarAudi* produceCarAudi()=;
 };

 class FactoryCompact:public IFactory{
 public:
     FactoryCompact(){}
     ~FactoryCompact(){}
     ICarAudi* produceCarAudi(){
         cout<<"Produce a audi compact car"<<endl;
         return new CarAudiA3;
     }
     ICarToyota* produceCarToyota(){
         cout<<"Produce a toyota compact car"<<endl;
         return new CarToyotaCarolla;
     }
 };

 class FactorySuv:public IFactory{
 public:
     FactorySuv(){}
     ~FactorySuv(){}
     ICarAudi* produceCarAudi(){
         cout<<"Produce a audi suv"<<endl;
         return new CarAudiQ5;
     }
     ICarToyota* produceCarToyota(){
         cout<<"Produce a toyota suv"<<endl;
         return new CarToyotaChr;
     }
 };

 int main()
 {
     FactoryCompact factory1;
     FactorySuv factory2;
     ICarAudi* audi1;
     ICarAudi* audi2;
     ICarToyota* toyota1;
     ICarToyota* toyota2;
     audi1 = factory1.produceCarAudi();
     audi1->printInfo();
     audi2 = factory2.produceCarAudi();
     audi2->printInfo();
     toyota1 = factory1.produceCarToyota();
     toyota1->printInfo();
     toyota2 = factory2.produceCarToyota();
     toyota2->printInfo();
 }

输出：

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实现抽象工厂

 public interface ICarAudi {
     void printInfo();
 }

 public class CarAudiA3 implements ICarAudi {
     public void printInfo() {
         System.out.println("The car is Audi A3");
     }
 }

 public class CarAudiQ5 implements ICarAudi {
     public void printInfo() {
         System.out.println("The car is Audi Q5");
     }
 }

 public interface ICarToyota {
     void printInfo();
 }

 public class CarToyotaCarolla implements ICarToyota {
     public void printInfo() {
         System.out.println("The car is Toyota Carolla");
     }
 }

 public class CarToyotaChr implements ICarToyota {
     public void printInfo() {
         System.out.println("The vehicle is toyota C-HR");
     }
 }

 public interface IFactory {
     ICarAudi produceAudi();
     ICarToyota produceToyota();
 }

 public class FactoryCompact implements IFactory {
     public ICarAudi produceAudi() {
         System.out.println("Produce an audi compact");
         return new CarAudiA3();
     }

     public ICarToyota produceToyota() {
         System.out.println("Produce a toyota compact");
         return new CarToyotaCarolla();
     }
 }

 public class FactoryCompact implements IFactory {
     public ICarAudi produceAudi() {
         System.out.println("Produce an audi compact");
         return new CarAudiA3();
     }

     public ICarToyota produceToyota() {
         System.out.println("Produce a toyota compact");
         return new CarToyotaCarolla();
     }
 }

 public class Main {

     public static void main(String[] args){
         FactoryCompact factoryCompact = new FactoryCompact();
         FactorySuv factorySuv = new FactorySuv();
         ICarAudi c1 = factoryCompact.produceAudi();
         c1.printInfo();
         ICarAudi c2 = factorySuv.produceAudi();
         c2.printInfo();
         ICarToyota c3 = factoryCompact.produceToyota();
         c3.printInfo();
         ICarToyota c4 = factorySuv.produceToyota();
         c4.printInfo();
     }

 }

输出：

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