一.简单工厂模式
简单工厂模式就是把对类的创建初始化全都交给一个工厂来执行,而用户不需要去关心创建的过程是什么样的,只用告诉工厂我想要什么就行了。而这种方法的缺点也很明显,违背了设计模式的开闭原则,因为如果你要增加工厂可以初始化的类的时候,你必须对工厂进行改建
代码如下:
package com.long88.ad.test; interface Car { public void getCar(); }
package com.long88.ad.test; public class BMW implements Car{ @Override public void getCar() { System.out.printf("来一辆BMW!"); } }
package com.long88.ad.test; public class BYD implements Car { @Override public void getCar() { System.out.printf("来一辆BYD!"); } }
package com.long88.ad.test; public class CarFactor { public static Car carFactor(Class<?> tClass){ if (tClass.getName().equals(BMW.class.getName())){ return new BMW(); } if (tClass.getName().equals(BYD.class.getName())){ return new BYD(); } return null; } }
package com.long88.ad.test; public class testFactory { public static void main(String[] args) { Car car = CarFactor.carFactor(BYD.class); car.getCar(); } }
结果如图:
二. 工厂方法模式
设计一个工厂的接口,你想要什么东西,就写个类继承于这个工厂,这样就不用修改什么,直接添加就行了。就相当于,我这个工厂是用来生汽车的,而要什么品牌的汽车具体分到了每个车间,如果新多了一种品牌的汽车,直接新增一个车间就行了。那么问题又来了,如果想要生产大炮怎么办?
代码如下:
package com.long88.ad.test; interface Car { public void getCar(); }
package com.long88.ad.test; public class BMW implements Car{ @Override public void getCar() { System.out.printf("来一辆BMW!"); } }
package com.long88.ad.test; public class BYD implements Car { @Override public void getCar() { System.out.printf("来一辆BYD!"); } }
//抽象工厂 interface CarFactory{ public Car getCarByFactory(); }
// BMW 具体工厂类 class BMWfactory implements CarFactory{ @Override public Car getCarByFactory() { return new BMW(); } }
// BYD 具体工厂类 class BYD factory implements CarFactory{ @Override public Car getCarByFactory() { return new BYD (); } }
public class TestFactory { public static void main(String[] args) { Car bmw= new BMWfactory().getCarByFactory(); bmw.getCar(); } }
三. 抽象工厂模式
定义:为创建一组相关或相互依赖的对象提供一个接口,而且无需指定他们的具体类。
抽象工厂与工厂方法的区别,就在于产品簇的问题,多了一种产品,这时候怎么办呢,就是在接口类里面加上创建大炮的方法,然后每个车间就可以有两个子车间分别来生产汽车和大炮。这样的话缺点也很显然的冒了出来,如果我又想生产飞机,那么我要需要更改所有的工厂车间以及工厂接口。
抽象工厂模式是工厂方法模式的升级版本,他用来创建一组相关或者相互依赖的对象。他与工厂方法模式的区别就在于,工厂方法模式针对的是一个产品等级结构;而抽象工厂模式则是针对的多个产品等级结构。在编程中,通常一个产品结构,表现为一个接口或者抽象类,也就是说,工厂方法模式提供的所有产品都是衍生自同一个接口或抽象类,而抽象工厂模式所提供的产品则是衍生自不同的接口或抽象类。
代码如下:
package com.long88.ad.test; interface Car { public void getCar(); }
package com.long88.ad.test; public class BMW implements Car{ @Override public void getCar() { System.out.printf("来一辆BMW!"); } }
package com.long88.ad.test; public class BYD implements Car { @Override public void getCar() { System.out.printf("来一辆BYD!"); } }
package com.long88.ad.test; interface Plane{ public void getPlane(); }
package com.long88.ad.test; public class AirPlane implements Plane{ @Override public void getPlane() { System.out.printf("来一架客机!"); } }
package com.long88.ad.test; public class BattlePlane implements Plane{ @Override public void getPlane() { System.out.printf("来一架战斗机!"); } }
//抽象工厂 interface Factory{ public Car getCarByFactory();
public Plane getPlaneByFactory(); }
// 具体工厂类 class FactoryOne implements Factory{ @Override public Car getCarByFactory() { return new BMW(); } @Override public Plane getPlaneByFactory() { return new AirPlane(); } }
// 具体工厂类 class FactoryTwo implements Factory{ @Override public Car getCarByFactory() { return new BYD(); } @Override public Plane getPlaneByFactory() { return new BattlePlane (); } }
public class TestFactory { public static void main(String[] args) { Car byd = new FactoryTwo().getCarByFactory(); byd.getCar(); Plane airPlane = new FactoryOne().getPlaneByFactory(); airPlane.getPlane(); } } /* 运行结果 来一辆BYD! 来一架客机! */
使用场景
当我们直接new一个对象比较麻烦时,比如构造方法传参数量太多;
再比如创建一个类A要先创建类B,这种使用new比较麻烦时就可以交给工厂去做,还减少了代码的重复。