本文仅供自我学习使用 我是一个小白

设计模式

• 创建型模式用于以灵活和高效的方式创建对象。包括Singleton模式、工厂模式和抽象工厂模式等。
• 结构型模式用于组合类和对象以形成更大的结构。包括适配器模式、桥接模式和装饰器模式等。
• 行为型模式用于处理类或对象之间的通信和控制流。包括观察者模式、策略模式和模板方法模式。

• 设计模式的六大原则
• 单一职责原则（SRP）：一个类只应该有一个引起它变化的原因。
• 开放封闭原则（OCP）：软件实体（类、模块、函数等）应该对扩展开放，对修改关闭。
• 里氏替换原则（LSP）：子类型必须能够替换掉它们的父类型。
• 依赖倒置原则（DIP）：高层模块不应该依赖于低层模块，两者都应该依赖于抽象接口；抽象接口不应该依赖于具体实现，具体实现应该依赖于抽象接口。
• 接口隔离原则（ISP）：不应该强迫一个类实现它不需要的接口，应该将接口拆分成更小和更具体的部分，以便客户端只需要知道它们感兴趣的部分。
• 迪米特法则（LOD）：一个对象应该对其他对象有尽可能少的了解，通常称为“最少知识原则”。

一.创建型模式

创建型模式用于以灵活和高效的方式创建对象

1.单例模式

(1).饿汉式

类在初始化的时候就实现实例化

public class Singleton {private static Singleton instance = new Singleton();private Singleton() {}public static Singleton getInstance() {return instance;}
}

(2).懒汉式，双检锁

类在第一次调用的时候进行的实例化加载a

/*** 在懒汉式基础上加入双重检验锁，保证线程安全和性能。*/
public class Singleton {private volatile static Singleton instance = null;private Singleton() {}public static Singleton getInstance() {if (instance == null) {synchronized (Singleton.class) {if (instance == null) {instance = new Singleton();}}}return instance;}
}
/*** 普通懒汉式*/
public class Singleton2{//私有的默认构造子private Singleton2(){}//注意，这里没有finalprivate static Singleton2 single=null;//静态工厂方法public synchronized static Singleton2 getInstance(){if(single==null){single=new Singleton2();}return single;}
}

(3).静态内部类

/*** 使用静态内部类来实现懒汉式单例模式，保证线程安全和性能。这种方式能达到双检锁方式一样的功效，但实现更简单。*/
public class Singleton {private Singleton() {}private static class SingletonHolder {private static final Singleton INSTANCE = new Singleton();}public static Singleton getInstance() {return SingletonHolder.INSTANCE;}
}

(4).枚举

public enum Singleton {INSTANCE;private Singleton() {// 私有构造方法//}public static Singleton getInstance() {return INSTANCE;}
}

1.线程安全:
枚举单例模式是线程安全的。由于枚举常量只会被实例化一次，所以无论多少个线程并发访问，都能
保证只有一个实例被创建。
2.防止反射攻击
枚举单例模式天然地防止了反射攻击。在Java中，通过反射可以获取类的私有构造器，并强制创建实
例。但是，对于枚举类来说，私有构造器是无法被反射调用的，因此无法通过反射来创建枚举类的实
例。
3.防止序列化和反序列化问题
枚举单例模式也能防止序列化和反序列化问题。当一个枚举类型被序列化时，只会将枚举常量的名称
写入到序列化流中，而不会序列化枚举常量本身。当枚举类型被反序列化时，只会通过名称来获取对
应的枚举常量。因此，无论是序列化还是反序列化，都无法破坏枚举单例的特性。
枚举单例模式的应用场景

枚举单例模式适用于以下场景：
需要实现单例的类比较简单，没有复杂的初始化过程。
需要确保线程安全。
需要防止反射攻击和序列化问题。
由于枚举单例模式的优势，建议在满足以上条件的情况下使用枚举单例。

2.原型模式

以一个实例为原型克隆出来和他一样的实例
浅克隆

public class Person implements Cloneable {private String name;private int age;public Person(String name, int age) {this.name = name;this.age = age;}public String getName() {return name;}public void setName(String name) {this.name = name;}public int getAge() {return age;}public void setAge(int age) {this.age = age;}/*** 进行浅克隆  如果克隆对象里面的值发生改变也会影响到其他对象的值* @return* @throws CloneNotSupportedException*/@Overridepublic Person clone() throws CloneNotSupportedException {return (Person) super.clone();}
}

深克隆（原型引用类型，并且原型和引用类型都需要实现序列化，和实现克隆接口）

public class DeepProtoType implements Serializable, Cloneable {public String name; //String 属性public DeepCloneableTarget deepCloneableTarget;// 引用类型public DeepProtoType() {super();}//深拷贝 通过对象的序列化实现public Object deepClone() {//创建流对象ByteArrayOutputStream bos = null;ObjectOutputStream oos = null;ByteArrayInputStream bis = null;ObjectInputStream ois = null;try {//序列化bos = new ByteArrayOutputStream();oos = new ObjectOutputStream(bos);oos.writeObject(this); //当前这个对象以对象流的方式输出//反序列化bis = new ByteArrayInputStream(bos.toByteArray());ois = new ObjectInputStream(bis);DeepProtoType copyObj = (DeepProtoType) ois.readObject();return copyObj;} catch (Exception e) {e.printStackTrace();return null;} finally {//关闭流try {bos.close();oos.close();bis.close();ois.close();} catch (Exception e2) {System.out.println(e2.getMessage());}}}
}

3.工厂模式

java的工厂模式

(1).简单工厂模式

静态工厂方法模式,可以根据参数的不同返回不同类的实例,简单工厂模式专门定义一个类来负责创建其他类的实例,被创建的实例通常都是具有共同的父类.

小知识:
在面对对象程序设计而定时候,需要遵循开闭原则(开闭原则规定:程序对于扩展是开放的,对于修改是
封闭的),打个比方现在有一个生产螺丝的生产螺丝,现在突然加了一一个任务需要生产口罩,这个时候
可以选择新增一个生产线来进行生产口罩而不是再原来的基础上将生产螺丝的机器改为生产口罩的
生产线

/*** SimpleFactory 工厂类* 优点:创建和使用分开,创建完全交给工厂类* 缺点:工厂类不够灵活,对象特别多的时候工厂类都需要进行改动判断--后面可以参考策略模式改进*/
public class SimpleFactory {public static Product createProduct(String type) {if (StringUtils.isNotEmpty(type) && type.equals("A")) {return new ProductA();} else {return new ProductB();}}public static void main(String[] args) {SimpleFactory.createProduct("A");SimpleFactory.createProduct("B");}}abstract class Product {public abstract void print();
}/*** 对象产品A*/
class ProductA extends Product {@Overridepublic void print() {System.out.println("ProductA");}
}/*** 对象产品B*/
class ProductB extends Product {@Overridepublic void print() {System.out.println("ProductB");}
}

4.抽象工厂模式

一个工厂下面还有其他多个工厂,可以理解为多个复合的简单工厂合集–这里实际上是属于违反开闭原则

public class FactoryPattern {public static void main(String[] args) {Factory factory = new AppleFactory();Phone phone = factory.createPhone();phone.print();}
}
interface  Phone{void print();
}class Iphone implements Phone{@Overridepublic void print() {System.out.println("安卓手机");}
}class ApplePhone implements Phone{@Overridepublic void print() {System.out.println("苹果手机");}
}/*** 抽象工厂*/
interface Factory{Phone createPhone();
}/*** 安卓手机工厂类*/
class IPhoneFactory implements Factory{@Overridepublic Phone createPhone() {return new Iphone();}
}/*** 苹果手机工厂类*/
class AppleFactory implements Factory{@Overridepublic Phone createPhone() {return new ApplePhone();}
}

5.建造者模式

二.结构型模式

结构型模式用于组合类和对象以形成更大的结构

6.适配器模式

7.组合模式

8.装饰器模式

动态的给一个对象添加一些额外的功能,就增加功能来说,装饰模式比生成子类更加灵活

public class DecoratorPattern {public static void main(String[] args) {new RobotDecorator(new FirstRobot()).doMoreThing();}}interface Robot {void doSomething();
}/*** 装饰器*/
class FirstRobot implements Robot {@Overridepublic void doSomething() {System.out.println("我会走路");System.out.println("我会唱歌");}
}class RobotDecorator implements Robot {private Robot robot;public RobotDecorator(Robot robot) {this.robot = robot;}@Overridepublic void doSomething() {robot.doSomething();}public void doMoreThing(){robot.doSomething();System.out.println("我新增了跳舞功能");}
}

9.外观模式

10.享元模式

11.代理模式

(1).静态代理

(2).jdk动态代理

(3).cglib动态代理

12.桥接模式

三.行为型模式

行为型模式用于处理类或对象之间的通信和控制流

13.责任链模式

14.命令模式

15.解释器模式

16.迭代器模式

17.观察者模式

18.状态模式

19.模板模式

20.中介者模式

21.备忘录模式

22.访问者模式

23.策略模式

四.其他

24.过滤器模式

25.空对象模式

锁