1.简单工厂模式
从简单的工厂模式开始说起的话,我们要知道工厂模式的目的是什么?工厂模式的目的在于程序的可扩展性。而对于简单工厂模式来说,它是为了让程序有一个更好地封装,降低程序模块之间的耦合程度。
对于简单的工厂模式,其实也可以将其理解成为一个创建对象的工具类。工具类的形式,可以仿造如下代码编写:
public class SimpleFactory {
public Object create(Class<?> clazz) {
if (clazz.getName().equals(Plane.class.getName())) {
return createPlane();
} else if (clazz.getName().equals(Broom.class.getName())) {
return createBroom();
}
return null;
}
private Broom createBroom() {
return new Broom();
}
private Plane createPlane() {
return new Plane();
}
public class FactoryTest {
public static void main(String[] args) {
// 简单工厂模式测试
SimpleFactory simpleFactory = new SimpleFactory();
Broom broom = (Broom) simpleFactory.create(Broom.class);
broom.run();
}
2.工厂方法模式
1.模式描述
提供一个用于创建对象的接口(工厂接口),让其实现类(工厂实现类)决定实例化哪一个类(产品类),并且由该实现类创建对应类的实例。
2.模式作用
可以一定程度上解耦,消费者和产品实现类隔离开,只依赖产品接口(抽象产品),产品实现类如何改动与消费者完全无关。
可以一定程度增加扩展性,若增加一个产品实现,只需要实现产品接口,修改工厂创建产品的方法,消费者可以无感知(若消费者不关心具体产品是什么的情况)。
可以一定程度增加代码的封装性、可读性。清楚的代码结构,对于消费者来说很少的代码量就可以完成很多工作。
等等。
另外,抽象工厂才是实际意义的工厂模式,工厂方法只是抽象工厂的一个比较常见的情况。
3.适用场景
消费者不关心它所要创建对象的类(产品类)的时候。
消费者知道它所要创建对象的类(产品类),但不关心如何创建的时候。
等等。
例如:hibernate里通过sessionFactory创建session、通过代理方式生成ws客户端时,通过工厂构建报文中格式化数据的对象。
4.类图
CPU接口与具体实现
public interface Cpu {
public void calculate();
}
public class IntelCpu implements Cpu {
/**
* CPU的针脚数
*/
private int pins = 0;
public IntelCpu(int pins){
this.pins = pins;
}
@Override
public void calculate() {
// TODO Auto-generated method stub
System.out.println("Intel CPU的针脚数:" + pins);
}
}
public class AmdCpu implements Cpu {
/**
* CPU的针脚数
*/
private int pins = 0;
public AmdCpu(int pins){
this.pins = pins;
}
@Override
public void calculate() {
// TODO Auto-generated method stub
System.out.println("AMD CPU的针脚数:" + pins);
}
}
主板接口与具体实现
public interface Mainboard {
public void installCPU();
}
public class IntelMainboard implements Mainboard {
/**
* CPU插槽的孔数
*/
private int cpuHoles = 0;
/**
* 构造方法,传入CPU插槽的孔数
* @param cpuHoles
*/
public IntelMainboard(int cpuHoles){
this.cpuHoles = cpuHoles;
}
@Override
public void installCPU() {
// TODO Auto-generated method stub
System.out.println("Intel主板的CPU插槽孔数是:" + cpuHoles);
}
}
public class AmdMainboard implements Mainboard {
/**
* CPU插槽的孔数
*/
private int cpuHoles = 0;
/**
* 构造方法,传入CPU插槽的孔数
* @param cpuHoles
*/
public AmdMainboard(int cpuHoles){
this.cpuHoles = cpuHoles;
}
@Override
public void installCPU() {
// TODO Auto-generated method stub
System.out.println("AMD主板的CPU插槽孔数是:" + cpuHoles);
}
}
CPU与主板工厂类
public class CpuFactory {
public static Cpu createCpu(int type){
Cpu cpu = null;
if(type == 1){
cpu = new IntelCpu(755);
}else if(type == 2){
cpu = new AmdCpu(938);
}
return cpu;
}
}
public class MainboardFactory {
public static Mainboard createMainboard(int type){
Mainboard mainboard = null;
if(type == 1){
mainboard = new IntelMainboard(755);
}else if(type == 2){
mainboard = new AmdMainboard(938);
}
return mainboard;
}
}
装机工程师类
public class ComputerEngineer {
/**
* 定义组装机需要的CPU
*/
private Cpu cpu = null;
/**
* 定义组装机需要的主板
*/
private Mainboard mainboard = null;
public void makeComputer(int cpuType , int mainboard){
/**
* 组装机器的基本步骤
*/
//1:首先准备好装机所需要的配件
prepareHardwares(cpuType, mainboard);
//2:组装机器
//3:测试机器
//4:交付客户
}
private void prepareHardwares(int cpuType , int mainboard){
//这里要去准备CPU和主板的具体实现,为了示例简单,这里只准备这两个
//可是,装机工程师并不知道如何去创建,怎么办呢?
//直接找相应的工厂获取
this.cpu = CpuFactory.createCpu(cpuType);
this.mainboard = MainboardFactory.createMainboard(mainboard);
//测试配件是否好用
this.cpu.calculate();
this.mainboard.installCPU();
}
}
3.抽象工厂模式
1.定义:
为创建一组相关或相互依赖的对象提供一个接口,而且无需指定他们的具体类。
2.类图:
抽象工厂模式与工厂方法模式的区别
抽象工厂模式是工厂方法模式的升级版本,他用来创建一组相关或者相互依赖的对象。他与工厂方法模式的区别就在于,工厂方法模式针对的是一个产品等级结构;而抽象工厂模式则是针对的多个产品等级结构。在编程中,通常一个产品结构,表现为一个接口或者抽象类,也就是说,工厂方法模式提供的所有产品都是衍生自同一个接口或抽象类,而抽象工厂模式所提供的产品则是衍生自不同的接口或抽象类。
在抽象工厂模式中,有一个产品族的概念:所谓的产品族,是指位于不同产品等级结构中功能相关联的产品组成的家族。抽象工厂模式所提供的一系列产品就组成一个产品族;而工厂方法提供的一系列产品称为一个等级结构。我们依然拿生产汽车的例子来说明他们之间的区别。
在上面的类图中,两厢车和三厢车称为两个不同的等级结构;而2.0排量车和2.4排量车则称为两个不同的产品族。再具体一点,2.0排量两厢车和2.4排量两厢车属于同一个等级结构,2.0排量三厢车和2.4排量三厢车属于另一个等级结构;而2.0排量两厢车和2.0排量三厢车属于同一个产品族,2.4排量两厢车和2.4排量三厢车属于另一个产品族。
新加入的抽象工厂类和实现类:
public interface AbstractFactory {
/**
* 创建CPU对象
* @return CPU对象
*/
public Cpu createCpu();
/**
* 创建主板对象
* @return 主板对象
*/
public Mainboard createMainboard();
}
public class IntelFactory implements AbstractFactory {
@Override
public Cpu createCpu() {
// TODO Auto-generated method stub
return new IntelCpu(755);
}
@Override
public Mainboard createMainboard() {
// TODO Auto-generated method stub
return new IntelMainboard(755);
}
}
public class AmdFactory implements AbstractFactory {
@Override
public Cpu createCpu() {
// TODO Auto-generated method stub
return new IntelCpu(938);
}
@Override
public Mainboard createMainboard() {
// TODO Auto-generated method stub
return new IntelMainboard(938);
}
}
装机工程师类跟前面的实现相比,主要的变化是:从客户端不再传入选择CPU和主板的参数,而是直接传入客户已经选择好的产品对象。这样就避免了单独去选择CPU和主板所带来的兼容性问题,客户要选就是一套,就是一个系列。
public class ComputerEngineer {
/**
* 定义组装机需要的CPU
*/
private Cpu cpu = null;
/**
* 定义组装机需要的主板
*/
private Mainboard mainboard = null;
public void makeComputer(AbstractFactory af){
/**
* 组装机器的基本步骤
*/
//1:首先准备好装机所需要的配件
prepareHardwares(af);
//2:组装机器
//3:测试机器
//4:交付客户
}
private void prepareHardwares(AbstractFactory af){
//这里要去准备CPU和主板的具体实现,为了示例简单,这里只准备这两个
//可是,装机工程师并不知道如何去创建,怎么办呢?
//直接找相应的工厂获取
this.cpu = af.createCpu();
this.mainboard = af.createMainboard();
//测试配件是否好用
this.cpu.calculate();
this.mainboard.installCPU();
}
}
抽象工厂模式的优点
抽象工厂模式除了具有工厂方法模式的优点外,最主要的优点就是可以在类的内部对产品族进行约束。所谓的产品族,一般或多或少的都存在一定的关联,抽象工厂模式就可以在类内部对产品族的关联关系进行定义和描述,而不必专门引入一个新的类来进行管理。
抽象工厂模式的缺点
产品族的扩展将是一件十分费力的事情,假如产品族中需要增加一个新的产品,则几乎所有的工厂类都需要进行修改。所以使用抽象工厂模式时,对产品等级结构的划分是非常重要的。
适用场景
当需要创建的对象是一系列相互关联或相互依赖的产品族时,便可以使用抽象工厂模式。说的更明白一点,就是一个继承体系中,如果存在着多个等级结构(即存在着多个抽象类),并且分属各个等级结构中的实现类之间存在着一定的关联或者约束,就可以使用抽象工厂模式。假如各个等级结构中的实现类之间不存在关联或约束,则使用多个独立的工厂来对产品进行创建,则更合适一点。
总结
无论是简单工厂模式,工厂方法模式,还是抽象工厂模式,他们都属于工厂模式,在形式和特点上也是极为相似的,他们的最终目的都是为了解耦。在使用时,我们不必去在意这个模式到底工厂方法模式还是抽象工厂模式,因为他们之间的演变常常是令人琢磨不透的。经常你会发现,明明使用的工厂方法模式,当新需求来临,稍加修改,加入了一个新方法后,由于类中的产品构成了不同等级结构中的产品族,它就变成抽象工厂模式了;而对于抽象工厂模式,当减少一个方法使的提供的产品不再构成产品族之后,它就演变成了工厂方法模式。
所以,在使用工厂模式时,只需要关心降低耦合度的目的是否达到了。
转:https://blog.csdn.net/lemon_tree12138/article/details/46225213
http://www.cnblogs.com/java-my-life/archive/2012/03/28/2418836.html