设计模式

设计模式

1. 简单工厂模式

2. 单例设计模式

• 饿汉模式

• 懒汉模式：线程不安全

• 私有静态内部类的懒汉模式：线程安全

• package com.qf.design;
  ​
  /**
   * 设计模式： 1：Design Pattern 2：对于软件设计中的某一类问题的经验的总结，最优的解决方案。
   * 
   * 1：单例设计模式 singleton 如何保证一个类只能创建该类的唯一的一个对象。 java.lang.Runtime;
   * 
   * 1:单例设计模式的第一种实现。 饿汉模式。
   * 2:单例设计模式的第二种实现。 懒汉模式。（第一次使用的时候创建）
   * 3：单例模式的 静态内部类的实现。
   * 4：使用枚举类实现。
   */
  public class TestDesign {
  ​
      public static void main(String[] args) {
  //      final MySingleton1 instance11;
  //      final MySingleton1 instance22;;
          
  //      new Thread(){
  //          public void run() {
  //              MySingleton1 instance1 = MySingleton1.getInstance();
  //              System.out.println(instance1);
  //          };
  //      }.start();
  //      
  //      new Thread(){
  //          public void run() {
  //              MySingleton1 instance2 = MySingleton1.getInstance();
  //              System.out.println(instance2);
  //              
  //          };
  //      }.start();
  //      
          
  //      System.out.println(Outer.i);
  //      System.out.println(Outer.getInstance());
          
          
  ​
      }
  ​
  }
  ​
  // 饿汉模式。 单例类。天生线程安全的。
  // 缺点：类加载的时候唯一的对象就被创建出来了，一直占用内存。可能会影响软件的开始运行速度。
  class MySingleton {
      private MySingleton() {
      }
  ​
      // 唯一的实例。
      private static final MySingleton instance = new MySingleton();
  ​
      public static MySingleton getInstance() {
          return instance;
      }
  }
  ​
  // 懒汉模式
  //优点：第一次使用的时候创建，不用一直占用内存了。缺点：实现相对复杂。
  class MySingleton1 {
      private MySingleton1() {
      }
  ​
      // 唯一的实例。
      private static MySingleton1 instance;
  ​
      // 第一次调用方法的时候，创建该对象。
  //  同步方法的效率比较低。
      public /*synchronized*/ static MySingleton1 getInstance() {
  //      为了保证不用每次都进行是否上锁的判断。提高效率的。
          if(instance == null){
              synchronized (MySingleton1.class) {
  //              为了保证创建一个对象。
                  if (instance == null) {
                      try {
                          Thread.sleep(100);
                      } catch (InterruptedException e) {
                          e.printStackTrace();
                      }
                      instance = new MySingleton1();
                  }
              }
          }
          return instance;
      }
  }
  ​
  //静态内部单例类
  class Outer{
  //  static int i;
  //  static{
  //      System.out.println("Outer");
  //  }
      private Outer(){}
      
  //  外部类加载的时候，不会加载内部类。唯一的实例，也是使用的时候创建。
      private static class Inner{
  //      static{
  //          System.out.println("Inner");
  //      }
          private Inner(){}
  //      天生线程安全。
          private static final Outer instance = new Outer();
      }
  ​
      public static Outer getInstance(){
          return Inner.instance;
      }
  }
  ​
  ​
  enum MyClass{
      instance;
      
      private int num;
      
      MyClass(){}
      
      void test(){}
      
  }
  ​
  ​
  ​

•  

3.适配器设计模式

package com.qf.design;
/**
 * 适配器设计模式
 * 
 * 分为两种
 *  1：类适配器模式
 *  2：对象适配器模式。
 * 
 * InputStreamReader 就使用了适配器模式。
 *
 */
public class TestAdapter {
​
    public static void main(String[] args) {
​
    }
}
​
class BaseClass{
//  基础民电提供的电压
    public int getBaseV(){
        return 220;
    }
}
​
//1：类适配器模式
class AdapterClass extends BaseClass{
    @Override
    public int getBaseV() {
        return super.getBaseV()/11;
    }
}
​
//  2：对象适配器模式。
class AdapterClass1{
    BaseClass base;
​
    public AdapterClass1(BaseClass base) {
        super();
        this.base = base;
    }
    public int getBaseV() {
        return base.getBaseV()/11;
    }
    
}
​
​