Java设计模式---工厂模式学习笔记
Java设计模式---单例模式学习笔记
工厂模式简介
三种工厂模式
- 简单工厂模式
- 工厂方法模式
- 抽象工厂模式
其中各有各的优缺点
这里直接拿造车举例(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();
}
}
优点和缺点
优点: 及其稳定,如果其中的一个厂坏了,不会影响到另一个
缺点: 如果要新增工厂功能,修改极大
