设计模式笔记

工厂模式：

1.Simple Factory Pattern : 是指由一个工厂对象决定创建出哪一种产品类的实例，简单工厂是产品的工厂，工厂类负责创建的对象较少，客户端需要传入工厂类的参数，对于如何创建对象的逻辑不关心。

缺点：工厂类的职责相对过重，增加新的产品时需要修改工厂类的判断逻辑，违背了开闭原则，不易于扩展过于复杂的产品结构；

这里用了反射，虽然不符合开闭原则，一般简单工厂模式用于比较固定的选项，基本不会再新增或修改对象

public class CourseFactory {
    //返回课程 也可以直接传标识进来，然后自行创建对应的课程 也可传.class ，都用反射获取实例
    //规定了传进来的值 必须是这个 接口的子类  单一职责原则
    public ICourse create(Class<? extends ICourse> clazz){
/*        if("java".equals(name)){
            return new JavaCourse();
        }else if ("python".equals(name)){
            return new PythonCourse();
        }else{
            return null;
        }
        利用反射机制
        if(!(null==className||"".equals(className))){
            try {
                return (ICourse) Class.forName(className).newInstance();
            } catch (Exception e) {
               e.printStackTrace();
            }
        }
        return null;*/
        if(null!=clazz){
            try {
                return  clazz.newInstance();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        return null;
    }
}
//产品的顶层接口 两个课程均有相同的动作

public interface ICourse {
    void record();
}

public class JavaCourse implements ICourse{
    @Override
    public void record() {
        System.out.println("录制java课程");
    }
}

public class PythonCourse implements ICourse{
    @Override
    public void record() {
        System.out.println("python课程录制");
    }
}

public class test {
    public static void main(String[] args) {
        //用工厂去创建
        ICourse course = new CourseFactory().create(JavaCourse.class);

        course.record();
        //用工厂去创建
        ICourse course1 = new CourseFactory().create(JavaCourse.class);
        course1.record();
        //是否是一个对象   false
        System.out.println(course==course1);

    }
}

2.Factory Method Pattern :工厂方法模式是工厂的工厂；定义一个创建对象的接口，但让实现这个接口的类来决定实例化哪个类，工厂方法让类的实例化推迟到子类中进行，符合开闭原则；需要抽象出顶层工厂，实现多个不同类型的工厂（各个类型工厂生产对应的产品），具体的创建逻辑交由具体的工厂去实现，用户只需要关心产品对应的工厂，不需要关心细节。提高了系统的可扩展性。

缺点：一个产品对应一个工厂，增加了代码的复杂度。

/**
 * Author:Eric
 * DATE:2023/8/19-11:00
 * Decription: 课程的抽象接口
 */
public interface ICourse {
    void record();
}


/**
 * Author:Eric
 * DATE:2023/8/19-15:24
 * Decription: 工厂方法模式 工厂接口 工厂的规范建立一个工厂的标准
 */
public interface ICourseFactory {
    ICourse create();
}

public class JavaCourse implements ICourse {
    @Override
    public void record() {
        System.out.println("录制java课程");
    }
}

public class PythonCourse implements ICourse {
    @Override
    public void record() {
        System.out.println("python课程录制");
    }
}


public class JavaCourseFactory implements ICourseFactory{
    @Override
    public ICourse create() {
        return new JavaCourse();
    }
}


public class PythonCourseFactory implements ICourseFactory{
    @Override
    public ICourse create() {
        return new PythonCourse();
    }
}

public class Test {
    public static void main(String[] args) {
        ICourseFactory factory = new PythonCourseFactory();
        ICourse course = factory.create();
        course.record();
    }
}

3.Abstract Factory Pattern : 最复杂的一个工厂模式，需要理解产品族和产品等级，规定了所有可能被创建的产品集合，产品族中扩展新的产品困难，需要修改抽象工厂的接口，增加了系统的抽象性和理解难度，具体产品在应用层代码隔离，无须关心创建细节，将一个系列的产品族统一到一起创建；强调一系列相关的产品对象；一起使用创建对象需要大量重复的代码，提供一个产品类的库，所有的产品以同样的接口出现，从而使客户端不依赖于具体实现。

/**
 * Author:Eric
 * DATE:2023/8/19-16:00
 * Decription: 支付抽象工厂方式 
 */
public abstract class IPayment {
    //定义好 都会进行的操作 比如 登录操作
    public void load(Class<? extends IPayapp> claze){
        try {
            IPayapp app = claze.newInstance();
            app.pay();
        } catch (InstantiationException e) {
            throw new RuntimeException(e);
        } catch (IllegalAccessException e) {
            throw new RuntimeException(e);
        }

        System.out.println("登录成功！");
    }
    //所有支付方式都有支付成功 后记录账单的功能
protected abstract Record paysuce();
    //所有的支付都可以退款功能 不论国内还是国外支付
protected abstract Money refund();
}

/**
 * Author:Eric
 * DATE:2023/8/19-16:02
 * Decription: 支付软件 分国内支付 国外支付，共同接口都是支付
 */
public interface IPayapp {
    void pay();
}

/**
 * Author:Eric
 * DATE:2023/8/19-16:03
 * Decription: 国内支付
 */
public class ChinaPay implements IPayapp{
    @Override
    public void pay() {
        System.out.println("国内支付软件支付");
    }
    public void weixinPay(){
        System.out.println("微信支付");
    }
}

/**
 * Author:Eric
 * DATE:2023/8/19-16:04
 * Decription:
 */
public class AmericaPay implements IPayapp{
    @Override
    public void pay() {
        System.out.println("歪果仁支付软件支付");
    }
    public void applePay(){
        System.out.println("苹果支付");
    }
}
/**
 * Author:Eric
 * DATE:2023/8/19-16:07
 * Decription: 记录
 */
public interface Record {
    //生成支付记录扣钱
    void record();
}


/**
 * Author:Eric
 * DATE:2023/8/19-16:08
 * Decription: 退钱
 */
public interface Money {
    void back();
}

public class WeiAppFactory extends IPayment{

    @Override
    protected Record paysuce() {
        super.load(ChinaPay.class);
        return new WeixinRecord();
    }

    @Override
    protected Money refund() {
        super.load(ChinaPay.class);
        return new WeixinMoney();
    }
}

public class AppleAppFactory extends IPayment{
    @Override
    protected Record paysuce() {
        super.load(AmericaPay.class);
        return new AppleRecord();
    }

    @Override
    protected Money refund() {
        super.load(AmericaPay.class);
        return new AppleMoney();
    }
}

public class WeixinMoney implements Money{
    @Override
    public void back() {
        System.out.println("微信退款成功！");
    }
}

public class WeixinRecord implements Record{
    @Override
    public void record() {
        System.out.println("生成微信支付成功记录");
    }
}
public class AppleMoney implements Money{
    @Override
    public void back() {
        System.out.println("生成苹果支付退款成功");
    }
}
public class AppleRecord implements Record{
    @Override
    public void record() {
        System.out.println("生成苹果支付记录");
    }
}

public class Test {
    public static void main(String[] args) {
        //国内支付
        IPayment fa = new WeiAppFactory();
        fa.paysuce().record();
        fa.refund().back();
    }
}

---