23种设计模式（一）

设计原则：

单一职责原则(Single Responsibility Principle, SRP)：一个类只负责一个功能领域中的相应职责，或者可以定义为：就一个类而言，应该只有一个引起它变化的原因。

开闭原则(Open-Closed Principle, OCP)：一个软件实体应当对扩展开放，对修改关闭。即软件实体应尽量在不修改原有代码的情况下进行扩展。

里氏代换原则(Liskov Substitution Principle, LSP)：所有引用基类（父类）的地方必须能透明地使用其子类的对象。

依赖倒转原则(Dependency Inversion Principle, DIP)：抽象不应该依赖于细节，细节应当依赖于抽象。换言之，要针对接口编程，而不是针对实现编程。

接口隔离原则(Interface Segregation Principle, ISP)：使用多个专门的接口，而不使用单一的总接口，即客户端不应该依赖那些它不需要的接口。

迪米特法则(Law of Demeter, LoD)：一个软件实体应当尽可能少地与其他实体发生相互作用。

合成复用尽量先使用组合或者聚合等关联关系来实现，其次才考虑使用继承关系来实现

创建型模式，共五种：工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式。

单例 singleton

//饿汉模式   
private static final Singleton01  sl = new Singleton01();
    private Singleton01(){

    }
    public static Singleton01 getInstance(){
        return sl;
    }

    public static void main(String[] args){
        Singleton01 s1 = Singleton01.getInstance();
        Singleton01 s2 = Singleton01.getInstance();
        System.out.println(s1 == s2);
    }

   //懒加载 
    private static  Singleton02  sl;
    private Singleton02(){
    }
    public static Singleton02 getInstance(){
        if (sl == null){
            try {
                Thread.sleep(1);//睡一秒 被其他线程打乱 几率变大
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            sl = new Singleton02();
        }
        return sl;
    }

    // synchronized  懒汉
 private static  Singleton03  sl;
    private Singleton03(){
    }

    public static synchronized Singleton03 getInstance(){
        if (sl == null){
            sl = new Singleton03();
        }
        return sl;
    }

//双重检验锁 
private volatile static  Singleton04  sl;
    private Singleton04(){
    }

    public static  Singleton04 getInstance(){
        if (sl == null){
            synchronized (Singleton04.class){
                if (sl == null){
                    sl = new Singleton04();
                }
            }
        }
        return sl;
    }

   //静态内部类  
  private Singleton05(){
    }
    //静态内部类
    private static class SingInner{
        private final static Singleton05 SL = new Singleton05();
    }
    public static Singleton05 getInstance(){
        return SingInner.SL;
    }

枚举。

工厂 Factory

模式用于封装和管理对象的创建，是一种创建型模式

方便在于产品上的扩展

public abstract class Product {
    abstract void go();
}
public class CarFactory {
    public Car createCar(){
        System.out.println("create.Car..");
        return new Car();
    }
}
public class Car extends Product {
    @Override
    void go() {
        System.out.println("car...xiaokuai...");
    }
}
public class BusFactory {
    public Bus createBus(){
        System.out.println("create.Bus..");
        return new Bus();
    }
}
public class Bus extends Product {
    @Override
    void go() {
        System.out.println("youji xiangdui haiman...");
    }
}

  public static void main(String[] args) {
        Product p = new CarFactory().createCar();
        p.go();
    }

抽象工厂 absFactory

来 定义一个 产品族 抽象工厂，抽象产品，具体工厂，具体产品

在产品上不好扩展

//手机产品接口
public interface PhoneProduct {
    void start();
}
//电脑产品接口
public interface ComputerProdect {
    void start();
}
public interface ProductFactory {
    PhoneProduct phoneProduct();

    ComputerProdect computerprodect();
}

public class XmiFactory implements ProductFactory{
    @Override
    public PhoneProduct phoneProduct() {
        return new XmiPhone();
    }

    @Override
    public ComputerProdect computerprodect() {
        return new XmiComputer();
    }
}
public class XmiComputer implements ComputerProdect{
    @Override
    public void start() {
        System.out.println("xiaomi...computer..start");
    }
}
public class XmiPhone implements PhoneProduct {
    @Override
    public void start() {
        System.out.println("xiaomi...phone....start..");
    }
}

==================================
    public class HweiFactory implements ProductFactory{
    @Override
    public PhoneProduct phoneProduct() {
        return new HweiPhone();
    }

    @Override
    public ComputerProdect computerprodect() {
        return new HweiComputer();
    }
}
public class HweiPhone implements PhoneProduct{
    @Override
    public void start() {
        System.out.println("Huawei...phone...start..");
    }
}
public class HweiComputer implements ComputerProdect{
    @Override
    public void start() {
        System.out.println("huawei....computer..start..");
    }
}
================================
     public static void main(String[] args) {
        System.out.println("===============小米系列==========");
        XmiFactory xmf = new XmiFactory();
        PhoneProduct xpp = xmf.phoneProduct();
        xpp.start();
        ComputerProdect xcp = xmf.computerprodect();
        xcp.start();
        System.out.println("===============华为系列==========");
        HweiFactory hf = new HweiFactory();
        PhoneProduct hpp = hf.phoneProduct();
        hpp.start();
        ComputerProdect hcp = hf.computerprodect();
        hcp.start();
    }

建造者 Builder

建造者模式将一个复杂对象的构建与表示分离，使得同样的构建过程可以创建不同的表示

//抽象建造者
public abstract class Builder {
    protected Product house = new Product();
    //将建造的流程写好, 抽象的方法
    public abstract void One();
    public abstract void Two();
    public abstract void Three();
    //建造房子好， 将产品(房子) 返回
    public Product buildHouse() {
        return house;
    }
}
//产品
public class Product {
    private String first;
    private String second;
    private String thirdly;

    public String getFirst() {
        return first;
    }

    public void setFirst(String first) {
        this.first = first;
    }

    public String getSecond() {
        return second;
    }

    public void setSecond(String second) {
        this.second = second;
    }

    public String getThirdly() {
        return thirdly;
    }

    public void setThirdly(String thirdly) {
        this.thirdly = thirdly;
    }
}
//具体建造者
public class ConcreteBuilder extends Builder{
    @Override
    public void One() {
        System.out.println("A。。。。。。");
    }

    @Override
    public void Two() {
        System.out.println("A。。。。。。");
    }

    @Override
    public void Three() {
        System.out.println("A。。。。。。");
    }
}
public class ConcreteBuilder2 extends Builder{
    @Override
    public void One() {
        System.out.println("B.......");
    }

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

    @Override
    public void Three() {
        System.out.println("B.......");
    }
}
//指挥者
public class Director {
    Builder builder;
    //构造器传入 Builder
    public Director(Builder builder) {
        this.builder = builder;
    }
    //通过setter 传入 houseBuilder
    public void setBuilder(Builder builder) {
        this.builder = builder;
    }

    //如何处理
    public Product builder(){
        builder.One();
        builder.Two();
        builder.Three();

        return builder.buildHouse();
    }
}

public static void main(String[] args) {
        //A
        ConcreteBuilder cb1 = new ConcreteBuilder();
        //准备创建的指挥者
        Director d = new Director(cb1);
        //完成
        Product b = d.builder();

        System.out.println("--------------------------");
        //B
        ConcreteBuilder2 cb2 = new ConcreteBuilder2();
        //重置建造者
        d.setBuilder(cb2);
        //完成返回产品(
        d.builder();
    }

原型 Prototype

实现 Cloneable 接口 重写 clone() 方法

浅克隆不会克隆原对象中的引用类型，仅仅拷贝了引用类型的指向。深克隆则拷贝了所有。也就是说深克隆能够做到原对象和新对象之间完全没有影响。

而深克隆的实现就是在引用类型所在的类实现Cloneable接口，并使用public访问修饰符重写clone方法。

public static void main(String[] args) throws Exception {
        Person p1 = new Person();
        Person p2 = (Person)p1.clone();
        System.out.println(p2.age + " " + p2.score);
        System.out.println(p2.loc);

        System.out.println(p1.loc == p2.loc);
        p1.loc.street = "sh";
        System.out.println(p2.loc);

        p1.loc.street.replace("sh", "sz");
        System.out.println(p2.loc.street);
    }
}

class Person implements Cloneable {
    int age = 18;
    int score = 100;

    Location loc = new Location("bj", 22);
    @Override
    public Object clone() throws CloneNotSupportedException {
        Person p = (Person)super.clone();
        p.loc = (Location)loc.clone();
        return p;
    }
}

class Location implements Cloneable {
    String street;
    int roomNo;

    @Override
    public String toString() {
        return "Location{" +
                "street='" + street + '\'' +
                ", roomNo=" + roomNo +
                '}';
    }

    public Location(String street, int roomNo) {
        this.street = street;
        this.roomNo = roomNo;
    }

    @Override
    public Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
}