降低系统的耦合度，使用者不需要关注对象创建的细节

一.单例模式

涉及到一个单一的类，这个类只能创建一个对象，这个类提供了一个可以唯一获得对象的方法，不需要外界实例化对象

1.饿汉式

类加载的时候对象就会被创建

//饿汉式
public class Singleton {
    //创建对象
    private static Singleton singleton=new Singleton();
    //私有化构造器
    private Singleton(){
    }
    //提供给外界获得对象的类
    public static Singleton getSingleton(){
        return singleton;
    }
}

2.懒汉式

在第一次调用时创建对象

//懒汉式
public class Singleton {
    //声明对象
    private static Singleton singleton=null;
    //私有化构造器
    private Singleton(){
    }
    //提供给外界获得对象的类
    public static Singleton getSingleton(){
        if(singleton==null){
            //如果等于null 创建对象
            singleton=new Singleton();
        }
        return singleton;
    }
}

线程安全版（双重检查）

//懒汉式（线程安全的）
public class Singleton {
    //声明对象
    private  static volatile Singleton singleton=null;
    //私有化构造器
    private Singleton(){
    }
    //提供给外界获得对象的类
    public static Singleton getSingleton(){
        if(singleton==null){
            synchronized (Singleton.class){
                if(singleton==null){
                    //如果等于null 创建对象
                    singleton=new Singleton();
                }
            }
        }
        return singleton;
    }
}

静态内部类版（线程安全）

//懒汉式（线程安全的）
public class Singleton {
    //私有化构造器
    private Singleton(){
    }
  public static class inner{
        private static final Singleton singleton= new Singleton();
  }
  public Singleton getSingleton(){
        return inner.singleton;
  }
}

二.工厂模式

在java中，万物皆对象，这些对象都需要创建，如果创建的时候直接new该对象，就会对该对象耦合严重，假如我们要更换对象，所有new对象的地方都需要修改一遍，这显然违背了软件设计的开闭原则。如果我们使用工厂来生产对象，我们就只和工厂打交道就可以了，彻底和对象解耦，如果要更换对象，直接在工厂里更换该对象即可，达到了与对象解耦的目的；所以说，工厂模式最大的优点就是：解耦。

1.简单工厂模式

简单工厂包含如下角色：
抽象产品：定义了产品的规范，描述了产品的主要特性和功能。
具体产品：实现或者继承抽象产品的子类
具体工厂：提供了创建产品的方法，调用者通过该方法来获取产品。

public class SimpleCoffeeFactory { 
    public Coffee createCoffee(String type) { 
        Coffee coffee = null; 
        if("americano".equals(type)) { 
            coffee = new AmericanoCoffee(); 
        } else if("latte".equals(type)) { 
            coffee = new LatteCoffee(); 
        }
        return coffee; 
    } 
}

优点：
封装了创建对象的过程，可以通过参数直接获取对象。把对象的创建和业务逻辑层分开，这样以后就避免了修改客户代码，如果要实现新产品直接修改工厂类，而不需要在原代码中修改，这样就降低了客户代码修改的可能性，更加容易扩展。
缺点：
增加新产品时还是需要修改工厂类的代码，违背了“开闭原则”。

2.静态工厂模式

public class SimpleCoffeeFactory { 
    public static Coffee createCoffee(String type) { 
        Coffee coffee = null; 
        if("americano".equals(type)) { 
            coffee = new AmericanoCoffee(); 
        } else if("latte".equals(type)) { 
            coffee = new LatteCoffee(); 
        }
        return coffee; 
    } 
}

3.工厂方法模式

定义一个用于创建对象的接口，让子类决定实例化哪个产品类对象。工厂方法使一个产品类的实例化延迟到其工厂的子类。
结构
工厂方法模式的主要角色：
抽象工厂（Abstract Factory）：提供了创建产品的接口，调用者通过它访问具体工厂的工厂
方法来创建产品。
具体工厂（ConcreteFactory）：主要是实现抽象工厂中的抽象方法，完成具体产品的创建。
抽象产品（Product）：定义了产品的规范，描述了产品的主要特性和功能。
具体产品（ConcreteProduct）：实现了抽象产品角色所定义的接口，由具体工厂来创建，它同
具体工厂之间一一对应。

//咖啡工厂类
public  interface CoffeeFactory {
    public  Coffee createCoffee(String name);
}
//美式咖啡工厂类，专门生产美式咖啡
public class AmericanCoffeeFactory  implements CoffeeFactory{
    @Override//生成美式咖啡
    public Coffee createCoffee(String name) {
        return new AmericanCoffee();
    }
}
//咖啡店类
public class CoffeeStore {
    private CoffeeFactory factory;
    public void setFactory(CoffeeFactory factory){
        this.factory=factory;
    }
    public Coffee createCoffee(){
        Coffee meishi = factory.createCoffee("meishi");
        return meishi;
    }
}

4.抽象工厂模式

现咖啡店业务发生改变，不仅要生产咖啡还要生产甜点，如提拉米苏、抹茶慕斯等，要是按照工厂方法模式，需要定义提拉米苏类、抹茶慕斯类、提拉米苏工厂、抹茶慕斯工厂、甜点工厂类，很容易发生类爆炸情况。其中拿铁咖啡、美式咖啡是一个产品等级，都是咖啡；提拉米苏、抹茶慕斯也是一个产品等级；拿铁咖啡和提拉米苏是同一产品族（也就是都属于意大利风味），美式咖啡和抹茶慕斯是同一产品族（也就是都属于美式风味）。所以这个案例可以使用抽象工厂模式实现

抽象工厂

public interface DessertFactory { 
    Coffee createCoffee(); 
    Dessert createDessert(); 
}

具体工厂

//美式甜点工厂 
public class AmericanDessertFactory implements DessertFactory { 
    public Coffee createCoffee() { 
        return new AmericanCoffee(); 
    }
    public Dessert createDessert() { 
        return new MatchaMousse(); 
    } 
}
//意大利风味甜点工厂 
public class ItalyDessertFactory implements DessertFactory { 
    public Coffee createCoffee() { 
        return new LatteCoffee(); 
    }
    public Dessert createDessert() { 
        return new Tiramisu(); 
    } 
}

三.原型模式

用一个已经创建的实例作为原型，通过复制该原型对象来创建一个和原型对象相同的新对象。
结构
原型模式包含如下角色：
抽象原型类：规定了具体原型对象必须实现的的 clone() 方法。
具体原型类：实现抽象原型类的 clone() 方法，它是可被复制的对象。
访问类：使用具体原型类中的 clone() 方法来复制新的对象

1.浅克隆

创建一个新对象，新对象的属性和原来对象完全相同，对于非基本类型属性，仍指向原有属性所指向的对象的内存地址。

//浅克隆
public class Realizetype implements Cloneable{
    @Override
    protected Realizetype clone() throws CloneNotSupportedException {
        return (Realizetype) super.clone();
    }
}

2.深克隆

创建一个新对象，属性中引用的其他对象也会被克隆，不再指向原有对象地址。
为每一个对象属性都进行一次克隆

public class sheep implements Cloneable, Serializable {
    private int age;
    private String name;
    public sheep friend=null;
    public sheep() {
    }
    public sheep(int age, String name) {
        this.age = age;
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    //深拷贝
    protected sheep clone2(){
        sheep sheep=null;
        try {
            sheep=(sheep)super.clone();
            if(sheep.friend!=null){
                sheep.friend=sheep.friend.clone2();
            }
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }
        return sheep;
    }
}

四.建造者模式

将一个复杂对象的构建与表示分离，使得同样的构建过程可以创建不同的表示。
分离了部件的构造(由Builder来负责)和装配(由Director负责)。从而可以构造出复杂的对象。这个模式适用于：某个对象的构建过程复杂的情况。
由于实现了构建和装配的解耦。不同的构建器，相同的装配，也可以做出不同的对象；相同的构建器，不同的装配顺序也可以做出不同的对象。也就是实现了构建算法、装配算法的解耦，实现了更好的复用。
建造者模式可以将部件和其组装过程分开，一步一步创建一个复杂的对象。用户只需要指定复杂对象的类型就可以得到该对象，而无须知道其内部的具体构造细节。
结构
抽象建造者类（Builder）：这个接口规定要实现复杂对象的那些部分的创建，并不涉及具体的部件对象的创建。
具体建造者类（ConcreteBuilder）：实现 Builder 接口，完成复杂产品的各个部件的具体创建方法。在构造过程完成后，提供产品的实例。
产品类（Product）：要创建的复杂对象。
指挥者类（Director）：调用具体建造者来创建复杂对象的各个部分，在指导者中不涉及具体产品的信息，只负责保证对象各部分完整创建或按某种顺序创建。

public class Bike {
    private String frame;//车架
    private String seat;//车座
    public Bike() {
    }
    public Bike(String frame, String seat) {
        this.frame = frame;
        this.seat = seat;
    }
    public String getFrame() {
        return frame;
    }
    public void setFrame(String frame) {
        this.frame = frame;
    }
    public String getSeat() {
        return seat;
    }
    public void setSeat(String seat) {
        this.seat = seat;
    }
}

建造者

public  abstract class Builder {
    public Bike bike=new Bike();//只是声明了一个自行车，具体部件没有组装
    public abstract void buildFrame();
    public abstract void buildSeat();
    public abstract Bike createBike();
}
public class OFOBuilder extends Builder{
    @Override
    public void buildFrame() {
        bike.setFrame("ofoFrame");
    }
    @Override
    public void buildSeat() {
        bike.setSeat("ofoSeat");
    }
    @Override
    public Bike createBike() {
        return this.bike;
    }
}

指挥者

public class Director {
    Builder builder;
    public Director(Builder builder) {
        this.builder = builder;
    }
    //组装
    public Bike construct(){
        builder.buildFrame();
        builder.buildSeat();
        return builder.createBike();
    }
}

建造者模式的封装性很好。使用建造者模式可以有效的封装变化，在使用建造者模式的场景中，一般产品类和建造者类是比较稳定的，因此，将主要的业务逻辑封装在指挥者类中对整体而言可以取得比较好的稳定性。

设计模式

创建型模式