设计模式（Design Pattern）

一.设计模式简述

1.设计模式
编程中的一些套路，能够使我们的代码实现特定的目的，使结构上更加优秀
2.设计模式分类：
设计模式分为三大类：
创建型模式，共五种：工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式。
结构型模式，共七种：适配器模式、装饰器模式、代理模式、外观模式、桥接模式、组合模式、享元模式。
行为型模式，共十一种：策略模式、模板方法模式、观察者模式、迭代子模式、责任链模式、命令模式、备忘录模式、状态模式、访问者模式、中介者模式、解释器模式。
3.单例模式（Singleton）
定义：虚拟机里这个类只有一个实例（创建一个对象），让构造方法私有，别人无法创建此类的实例
单例模式有以下特点：
　　1、单例类只能有一个实例。
　　2、单例类必须自己创建自己的唯一实例。
　　3、单例类必须给所有其他对象提供这一实例。
方式一：饿汉式单例

public class Singleton1 {
    //让构造方法私有，别人无法创建这个实例
    private Singleton1(){}
    //自己创建这个实例
    private static final Singleton1 ME=new Singleton1();
    //获取唯一实例
    public static Singleton1 getInstance(){
        return ME;
    }
}

在同一个虚拟机范围内，Singleton的唯一实例只能通过getInstance()方法访问。
方式二.懒汉式单例
用到才创建，用不到不创建实例，在多线程下保证线程安全加入synchronized同步

public class Singleton2 {
    private Singleton2(){}
    private static  Singleton2 ME;
    public static synchronized Singleton2 getInstance(){
        if(ME==null){
            ME=new Singleton2();
        }
        return ME;
    }
}

方式三.懒汉式单例的更佳实现

static{
        System.out.println("Singleton4类被加载了");
    }
    private Singleton4(){}
    //由静态内部类创建它的唯一实例
    private static class Holder{
        static{
            System.out.println("Holder类被加载了");
        }
        static Singleton4 ME=new Singleton4();
    }
    //第一次调用getInstance（）才能出发Holder(),才能触发类加载，类加载只会执行一次
    public static Singleton4 getInstance(){
        return Holder.ME;
    }
    public static void test(){
        System.out.println("Singleton4其他方法");
    }
    public static void main(String[] args) {
        Singleton4.test();
        Singleton4.getInstance();
        Singleton4.getInstance();//只被加载一次
    }
}    

结果

Singleton4类被加载了
Singleton4其他方法
-----------------------------------
Holder类被加载了

破坏单例的方法：
1）反射来破坏，不能new,反射可以调用私有构造
2）反序列化可以破坏单例
4.享元模式（flyweight）
尽量减少对象对虚拟机的占用，提倡重用已有的对象，而不是创建新的对象

public static void main(String[] args) {
        System.out.println(Integer.valueOf(1)==Integer.valueOf(1));//true
        System.out.println(Integer.valueOf(100)==Integer.valueOf(100));//true
        System.out.println(Integer.valueOf(200)==Integer.valueOf(200));//false
    }

1,100返回同一整数包装对象
valueof里 享元模式，200超出了享元范围才创建新的对象，
Integer享元范围-128-+127之间，1,100在享元范围内，底层在IntergerCache缓存中预先创建好对象，设定好享元范围，达到重用对象的目的。
Byte,Short,Character,Long都有享元范围，范围在（-127-128）之间。
在java中连接池-对数据库连接对象进行了重用也是享元模式的应用。
5.原型模式（prototype）
用原型实例指定创建对象的种类，并通过拷贝这些原型创建新的对象。
根据已有对象来创建新的对象，克隆
原型模式主要用于对象的复制，它的核心是就是类图中的原型类Prototype。Prototype类需要具备以下两个条件：
（1）实现Cloneable接口。在java语言有一个Cloneable接口，它的作用只有一个，就是在运行时通知虚拟机可以安全地在实现了此接口的类上使用clone方法。在java虚拟机中，只有实现了这个接口的类才可以被拷贝，否则在运行时会抛出CloneNotSupportedException异常。
（2） 重写Object类中的clone方法。Java中，所有类的父类都是Object类，Object类中有一个clone方法，作用是返回对象的一个拷贝，但是其作用域protected类型的，一般的类无法调用，因此，Prototype类需要将clone方法的作用域修改为public类型。

import java.util.Date;
public class User implements Cloneable{
   private String name;
   private int age;
   private Date birthday;
    public User() {
    }
    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;
    }
    public Date getBirthday() {
        return birthday;
    }
    public void setBirthday(Date birthday) {
        this.birthday = birthday;
    }
    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
}

 public static void main(String[] args) throws CloneNotSupportedException {
        User user = new User();
        user.setName("王小帅");
        user.setAge(19);
        user.setBirthday(new Date());
        User user2 =(User) user.clone();
        System.out.println(user==user2);
        System.out.println(user2.getAge());
        System.out.println(user2.getName());
        System.out.println(user2.getBirthday());
        user2.getBirthday().setDate(28);
        System.out.println("新克隆用户的生日："+user2.getBirthday());
        System.out.println("王小帅的生日："+user.getBirthday());
    }

结果
    Wed Nov 28 19:22:17 CST 2018
    Wed Nov 28 19:22:17 CST 2018

修改日期后，新对象与原对象日期都发生了改变
这就牵涉到深拷贝和浅拷贝
这是因为基本类型不受修改的影响,引用类型受到影响。
Date克隆的只是地址，它们的地址相同，原对象与新对象引用的是同一对象，所以都会被修改。
克隆属于浅拷贝，对象的属性仅仅复制了地址，没有cloneable把内容新复制一份。
因此我们在进行深拷贝时，重写clone（）方法

protected Object clone() throws CloneNotSupportedException {
        ByteArrayOutputStream os = new ByteArrayOutputStream();
        try {
            // 把自己（当前对象）写入输出流
            new ObjectOutputStream(os).writeObject(this);

            // 拿到字节数组
            byte[] bytes = os.toByteArray();

            // 反序列化为新对象
            ByteArrayInputStream is = new ByteArrayInputStream(bytes);

            // 对象输入流
            ObjectInputStream ois = new ObjectInputStream(is);

            return ois.readObject();

        } catch (IOException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
        return null;
    }

使用场景：当对象属性非常多时，希望新的对象的大部分属性从原有对象复制而来，只修改某几个属性。