JAVA 设计模式相关_java 双重委派设计模式-CSDN博客

本文链接：https://blog.csdn.net/liu1390910/article/details/105088540

接口隔离原则

单一原则

依赖倒转原则

里氏替换原则

子类中尽量不要重写父类的方法，适当的情况下，可以通过聚合，组合，依赖来解决问题，或者可以让类升级为基类

开闭原则

迪米特法则

合成复用原则

UML建模

类之间的关系：

依赖

泛化

实现关系

关联关系

聚合关系（可以分开）

组合关系（不可以分开）

设计模式

单例模式

饿汉式（静态常量）

饿汉式（静态代码块）

懒汉式（线程不安全）

懒汉式（线程安全，同步方法）

懒汉式（线程安全，同步代码块）

双重监察

静态内部类

主类装载时，内部类是不会装载的，只有用到内部类是才会装载，并且是线程安全的

getInstance（）不需要加 synchronized

枚举（强烈推荐）

注意事项

工厂模式

简单工厂模式（静态工厂模式）

定义一个创建不同对象的工厂，由这个类来封装实例化对象的代码

工厂方法模式

抽象工厂模式

工厂模式在JDK源码中的应用：

Calendar类实例化调用了简单工厂模式

Calendar.getInstance()

工厂模式总结

原型模式

传统模式编写：

在spring中原型模式的运用：

浅拷贝

深拷贝

//深拷贝 - 方式 1 使用clone 方法
@Override
protected Object clone() throws CloneNotSupportedException {
   
   Object deep = null;
   //这里完成对基本数据类型(属性)和String的克隆
   deep = super.clone(); 
   //对引用类型的属性，进行单独处理
   DeepProtoType deepProtoType = (DeepProtoType)deep;
   deepProtoType.deepCloneableTarget  = (DeepCloneableTarget)deepCloneableTarget.clone();
   
   // TODO Auto-generated method stub
   return deepProtoType;
}

//深拷贝 - 方式2 通过对象的序列化实现 (推荐)

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) {
      // TODO: handle exception
      e.printStackTrace();
      return null;
   } finally {
      //关闭流
      try {
         bos.close();
         oos.close();
         bis.close();
         ois.close();
      } catch (Exception e2) {
         // TODO: handle exception
         System.out.println(e2.getMessage());
      }
   }
   
}

原型模式注意事项和细节：

建造者模式

传统模式：

建造者模式：

JDK中源码部分使用了建造者模式：

适配器模式

类适配器

//适配器类
public class VoltageAdapter extends Voltage220V implements IVoltage5V {

   @Override
   public int output5V() {
      // TODO Auto-generated method stub
      //获取到220V电压
      int srcV = output220V();
      int dstV = srcV / 44 ; //转成 5v
      return dstV;
   }

}

public class Client {

   public static void main(String[] args) {
      // TODO Auto-generated method stub
      System.out.println(" === 类适配器模式 ====");
      Phone phone = new Phone();
      phone.charging(new VoltageAdapter());
   }

}

对象适配器

public class VoltageAdapter  implements IVoltage5V {

   private Voltage220V voltage220V; // 关联关系-聚合
   
   
   //通过构造器，传入一个 Voltage220V 实例
   public VoltageAdapter(Voltage220V voltage220v) {
      
      this.voltage220V = voltage220v;
   }



   @Override
   public int output5V() {
      
      int dst = 0;
      if(null != voltage220V) {
         int src = voltage220V.output220V();//获取220V 电压
         System.out.println("使用对象适配器，进行适配~~");
         dst = src / 44;
         System.out.println("适配完成，输出的电压为=" + dst);
      }
      
      return dst;
      
   }

}

public class Client {

   public static void main(String[] args) {
      // TODO Auto-generated method stub
      System.out.println(" === 对象适配器模式 ====");
      Phone phone = new Phone();
      phone.charging(new VoltageAdapter(new Voltage220V()));
   }

}

接口适配器

public abstract class AbsAdapter implements Interface4 {

   //默认实现
   public void m1() {

   }

   public void m2() {

   }

   public void m3() {

   }

   public void m4() {

   }
}

public class Client {
   public static void main(String[] args) {
      
      AbsAdapter absAdapter = new AbsAdapter() {
         //只需要去覆盖我们 需要使用 接口方法
         @Override
         public void m1() {
            // TODO Auto-generated method stub
            System.out.println("使用了m1的方法");
         }
      };
      
      absAdapter.m1();
   }
}