Java 简单工厂模式和工厂模式（类图及实现）

一. 工厂模式概要

1. 理解：用factory模式代替使用new创建对象，实现了创建者和调用者的分离，方便维护对象。
2. 实现方式：是面向接口编程
3. 主要遵循：开闭原则，对类可以扩展，但是不允许对类修改。
   这原则核心思想，宁愿多创建几个类，也不要去修改已经写好的类，但如果是系统逻辑的错误，可以修改类。

面向对象设计基本原则：

原则	说明
开闭原则	软件实体应该是可扩展的，而不可修改的
$里氏替换原则$	子类必须能够替换其基类，保证继承复用的基础
依赖倒转原则	依赖于抽象，高层模块不依赖于底层模块，二者都同依赖于抽象
单一职责	一个类，只做一件事并且做好
接口隔离原则	使用多个小的专门的接口，而不要使用一个大的总接口
迪米特法则	如果两个类之间无须直接通信，那么就不应当发生直接的相互调用，可以通过第三方转发该调用

模式	说明
简单工厂模式	用来生产同一等级结构中的任意产品。(对于增加新的产品，需要修改已有代码)（违反开闭原则）
工厂模式	用来生产同一等级结构中的固定产品。（支持增加任意产品）
抽象工厂	用来生产不同产品族的全部产品。(对于增加新的产品，无能为力；支持增加产品族)

二．简单工厂模式

创建意图就是，把对类的创建初始化全都交给一个工厂来执行，而用户不需要去关心创建的过程是什么样的，只用告诉工厂我想要什么就行了。违背了设计模式的开闭原则，如果你要增加其他产品，就必须对工厂进行改建。
例如我开了奔驰公司想要生产A系列的车和B系列的车，首先定义接口，创建两种车的类，和工厂类，就可以生产车了。
类图：

实现代码：

interface car {
    public  void run();
}

class carA implements car {

    public void run(){

        System.out.println("carA 时速100km");
    }
}

class carB implements car {
    public void run(){
        System.out.println("carB 时速200km");
    }

}
//如果生产C系列的车
class carC implements car {   

    public void run(){
        System.out.println("carC 时速300km");
    }

}

class Factory {
    public car createCar(String name)
    {
        if (name.equalsIgnoreCase("carA")) {
            return new carA();
        }
        else if (name.equalsIgnoreCase("carB")) {
            return new carB();
        }
        return null;
    }
}

class SimpleFactoryClient{
    public static void main(String[] args) {
        Factory factory = new Factory();
        car car1= factory.createCar("carA"); //给个名，工厂就生产
        car1.run();
        car car2= factory.createCar("carB");
        car2.run();
        car car3= factory.createCar("carC");
        car3.run();
    }
}

如果改天想生产C系列的车carC，就得先造carC的类，但是要想完成对carC的生产，此时只能去修改工厂类，在里面添加一个新的方法，制造carC，但是不符合开闭原则。

三. 工厂模式

• 解决简单工厂方法模式的缺点：使用工厂方法模式为每一种产品生成一个对应的工厂。
• 工厂方法模式的核心思想：讨论的仍然是如何构建同一类型产品（都实现同一个接口）的问题，只不过每个工厂只生产一种特定的产品。
• 优势：是当以后需要增加新的产品时，直接新增加一个对应的工厂就可以了，而不是去修改原有的工厂
  奔驰厂商优化生产线类图：
  
  实现

interface car {
    public  void run();
}

class carA implements car {

    public void run(){

        System.out.println("carA 时速100km");
    }
}

class carB implements car {
    public void run(){
        System.out.println("carB 时速200km");
    }

}
//如果生产C系列的车
class carC implements car {   

    public void run(){
        System.out.println("carC 时速300km");
    }

}

interface CarFactory {
    public  car creatCar();
}
class  CarAFactory implements CarFactory {
    public  car creatCar(){
        return new carA();
    };
};
class  CarBFactory implements CarFactory {
    public  car creatCar(){
        return new carB();
    };
};
class  CarCFactory implements CarFactory {   //生产新车了
    public  car creatCar(){
        return new carC();
    };
};


public class FactoryClient {
    public static void main(String[] args) {

        car car1 =new CarAFactory().creatCar(); 
        car car2= new CarBFactory().creatCar();
        car car3= new CarCFactory().creatCar();
        car1.run();
        car2.run();
        car3.run();

    }
}

优缺点

• 优点：不直接在客户端创建具体产品的实例，降低了耦合性。
• 缺点：每增加一种产品就要相应的增加一个工厂类，比较繁琐。

技术要点总结

• 构建的都是同一类型的对象，即实现相同的接口
• 每一类对象对应一个工厂

欠的有一天不得不补回来 （| _ |）
参考