简单工厂，工厂方法，抽象工厂模式

简单工厂，工厂方法，抽象工厂模式

软件设计七大原则

开闭原则	对扩展开放，对修改关闭	降低维护带来的新风险
依赖倒置原则	高层不应该依赖低层，要面向接口编程	更利于代码结构的升级扩展
单一职责原则	一个类只干一件事，实现类要单一	便于理解，提高代码的可读性
接口隔离原则	一个接口只干一件事，接口要精简单一	功能解耦，高聚合、低耦合
迪米特法则	不该知道的不要知道，一个类应该保持对其它对象最少的了解，降低耦合度	只和朋友交流，不和陌生人说话，减少代码臃肿
里氏替换原则	不要破坏继承体系，子类重写方法功能发生改变，不应该影响父类方法的含义	防止继承泛滥
合成复用原则	尽量使用组合或者聚合关系实现代码复用，少使用继承	降低代码耦合

简单工厂模式：

1.定义：简单来说就是在实例化对象的时候不在使用new Object()这个形式，而是3可以根据用户的选择条件来 实例化相对应需要的类。对于客户端来说，去除了具体类的相关依赖。只需要给出具体的实例给工厂，工厂就会自动返回具体的实例对象。

 

在创建车型的时候我们一共有三种选择的车型：Hongqi，Biyadi，Benz，各自可以生产：红旗，比亚迪，奔驰。我们创建有个工厂类来根据用户输入的车型，创建其相对应的类：

汽车类

public interface Car {
    void createCar();
}
​

具体车型实现Car接口

public class HongqiCar implements Car {
    @Override
    public void createCar() {
        System.out.println("生产红旗");
    }
}
​
public class BenzCar implements  Car{
    @Override
    public void createCar() {
        System.out.println("生产奔驰");
    }
}
​
public class BiyadiCar implements Car{
    @Override
    public void createCar() {
        System.out.println("生产比亚迪");
​
    }
}
​

创建工厂类：

public class CarFactor {
​
    public Car createModel(String model){
        Car car=null;
        switch (model){
            case "比亚迪":
                car=new BiyadiCar();
            case "红旗":
                car=new HongqiCar();
            case "奔驰":
                car=new BenzCar();
        }
        return  car;
    }
​
}
​

测试：

public class test {
​
    public static void main(String[] args) {
        CarFactor carFactor = new CarFactor();
        Car car = carFactor.createModel("比亚迪");
        car.createCar();
    }
​
​
}

​
输出：生产比亚迪

总结：简单工厂符合单一原则，用牺牲开闭的 方式来提高灵活性。

工厂方法模式（Factory Method）：

1.定义：定义一个用于创建对象的接口，让子类决定实例化哪一个类。工厂方法决定实例化哪一个类。工厂方法使一个类的实例化延迟到其他子类。

 

//创建工厂接口CarFactory：

public interface CarFactory {
    Car createCarFactory();
}
​

//创建具体类型的工厂：

public class BenzFactory implements CarFactory {
    @Override
    public Car createCarFactory() {
        return new BiyadiCar();
    }
}
​
public class BiyadiFactory implements CarFactory{
    @Override
    public Car createCarFactory() {
        return new BiyadiCar();
    }
}
​
public class HongqiFactory implements CarFactory{
    @Override
    public Car createCarFactory() {
        return new HongqiCar();
    }
}
​
​

//测试

    public static void main(String[] args) {
        HongqiFactory hongqiFactory = new HongqiFactory();
        Car carFactory = hongqiFactory.createCarFactory();
        carFactory.createCar();
    }
​
​
​
}
//输出：生产比亚迪

总结：用户只需要知道具体工厂的名字，就可以得到想要的产品。

其满足单一原则，开闭原则，但是灵活性较差。

抽象工厂模式（Abstract Factory）：

1.定义：提供一个创建一系列相关或相互依赖对象的接口，而无需指定他们

//创建电车，油车，混能车的抽象接口

public interface ECar {
    void createCar();
}
​
public interface HCar {
    void createCar();
}
​
public interface OCar {
    void createCar();
}
​

//创建具体品牌车型的具体类(其他车型以此类推)

public class BenZECar implements ECar{
    @Override
    public void createCar() {
        System.out.println("奔驰电车");
    }
}
​
public class BenZHCar implements HCar{
    @Override
    public void createCar() {
        System.out.println("奔驰混合车");
    }
}
​
public class BenZOCar implements OCar {
​
    @Override
    public void createCar() {
        System.out.println("奔驰油车");
    }
​
}
​

//创建抽象车型工厂接口

public interface CarFactory {
    ECar createEcar();
     OCar createOcar();
     HCar createHcar();
}
​


//创建具体品牌的工厂实现接口工厂CarFactory(其他品牌以此类推)

public class BenZFactory implements CarFactory {
​
    @Override
    public ECar createEcar() {
        return new BenZECar();
    }
​
    @Override
    public OCar createOcar() {
        return new BenZOCar();
    }
​
    @Override
    public HCar createHcar() {
        return new BenZHCar();
    }
}

//测试

public class test {
​
    public static void main(String[] args) {
        BenZFactory benZFactory = new BenZFactory();
        HCar hcar = benZFactory.createHcar();
        hcar.createCar();
    }
}

总结：抽象方法符合单一原则，开闭原则，但是灵活性差

抽象工厂--简单抽象工厂

将工厂类替换为：

public class SimpleAbstractCatFactory {
    public ECar createECars(String brand ){
​
        Ecar ecar = null;
        switch (brand) {
            case "比亚迪":
                ecar = new BIyadiEcar();
                break;
            case "红旗":
                ecar = new HongqiEcar();
                break;
            case "奔驰":
                ecar = new BenZEcar();
                break;
        }
        return ecar;
    }
​}

总结：抽象方法符合单一原则，不符合开闭原则，但是灵活性高

工厂模式小结

工厂方法模式与抽象工厂模式的区别在于：

（1）工厂方法只有一个抽象产品类和一个抽象工厂类，但可以派生出多个具体产品类和具体工厂类，每个具体工厂类只能创建一个具体产品类的实例。

（2）抽象工厂模式拥有多个抽象产品类（产品族）和一个抽象工厂类，每个抽象产品类可以派生出多个具体产品类；抽象工厂类也可以派生出多个具体工厂类，同时每个具体工厂类可以创建多个具体产品类的实例