这两天抽空学习一下设计模式,刚开始遇到工厂模式,感觉工厂方法模式和抽象工厂模式的区别有点模糊,看了之前的面试资料也是有点区分不清,于是查阅一些网上的资料和博客,记录一下。
1,工厂方法模式: 定义一个用于创建对象的接口,让子类决定实例化哪一个类,工厂方法使得一个类的实例化延迟到了子类
工厂方法在简单工厂的基础上再包了一层工厂,所有的工厂都是此工厂的子类。而产生对象的类型由子类工厂决定。(摘自别的博客,代码)
//定义上级工厂的接口
public interface IFractory {
public Operation generateOper();
}
//为每一个类创建工厂
/**
* 工厂方法 为每个对象生成一个工厂类
*/
public class AddOperationFactory implements IFractory{
@Override
public Operation generateOper() {
return new AddOperation();
}
}
public class SubOperationFactory implements IFractory {
@Override
public Operation generateOper() {
return new SubOperation();
}
}
public class MulOperationFactory implements IFractory {
@Override
public Operation generateOper() {
return new MulOperation();
}
}
public class DivOperationFactory implements IFractory {
@Override
public Operation generateOper() {
return new DivOperation();
}
}
//客户端代码
IFractory fractory = new AddOperationFactory();
Operation operation = fractory.generateOper();
operation.getResult(firstNum,secondNum);
---------------------
作者:最伤离别
来源:CSDN
原文:https://blog.csdn.net/xiaoddt/article/details/74937952?utm_source=copy
版权声明:本文为博主原创文章,转载请附上博文链接!
工厂方法把类的实例化推迟到其子类,由客户端代码决定选择对应工厂类进行实例化。将判断问题移到客户端,但是如果工厂方法模式遇到需要更改产品线,只需要更改一个工厂实例化对象即可,非常方便。
2.抽象工厂模式: 提供一个创建一系列相关相互依赖对象的接口,而无需指定他们具体的类。抽象工厂为不同产品族的对象创建提供接口。
使用场景:系统需要在不同产品族进行切换
/**
* @Description 抽象工厂模式:最原始工厂
* @Author xg
* @Date 2018/10/11 10:02
*/
public interface IFactory {
public KeyBoard createKeyBoard();
public Mouse createMouse();
}
/**
* @Description 键盘
* @Author xg
* @Date 2018/10/11 10:04
*/
public interface KeyBoard {
public void getMessage();
}
/**
* @Description 鼠标
* @Author xg
* @Date 2018/10/11 10:06
*/
public interface Mouse {
public void getMessage();
}
/**
* @Description 罗技产品
* @Author xg
* @Date 2018/10/11 10:08
*/
public class LGKeyBoard implements KeyBoard{
@Override
public void getMessage() {
System.out.println("罗技键盘");
}
}
/**
* @Description 罗技产品
* @Author xg
* @Date 2018/10/11 10:09
*/
public class LGMouse implements Mouse {
@Override
public void getMessage() {
System.out.println("罗技鼠标");
}
}
/**
* @Description 雷蛇产品
* @Author xg
* @Date 2018/10/11 10:10
*/
public class LSKeyBoard implements KeyBoard {
@Override
public void getMessage() {
System.out.println("雷蛇键盘");
}
}
/**
* @Description 雷蛇产品
* @Author xg
* @Date 2018/10/11 10:12
*/
public class LSMouse implements Mouse {
@Override
public void getMessage() {
System.out.println("雷蛇鼠标");
}
}
/**
* @Description 罗技工厂 不同产品组使用同一个工厂
* @Author xg
* @Date 2018/10/11 10:12
*/
public class LGFactory implements IFactory {
@Override
public KeyBoard createKeyBoard() {
return new LGKeyBoard();
}
@Override
public Mouse createMouse() {
return new LGMouse();
}
}
/**
* @Description 雷蛇工厂
* @Author xg
* @Date 2018/10/11 10:13
*/
public class LSFactory implements IFactory {
@Override
public KeyBoard createKeyBoard() {
return new LSKeyBoard();
}
@Override
public Mouse createMouse() {
return new LSMouse();
}
}
package factory_demo;
import factory_demo.product.KeyBoard;
import factory_demo.product.Mouse;
/**
* @Description 抽象工厂模式测试 客户端代码
* @Author xg
* @Date 2018/10/11 10:16
*/
public class FactoryTest {
public static void main(String[] args) {
IFactory lgFactory = new LGFactory();
KeyBoard lgKeyBoard = lgFactory.createKeyBoard();
lgKeyBoard.getMessage();
Mouse lgMouse = lgFactory.createMouse();
lgMouse.getMessage();
IFactory lsFactory = new LSFactory();
KeyBoard lsKeyBoard = lsFactory.createKeyBoard();
lsKeyBoard.getMessage();
Mouse lsMouse = lsFactory.createMouse();
lsMouse.getMessage();
}
}
好处:①便于交换产品系列,具体工厂在代码中一般只出现一次。这就使得改变应用的具体工厂很容易。
②能让具体的创建对象实例和客户端分离,客户端是通过他们的抽象接口操作实例
缺点:不太易于拓展,如果需要自增功能,或者自增产品,则需要至少修改三个类,而且实例化的代码是写死在程序中的 , 这样无法避免违背开放-关闭原则。
对于上述问题,可以通过配置文件,结合反射的方式来解决。
自己理解还不是很到位,文字总结也是依照别人理解,只能对代码有所意会,先记录下来供以后补充和学习。