设计模式（单例模式，工厂模式，适配器模式）

1：设计模式是什么？

前人总结的一些经验和思想，给我们提供了从抽象到具体的方法

总共有23种
    分类：
        创建型模式： 创建对象。（其实创建对象比较耗内存的动作）
        结构型模式： 对象的组成。
        行为模式： 对象能够做什么。

    工厂模式：
        通过一个工厂类来帮我们创建对象

    单例模式：
        要求：类在内存中的对象只有一个。
        eg：打印机，网站访问计数器。
    如何实现单例设计模式：
        分析：
            1：让外界不能通过构造方法创建对象。
                将构造方法私有化。
            2：类本身要创建一个对象
                在成员位置创建一个对象
            3：对外提供一个公共的方法可以获取该对象

    package com.thread.module;

public class Student {
    //1：构造函数初始化为私有，防止外界直接通过构造函数创建对象
    private Student() {

    }

    //6：由于静态只能访问静态，此处也加上static
    //7：为了不让外界直接访问加上 private
    //2：提供一个对象
    private static Student s = new Student();

    //3：为了保证外界能够获取到对象，提供给外界的一个方法，
    //4：但是此时还是访问不到。因为该方法没有加static只能通过对象获取
    //5：为了能通过类名获取，加入static
    public static Student getStudent() {
        return s;
    }

}

static修饰，随着类的加载就加载

    单例模式分类：
        饿汉式：
            一加载就创建对象（private static Student s = new
             Student();）  
             就是上面的代码。
        懒汉式：
            用的时候才去创建
            public static Student1 getStudent1() {
        if (s == null) {
            s = new Student1();
        }
        return s;
    }

package com.thread.module;

/**
 * 懒汉式
 */
public class Student1 {
    private Student1() {
    }

    private static Student1 s = null;

    public static Student1 getStudent1() {
        if (s == null) {
            s = new Student1();
        }
        return s;
    }

    public void show() {
        System.out.println("懒汉式");
    }
}

我们要掌握哪种方式呢？
    开发：饿汉式
    面试：懒汉式
为什么？
    因为饿汉式不会出现线程安全问题。
    懒汉式：
        延迟加载思想：（懒加载思想）服务器启动的时候加载的资源会少一点
        线程不安全，你要给别人分析出安全问题的原因，并提供解决方案。
            /**
     * 此代码会产生线程安全问题
     * 当有四个线程调用该方法
     * t1,t2,t3,t4
     * @return
     */
    //5:解决：改为同步方法加synchronized
    public synchronized static Student1 getStudent1() {
        //1：t1,t2,t3,t4都进来了
        if (s == null) {
            //2：t1刚进入这里，执行权就被t2抢到了，t2也进来了，同样，t3,t4都进来了
            //3：四个线程都创建了对象，导致线程不安全（虽然最后返回的就只有一个对象）
            s = new Student1();
        }
        return s;
    }

Runtime类本身就是一个饿汉式的体现,通过查看源码可知。

 public class Runtime{  
       private Runtime(){}  
       private static Runtime currentRuntime = new Runtime();  
      public static Runtime getRuntime(){  
          return currentRuntime;  
       }  
  }  
  //测试Runtime
public class RuntimeDemo {
    public static void main(String[] args) throws IOException {
        Runtime r = Runtime.getRuntime();
        //可以调用出path路径中配置过的exe文件
        r.exec("notepad");
    }
}

适配器模式

    /**
    *场景：
        接口：Inter中有多个抽象方法
        普通类：有一个方法，方法的形参是Inter接口
            public void show(Inter i){}
        测试类：创建普通类的对象调用方法。
    */
    package com.thread.module;

/**
 * 接口中的方法都是抽象的，不管你加没加abstract，没有加默认就adstract
 * 
 */
public interface Inter {
    public abstract void show();
    public abstract void show1();
    public abstract void show2();
    public abstract void show3();
}

public class InterDemo {
    //方法的形式参数如果是接口，那么传递的时候肯定是接口的子类对象，这就是多态。
    public void show(Inter i) {
        i.show3();
    }
}

public class InterTest {
    public static void main(String[] args) {
        InterDemo id = new InterDemo();
        id.show(new Inter() {

            @Override
            public void show3() {
                System.out.println("show3");
            }

            @Override
            public void show2() {
                System.out.println("show2");
            }

            @Override
            public void show1() {
            }

            @Override
            public void show() {
            }
        });
    }
}

在上面发现一个弊端。
在写测试方法的时候，创建匿名Inner内部类的时候，会将所有的方法都重写，这样导致代码非常的难看，以及不简介
改善：

    怎么实现？
        接口中有多个方法
        然后来一个抽象方法去实现这个接口。而且提供的都是空实现
        最后在使用的时候，只需要重写需要使用的那个方法就可以了。
        package com.thread.module;

public abstract class InterAdapter implements Inter {

    @Override
    public void show() {
    }

    @Override
    public void show1() {
    }

    @Override
    public void show2() {
    }

    @Override
    public void show3() {
    }

}

//InterTest中修改
    id.show(new InterAdapter() {
            @Override
            public void show3() {
                System.out.println("show3");
            }
        });