Java设计模式---工厂模式学习笔记

Java设计模式---单例模式学习笔记

工厂模式简介

简单的来说就是在新建一个实例的时候，不使用new而是直接用工厂创建，使用工厂直接返回一个实例。

使用工厂方法将创建实例的工作封装起来，这样在调用的时候无需关心复杂的实例化问题(直接拿来用就可以了)

---

三种工厂模式

1. 简单工厂模式
2. 工厂方法模式
3. 抽象工厂模式

其中各有各的优缺点

---

这里直接拿造车举例(PS:没有专业的画图工具，UML图可能画得不好)

简单工厂模式

UML类图

规范

ICar: 车的规范接口

public interface ICar {
    void name();    //车的名字
    void make();    //生产车
}

制造过程

Benz: 制造奔驰车

//应为是车,所以要满足车规范
public class Benz implements ICar{
    @Override
    public void name() {
        //车名
        System.out.println("这是奔驰车");
    }
    @Override
    public void make() {
        //制造车
        System.out.println("制造奔驰车");
    }
}

Bmw: 制造宝马车

public class Bmw implements ICar{
    @Override
    public void name() {
        System.out.println("这是宝马车");
    }
    @Override
    public void make() {
        System.out.println("制造宝马车");
    }
}

封装到厂

CarFactory: 车工厂(直接在这造车,这个大厂既可以造Benz也可以造Bmw)

public class CarFactory {
    public ICar CreateCar(String CarName) {
        //车工厂,传入参数取车
        if(CarName.equals("Benz")) {
            return new Benz();
        }else if(CarName.equals("Bmw")) {
            return new Bmw();
        }
        //都不是的话就返回空
        return null;
    }
}

模拟造车

Client: 模拟车厂造车(演示)

public class Client {
    public static void main(String[] args) {
        //现创建造车工厂
        CarFactory carFactory = new CarFactory();
        //制造Benz
        ICar benz = carFactory.CreateCar("Benz");
        benz.make();    //制造奔驰车
        benz.name();    //这是奔驰车
        System.out.println("------------------");
        //制造Bmw
        ICar bmw = carFactory.CreateCar("Bmw");
        bmw.make();    //制造宝马车
        bmw.name();    //这是宝马车
    }
}

优点和缺点

简单工厂模式的优点显而易见，将实例化的创建和使用分成了两个部分，我们只需要传入一个参数就可以得到一个对象
缺点当然也是有的，比如我们现在如果想要多造一种车大众(DaZhong)，我们不得不修改CarFactory的代码(CreateCar 指定新的字符串)才可以生效，
这就违反了开闭原则（对扩展开放，对修改关闭）
于是工厂方法模式应之而生

---

工厂方法模式

在上面的基础上新增了一层ICarFactory，每种车都有各自的工厂，ICarFactory将所有工厂的规范整合
这样如果要新增一种车，直接implete这个厂接口就可以了，各自在各自的厂里造车

UML类图

规范

ICar: 车的规范接口

public interface ICar {
    void name();
    void make();
}

ICarFactory: 工厂规范接口

public interface ICarFactory {
    ICar CreateCar();
}

制造过程

Benz: 制造奔驰车

public class Benz implements ICar{
    @Override
    public void name() {
        System.out.println("这是奔驰车");
    }
    @Override
    public void make() {
        System.out.println("制造奔驰车");
    }
}

Bmw: 制造宝马车

public class Bmw implements ICar{
    @Override
    public void name() {
        System.out.println("这是宝马车");
    }
    @Override
    public void make() {
        System.out.println("制造宝马车");
    }
}

封装到厂

BenzFactory: 制造奔驰车的工厂

public class BenzFactory implements ICarFactory{
    @Override
    public ICar CreateCar() {
        return new Benz();
    }
}

BmwFactory: 制造宝马车的工厂

public class BmwFactory implements ICarFactory{
    @Override
    public ICar CreateCar() {
        return new Bmw();
    }
}

此时如果我们想要增加新的车，直接建类实现ICar和ICarFactory接口就行
eg

模拟造车

Client:

public class Client {
    public static void main(String[] args) {
        ICar benz = new BenzFactory().CreateCar();
        benz.make();
        benz.name();
        ICar bmw = new BmwFactory().CreateCar();
        bmw.make();
        bmw.name();
    }
}

优点和缺点

优点： 如果要增加新的车辆，直接实现两个接口即可
缺点： 但是如果车厂现在要新增一类载具（比如说造坦克），那样我们不得不改变ICarFactory，这就又违反了开闭原则

---

抽象工厂模式

新增一个超级工厂，其余的工厂implete这个工厂

UML类图

规范

ICar: 车的规范接口

public interface ICar {
    void name();
    void make();
}

ITank: 坦克规范接口

public interface ITank {
    void name();
    void make();
}

ISuperFactory: 超级工厂接口

public interface ISuperFactory {
    ICar CreateCar();
    ITank CreateTank();
}

制造过程

BenzCar: 制造奔驰车

public class BenzCar implements ICar{
    @Override
    public void name() {
        System.out.println("这是奔驰车");
    }
    @Override
    public void make() {
        System.out.println("制造了奔驰车");
    }
}

BenzTank: 制造奔驰坦克

public class BenzTank implements ITank{
    @Override
    public void name() {
        System.out.println("这是奔驰坦克");
    }
    @Override
    public void make() {
        System.out.println("制造了奔驰坦克");
    }
}

封装到厂

BenzFactory: 奔驰的车厂(用于生产奔驰车和奔驰坦克)

public class BenzFactory implements ISuperFactory{
    @Override
    public ICar CreateCar() {
        return new BenzCar();
    }
    @Override
    public ITank CreateTank() {
        return new BenzTank();
    }
}

Bmw类似于是不再赘述

模拟造车

public class Client {
    public static void main(String[] args) {
        //造Benz工厂
        BenzFactory benzFactory = new BenzFactory();
        //造BenzCar
        ICar benzCar = benzFactory.CreateCar();
        benzCar.make();
        benzCar.name();
        //造BenzTank
        ITank benzTank = benzFactory.CreateTank();
        benzTank.make();
        benzTank.name();
    }
}

优点和缺点

优点: 及其稳定,如果其中的一个厂坏了,不会影响到另一个
缺点: 如果要新增工厂功能,修改极大