设计模式笔记

工厂模式：

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{@Overridepublic void record() {System.out.println("录制java课程");}
}public class PythonCourse implements ICourse{@Overridepublic 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();//是否是一个对象   falseSystem.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 {@Overridepublic void record() {System.out.println("录制java课程");}
}public class PythonCourse implements ICourse {@Overridepublic void record() {System.out.println("python课程录制");}
}public class JavaCourseFactory implements ICourseFactory{@Overridepublic ICourse create() {return new JavaCourse();}
}public class PythonCourseFactory implements ICourseFactory{@Overridepublic 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{@Overridepublic 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{@Overridepublic 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{@Overrideprotected Record paysuce() {super.load(ChinaPay.class);return new WeixinRecord();}@Overrideprotected Money refund() {super.load(ChinaPay.class);return new WeixinMoney();}
}public class AppleAppFactory extends IPayment{@Overrideprotected Record paysuce() {super.load(AmericaPay.class);return new AppleRecord();}@Overrideprotected Money refund() {super.load(AmericaPay.class);return new AppleMoney();}
}public class WeixinMoney implements Money{@Overridepublic void back() {System.out.println("微信退款成功！");}
}public class WeixinRecord implements Record{@Overridepublic void record() {System.out.println("生成微信支付成功记录");}
}
public class AppleMoney implements Money{@Overridepublic void back() {System.out.println("生成苹果支付退款成功");}
}
public class AppleRecord implements Record{@Overridepublic void record() {System.out.println("生成苹果支付记录");}
}

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

单例模式：

内存中只有一个实例，减少了内存开销，避免对资源的多重占用，严格控制访问，隐藏其构造方法；扩展对象困难，旨在确保一个类在任何情况下绝对只有一个实例，并提供一个全局访问点

A.饿汉式：

单例类首次加载的时候就创建。对外提供公共获取实例的方法，将加载的时候初始化的类返回出去，执行效率高，性能高，没有锁参与。

缺点：类加载的时候就初始化了，在牟星情况下可能会造成内存浪费。


/*** Author:Eric* DATE:2023/8/20-10:07* Decription: 饿汉式 创建单例*/
public class HungrySingleton {//private static final HungrySingleton hungrySingleton = new HungrySingleton();//构造方法隐藏private HungrySingleton(){}//提供一个 获取实例的公共方法，将最开始就初始化的实例 返回出去//类加载的时候就初始化了public static HungrySingleton getInstance(){return hungrySingleton;}}

B.懒汉式：由饿汉式进化而来，当被外部类调用的时候才会创建，节省了内存

b.1 简单版本懒汉式单例

/*** Author:Eric* DATE:2023/8/20-11:08* Decription: 简单的 懒汉式* 1.优点：节省了内存* 2.缺点： 可能出现线程不安全的问题* 3.加了synchronized 解决了线程安全问题，但是会有性能瓶颈*/
public class LazySimpleSingleton {private static LazySimpleSingleton instance;private LazySimpleSingleton(){};//加锁解决线程问题 但是这样会造成性能瓶颈public synchronized  static LazySimpleSingleton getInstance(){if(instance==null ){instance=new LazySimpleSingleton();}return instance;}
}

b.2 双重校验方式，解决线程安全问题，同时需要volatile关键字，解决指令重排问题，但是代码不够优雅

/*** Author:Eric* DATE:2023/8/20-11:56* Decription: 双重校验* 从之前的懒汉式代码块加锁 进行改进得来*/
public class LazyDoubleCheck {//解决指令重排序的问题private volatile static LazyDoubleCheck instance;private LazyDoubleCheck() {}//加锁解决线程问题public static LazyDoubleCheck getInstance() {//第一次检查是否要阻塞if (instance == null) {synchronized (LazyDoubleCheck.class) {//检查是否要重新创建 实例if (instance == null) {instance = new LazyDoubleCheck();//指令重排序}}}return instance;}//解决序列化破坏问题private Object readResolve() {return instance;}
}

b.3 静态内部类方式静态成员变量是加载的时候就会分配内存空间，而静态内部类是使用的时候才会分配；写法优雅，但要防止被反射破坏

/*** Author:Eric* DATE:2023/8/20-12:12* Decription: 静态内部类单例方式*/
/*
*加载的时候：ClassPath: LazyStaticInnerClass.class
* 用到的时候才会加载     LazyStaticInnerClass$LazyHolder.class
* 优点：写法优雅  ，很好的利用了java本身语法特点，性能高了避免了内存浪费
* 缺点：能够被反射破坏
* */
public class LazyStaticInnerClass {private LazyStaticInnerClass(){//防止反射直接拿构造方法进行创建if(LazyHolder.INSTANCE!=null){throw new RuntimeException("不允许非法访问");}}public static LazyStaticInnerClass getInstance(){return LazyHolder.INSTANCE;}//因为静态成员变量加载的时候会分配内存空间，而创建静态内部类是用的时候才会private static class LazyHolder{private static final LazyStaticInnerClass INSTANCE = new LazyStaticInnerClass();}
}

C.注册式 将每一个实例都缓存到统一的容器中，使用唯一标识获取实例

c.1 枚举式单例：官方反射里面就不允许反射获取枚举的构造器，枚举在声明的时候就将其当成常量放到了map中类似饿汉式，太多也会有内存问题，不适合大批量创建类。所有后续会进行垓心，spring ioc就是借鉴的枚举式单例进行改良的。

/*** Author:Eric* DATE:2023/8/20-12:35* Decription: 注册式： 枚举式单例*/
public enum EnumSingleton {//声明的时候 枚举就将这个INSTANCE 当成常量 放到一个map中存着了INSTANCE;private Object data;public Object getData() {return data;}public void setData(Object data) {this.data = data;}public static EnumSingleton getInstance(){return INSTANCE;}//解决序列化破坏问题private Object readResolve() {return INSTANCE;}
}

/*** Author:Eric* DATE:2023/8/20-12:37* Decription: 测试枚举类单例模式* 可防止反射破坏 也优雅*/
public class EnumSingletonTest {public static void main(String[] args) {EnumSingleton instance = EnumSingleton.getInstance();instance.setData(new Object());EnumSingleton instance1 = EnumSingleton.getInstance();System.out.println(instance1==instance);System.out.println(instance.getData()==instance1.getData());Class clazz = EnumSingleton.class;try {Constructor c  = clazz.getDeclaredConstructor(String.class,int.class);c.setAccessible(true);  //依然无法用反射去获取枚举对象 底层就不允许Object o = c.newInstance();System.out.println(o);} catch (Exception e) {e.printStackTrace();}}
}

c.2 容器式单例解决大批量创建的问题(将实例放到一个concurrentHashMap中，ioc也是如此); 也有线程问题，需要解决，如果单例模式需要防止序列化反序列化的破坏，需要加上固定的方法，如代码中所标识，这样反序列化的时候就不会额外创建一个新对象，不会再分配新的内存地址值。

/*** Author:Eric* DATE:2023/8/20-12:51* Decription: 容器式单例模式 解决了枚举式单例的大批量问题*/
public class ContainerSingleton {//构造方法私有化private ContainerSingleton(){};private static Map<String,Object> ioc = new ConcurrentHashMap<String,Object>();public  static Object getInstance(String className){Object instance=null;if(!ioc.containsKey(className)){try {instance = Class.forName(className).newInstance();ioc.put(className,instance);} catch (Exception e) {e.printStackTrace();}return instance;}else {return ioc.get(className);}}
}

D.ThreadLocal单例：不是全局单例，只保证线程内部的全局唯一，且天生线程安全

/*** Author:Eric* DATE:2023/8/20-13:47* Decription: ThreadLocal单例 不是全局单例 保证线程单例*/
public class ThreadLocalSingleton {private static final ThreadLocal<ThreadLocalSingleton> threadLocalInstance =new ThreadLocal<ThreadLocalSingleton>() {@Overrideprotected ThreadLocalSingleton initialValue() {return new ThreadLocalSingleton();}};private ThreadLocalSingleton() {}public static ThreadLocalSingleton getInstance() {return threadLocalInstance.get();}
}