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中应用广泛。

产品的多样化   |  工厂多样化     ---------------------    工厂里面方法的返回值 是产品对象，该产品对象即可是具体的产品对象，也可以是抽象产品对象(抽象产品工厂和产品)

需要设计模式方面的书籍请留言，免费赠送