GOF23---工厂设计模式练习代码和随笔
GOF23学习练习代码
创建型设计模式
一、工厂方法
1.工厂类
/**
* 抽象工厂
*/
public interface PayFactory{
Pay getPayProduct();
}
public class AlipayFactory implements PayFactory {
@Override
public Pay getPayProduct() {
return new AlipayProduct();
}
}
public class WechatPayFactory implements PayFactory {
@Override
public Pay getPayProduct() {
return new WechatPayProduct();
}
}
2.产品类
public interface Pay {
//下订单
void placeAnOrder();
}
public class AlipayProduct implements Pay {
@Override
public void placeAnOrder() {
System.out.println("支付宝支付.........");
}
}
public class WechatPayProduct implements Pay {
@Override
public void placeAnOrder() {
System.out.println("微信支付....");
}
}
3.ProductClient
public class PayClient {
public static void main(String[] args) {
PayFactory payFactory = new AlipayFactory();
payFactory.getPayProduct().placeAnOrder();
System.out.println("---------------------------------------------------");
payFactory = new WechatPayFactory();
payFactory.getPayProduct().placeAnOrder();
}
}
二、抽象工厂
1.顶级工厂
/**
* 顶级工厂，里面需要创建子工厂{子工厂抽象层面}
*/
public interface OrderFactory {
PayFactory getPayFactory();
RefunFactory getRefunFactory();
}
2.产品行为规范和具体产品
public interface PayFactory {
//支付下单行为规范
void pay();
}
public interface RefunFactory {
//退款行为规范
void refun();
}
public class AliPay implements PayFactory {
@Override
public void pay() {
System.out.println("支付宝支付 进行下单 ................................");
}
}
public class AliRefunPay implements RefunFactory {
@Override
public void refun() {
System.out.println("支付宝支付后 用户不满意进行退款..................................");
}
}
===>添加微信支付
public class WechatPay implements PayFactory {
@Override
public void pay() {
System.out.println("微信支付进行支付下单...............................");
}
}
public class WechatRefunPay implements RefunFactory {
@Override
public void refun() {
System.out.println("微信支付后用户申请退款.............................");
}
}
3.子工厂创建
public class AliOrderPay implements OrderFactory {
@Override
public PayFactory getPayFactory() {
return new AliPay();
}
@Override
public RefunFactory getRefunFactory() {
return new AliRefunPay();
}
}
*====> 微信产品维度的子工厂*
public class WechatOrderPay implements OrderFactory {
@Override
public PayFactory getPayFactory() {
return new WechatPay();
}
@Override
public RefunFactory getRefunFactory() {
return new WechatRefunPay();
}
}
4.使用简单工厂创建工厂
public class FactoryProduct {
public static OrderFactory getFactory(String type){
if("ali".equalsIgnoreCase(type)){
return new AliOrderPay();
}
if("Wechat".equalsIgnoreCase(type)){
return new WechatOrderPay();
}
return null;
}
}
*====>思考? 如果这里使用工厂方法了?——*
5.Client
public class Client {
public static void main(String[] args) {
OrderFactory orderFactory = FactoryProduct.getFactory("ali");
orderFactory.getPayFactory().pay();
System.out.println("用户收到产品不满意需要进行退款操作");
orderFactory.getRefunFactory().refun();
}
}
=====>学习随笔记录:
一、创建型设计模式:
1.简单工厂
把要创建的产品抽象化。-----抽象产品类 IProduct | public class AppleProject implements IProject
抽象产品类，用于描述所有实例共有的公共接口。 IProduce
具体产品，实现抽象产品列的接口，工厂类穿件对象，如果有多个需要定义多个。Project
2.工厂方法:
工厂进行抽象化。把类的实例化(具体产品的创建)延迟到工厂类的子类(具体工厂)中完成，由子类决定应该实例化那个产品。
参与的角色:
抽象产品类，用于描述所有实例共有的公共接口。 IProduce
具体产品，实现抽象产品列的接口，工厂类穿件对象，如果有多个需要定义多个。Project
抽象工厂，描述具体工厂的公共接口IFactory
具体工厂类，实现创建产品类的对象，实现抽象工厂接口，如果有多个需要定义多个 Factrory
如何定义工厂?如何通过工厂创建产品对象?
工厂----可以是抽象类 , 也可以是接口.一般定义成接口,便于扩展。
如何通过工厂创建产品对象?
public class Factrory{
public static IProduct getFactory(){
return new Product();
}
}
=======>抽象工厂和子工厂:
public interfact IFactory{
IProduct getFactory();
}
public class Factrory implements IFactory{
public IProduct getFactory(){
return new Product();
}
}
工厂方法是为了弥补简单工厂缺点。简单工厂的缺点是：当新增一种产品的时候需要修改简单工厂里面的代码，违背了开闭原则。
抽象工厂里面的方法返回值是抽象产品。
满足：
最少知识原则 | 依赖倒置原则(针对接口编程,依赖于抽象不依赖于具体) | 里氏替换原则(多态的体现,任何基类可以出现的地方，子类一定可以出现) | 开闭原则
3.抽象工厂
产品族--业务域(可以理解成一系列相关的产品对象) | 产品等级 由同一个工厂生产 一系列产品对象。
顶级工厂(超级工厂)创建子工厂 子工厂创建产品 [产品抽象化] 产品实现子工程，重写子工厂里面的方法。
顶级工厂里面的方法可以理解成要创建的产品的工厂，也就是顶级工厂的子工厂。子工厂去创建需要的产品
抽象工厂模式在Spring中应用广泛。
产品的多样化 | 工厂多样化 --------------------- 工厂里面方法的返回值 是产品对象，该产品对象即可是具体的产品对象，也可以是抽象产品对象(抽象产品工厂和产品)
需要设计模式方面的书籍请留言，免费赠送