java回归基础复习干货总结九

基础十

设计模式复习巩固

1. 说说什么是单例模式？

   答：单例模式是一种常用的软件设计模式，在这个模式中，单例模式对象的类必须保证只有一个实例存在。
   优点：不会频繁的创建和销毁对象，这样可以节省系统的资源。
   
   几种单例模式的写法：
   饿汉式：线程安全
   懒汉式：非线程安全
   双重检查锁：线程安全
   

   package Singleton;
   
   /*
    * @Author: jun
    * @Date:2023/2/19 15:31
    * @概述：
    */
   
   /**
    * 饿汉式
    * 1.类加载时就初始化，比较浪费内存，不能够延迟加载
    * 2.基于classloader机制避免多线程的同步问题，线程安全
    * 3.无需上锁，调用效率高
    */
   public class SingletonByHunger {
   
       //私有实例，类初始化就加载
       private static SingletonByHunger instance = new SingletonByHunger();
   
       //私有构造方法
       private SingletonByHunger(){};
   
       //公共和静态的获取实例方法
       public static SingletonByHunger getInstance() {
           return instance;
       }
   }
   
   

   package Singleton;
   
   /*
    * @Author: jun
    * @Date:2023/2/19 15:47
    * @概述：
    */
   
   /**
    * 懒汉式
    * 此方法线程不安全，但可实现延迟加载
    */
   public class SingletonByLazy {
   
       //私有化实例，初始化时不加载，即延迟加载
       private static SingletonByLazy instance;
   
       //私有构造方法
       private SingletonByLazy(){};
   
       //公共获取实例方法（线程不安全），这里没有上锁
       public static SingletonByLazy getInstance() {
           if (instance == null){
               instance = new SingletonByLazy();
           }
           return instance;
       }
   }
   
   

   package Singleton;
   
   /*
    * @Author: jun
    * @Date:2023/2/19 15:52
    * @概述：
    */
   
   /**
    * 懒汉模式
    * 通过关键字synchronized声明公共的获取实例的方法getInstance(),可以确保线程安全，能做到延迟加载，缺点是效率低
    */
   public class SingletonByLazyAndLock {
   
       //私有化实例，初始化时不加载
       private static SingletonByLazyAndLock instance;
   
       //私有构造方法
       private SingletonByLazyAndLock(){};
   
       //公共获取实例方法（线程安全，调用效率低）
       public synchronized static SingletonByLazyAndLock getInstance() {
           if (instance == null){
               instance = new SingletonByLazyAndLock();
           }
           return instance;
       }
   }
   
   

   package Singleton;
   
   /*
    * @Author: jun
    * @Date:2023/2/19 16:03
    * @概述：
    */
   
   /**
    * 双重检查锁
    * 双重判断检查，延迟加载
    * 线程安全
    * 要求是jdk1.5+
    */
   public class SingletonByDoubleCheckLock {
   
       //私有实例，volatile关键字，禁止指令重排
       private volatile static SingletonByDoubleCheckLock instance;
   
       //私有构造
       private SingletonByDoubleCheckLock(){};
   
       //公共获取实例方法（线程安全）
       public static SingletonByDoubleCheckLock getInstance() {
           if (instance == null){//第一次检查，加锁之前判断是否为空，可以确保instance不为空的情况下，不加锁直接返回实例
               synchronized (SingletonByDoubleCheckLock.class){
                   if (instance == null){//第二次检查
                       instance = new SingletonByDoubleCheckLock();
                   }
               }
           }
           return instance;
       }
   }
   
   

代码转载自：https://blog.csdn.net/qq_41863849/article/details/106299726

2. 说说你对代理模式的理解？

   代理模式是给某一个对象提供一个对象，并由代理对象控制对原对象的引用
   
   优点：
   代理模式能够协调调用者和被调用者，在一定程度上降低了系统的耦合度
   可以灵活的隐藏被代理对象的部分功能和服务，也增加了额外的功能和服务
   
   缺点：
   由于使用了代理模式，因此程序的性能没有直接调用性能高
   使用代理模式提高了代码的复杂度
   
   

3. 说说工厂模式。

   简单工厂模式又叫静态工厂方法模式，就是建立一个工厂类，对实现了同一个结构的一些类进行实例的创建。比如，一台咖啡机就可以理解为一个工厂模式，你只需要按下想喝咖啡品类的按钮，它就会给你生产一杯相应的咖啡，你不需要管它内部的具体实现，只需要告诉它你的需求就可以。
   
   优点：
   1.工厂类含有必要的判断逻辑，可以决定在什么时候创建哪一个产品类的实例，客户端可以免除直接创建产品对象的责任，而仅仅"消费"产品，简单工厂模式通过这种方式实现了对责任分割，它提供了专门的工厂类用于创建对象。
   2.客户端无须知道所创建的具体产品类和类名，只需要知道具体产品类所对应的参数即可，对于一些复杂的类名，通过简单工厂模式可以减少使用者的记忆量。
   
   
   缺点：
   1.不易扩展
   2.较为复杂，不易维护
   

4. 抽象工厂模式

   抽象工厂模式是在简单工厂的基础上将未来可能需要修改的代码抽象出来，通过继承的方式让子类去做决定。