java超级工厂_Java设计模式---工厂模式学习笔记

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

工厂模式简介

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

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

三种工厂模式

简单工厂模式

工厂方法模式

抽象工厂模式

其中各有各的优缺点

这里直接拿造车举例(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();

}

}

优点和缺点

优点: 及其稳定,如果其中的一个厂坏了,不会影响到另一个

缺点: 如果要新增工厂功能,修改极大