1.设计模式概述

1.什么是设计模式

设计模式(Design Pattern)是前辈们对代码开发经验的总结，是解决特定问题的一系列套路。
它不是语法规定，而是一套用来提高代码可复用性、可维护性、可读性、稳健性以及安全性的解决方案。

1995年，GoF (Gang of Four,四人组/四人帮)合作出版了《设计模式:可复用面向对象软件的基础》一书,共收录了23种设计模式,从此树立了软件设计模式领域的里程碑，人称「GoF设计模式」

2.学习设计模式的意义

设计模式的本质是面向对象设计原则的实际运用，是对类的封装性、继承性和多态性以及类的关联关系和组合关系的充分理解。

• 正确使用设计模式具有以下优点:
  • 可以提高程序员的思维能力、编程能力和设计能力。
  • 使程序设计更加标准化、代码编制更加工程化，使软件开发效率大大提高，从而缩短软件的开发周期。
  • 使设计的代码可重用性高、可读性强、可靠性高、灵活性好、可维护性强。

3.23种设计模式

按照设计模式的作用可分为三种模式，创建型模式、结构型模式、行为型模式

4.七大设计原则

2.创建者模式

1.单例模式

保证一个类仅有一个实例，并提供一个访问它的全局访问点

主要解决：一个全局使用的类频繁地创建与销毁。

关键代码：构造函数是私有的，自己创建自己的唯一实例，公有的静态的方法

优点：

• 1.在内存里只有一个实例，减少了内存的开销，尤其是频繁的创建和销毁实例（比如管理学院首页页面缓存）。
• 2、避免对资源的多重占用（比如写文件操作）。

缺点：没有接口，不能继承，与单一职责原则冲突，一个类应该只关心内部逻辑，而不关心外面怎么样来实例化。

应用场景：WEB 中的计数器

饿汉式

一上来就把所有的东西加载进来，非常浪费空间

类加载时创建（不管使不使用都创建），天生线程安全

生命周期长

/*** 饿汉式单例*/
public class Hungry {/*** 可能会浪费空间*/private byte[] data1=new byte[1024*1024];private byte[] data2=new byte[1024*1024];private byte[] data3=new byte[1024*1024];private byte[] data4=new byte[1024*1024];private Hungry(){}private final static Hungry hungry = new Hungry();public static Hungry getInstance(){return hungry;}}

懒汉式

第一次调用才初始化，避免内存浪费。

单线程安全，多线程不安全

生命周期短

public class Singleton {  private static Singleton instance;  private Singleton (){}  public static Singleton getInstance() {  if (instance == null) {  instance = new Singleton();  }  return instance;  }  
}

这里可以给他加锁完成线程安全，但是就降低了效率

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

DCL懒汉式（双重校验（判定）锁）

这里new对象的时候会有原子性不一致的问题，就导致可能出现指令重排的问题，给LazyMan2的类对象加一个volatile保证指令重排的问题

public class Singleton {  private volatile static Singleton singleton;  private Singleton (){}  public static Singleton getSingleton() {  if (singleton == null) {  synchronized (Singleton.class) {  if (singleton == null) {  singleton = new Singleton();  }  }  }  return singleton;  }  
}

静态内部类

线程安全，功能和双重校验锁一样

public class Singleton {  private static class SingletonHolder {  private static final Singleton INSTANCE = new Singleton();  }  private Singleton (){}  public static final Singleton getInstance() {  return SingletonHolder.INSTANCE;  }  
}

但是这时候出现了问题，反射可以破坏单例模式

枚举

它更简洁，自动支持序列化机制，绝对防止多次实例化。可以防止反射来破坏单例模式，因为反射破坏不了枚举类

public enum Singleton {  INSTANCE;  public void whateverMethod() {  }  
}

2.工厂模式

在工厂模式中，我们在创建对象时不会对客户端暴露创建逻辑，并且是通过使用一个共同的接口来指向新创建的对象

• 三种模式：
  • 简单工厂模式
    • 用来生产同一等级结构中的任意产品(对于增加新的产品，需要扩展已有代码)
  • 工厂方法模式
    • 用来生产同一等级结构中的固定产品(支持增加任意产品)
  • 抽象工厂模式
    • 围绕一个超级工厂创建其他工厂。该超级工厂又称为其他工厂的工厂。
• 小结：
  • 简单工厂模式(静态工厂模式)
    • 虽然某种程度上不符合设计原则，但实际使用最多!
  • 工厂方法模式
    • 不修改已有类的前提下，通过增加新的工厂类实现扩展。
  • 抽象工厂模式
    • 不可以增加产品，可以增加产品族!

应用场景：JDBC中的Connection对象的获取、Spring中IOC容器创建管理bean对象、反射中Class对象的newInstance方法

简单工厂模式（静态工厂模式）

public interface Car {void name();
}class Wuling implements Car {@Overridepublic void name() {System.out.println("五菱");}
}class Tesla implements Car {@Overridepublic void name() {System.out.println("特斯拉");}
}class CarFactory {public static Car getCar(String car) {if ("五菱".equals(car)) {return new Wuling();} else if ("特斯拉".equals(car)) {return new Tesla();} else {return null;}}
}class Consumer {public static void main(String[] args) {//传统方式//Car wuling = new Wuling();//Car tesla = new Tesla();//工厂模式Car car = CarFactory.getCar("五菱");Car car1 = CarFactory.getCar("特斯拉");car.name();car1.name();}
}

这时我想要在加一辆车，那么车工厂就要增加一个大众类型的车，按照类型去寻找车

工厂方法

工厂方法，增加一层工厂的约束，对工厂去管理，要什么车就去什么工厂，然后工厂帮你找到车

public interface Car {void name();
}class Wuling implements Car {@Overridepublic void name() {System.out.println("五菱");}
}class Tesla implements Car {@Overridepublic void name() {System.out.println("特斯拉");}
}
interface CarFactory{Car getCar();
}
class TeslaFactory implements CarFactory{@Overridepublic Car getCar() {return new Tesla();}
}
class WulingFactory implements CarFactory{@Overridepublic Car getCar() {return new Wuling();}
}class Consumer {public static void main(String[] args) {//传统方式//Car wuling = new Wuling();//Car tesla = new Tesla();//工厂模式//Car car = CarFactory.getCar("五菱");//Car car1 = CarFactory.getCar("特斯拉");//car.name();//car1.name();Car car = new WulingFactory().getCar();Car car1 = new TeslaFactory().getCar();car1.name();car.name();}
}

3.抽象工厂模式

提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。

何时使用：系统的产品有多于一个的产品族，而系统只消费其中某一族的产品

优点：当一个产品族中的多个对象被设计成一起工作时，它能保证客户端始终只使用同一个产品族中的对象

缺点：产品族扩展非常困难，要增加一个系列的某一产品，既要在抽象的 Creator 里加代码，又要在具体的里面加代码。

注意事项：产品族难扩展，产品等级易扩展。

//手机接口
public interface IphoneProduct {void start();void shutdown();void callup();void sendSMS();
}
//路由器接口
public interface IRouterProduct {void start();void shutdown();void openwife();void setting();
}//华为手机
public class HuaweiPhone implements IphoneProduct{@Overridepublic void start() {System.out.println("华为手机开机");}@Overridepublic void shutdown() {System.out.println("华为手机关机");}@Overridepublic void callup() {System.out.println("华为手机打电话");}@Overridepublic void sendSMS() {System.out.println("华为手机发短信");}
}
//华为路由器
public class HuaweiRouter implements IRouterProduct{@Overridepublic void start() {System.out.println("开启华为路由器");}@Overridepublic void shutdown() {System.out.println("关闭华为路由器");}@Overridepublic void openwife() {System.out.println("开启华为wifi");}@Overridepublic void setting() {System.out.println("打开华为设置");}
}
//小米手机
public class XiaomiPhone implements IphoneProduct{@Overridepublic void shutdown() {System.out.println("关闭小米手机");}@Overridepublic void callup() {System.out.println("小米手机打电话");}@Overridepublic void sendSMS() {System.out.println("小米手机发短信");}@Overridepublic void start() {System.out.println("开启小米手机");}
}
//小米路由器
public class XiaomiRouter implements IRouterProduct{@Overridepublic void start() {System.out.println("开启小米路由器");}@Overridepublic void shutdown() {System.out.println("关闭小米路由器");}@Overridepublic void openwife() {System.out.println("开启小米wifi");}@Overridepublic void setting() {System.out.println("开启小米设置");}
}//生产路由器和手机的工厂
public interface IProductFactory {//生产手机IphoneProduct iphoneProduct();//生产路由器IRouterProduct irouterproduct();
}//生产华为系列路由器和手机的工厂
public class HuaweiFactory implements IProductFactory{@Overridepublic IphoneProduct iphoneProduct() {return new HuaweiPhone();}@Overridepublic IRouterProduct irouterproduct() {return new HuaweiRouter();}
}
//生产小米系列路由器和手机的工厂
public class XiaomiFactory implements IProductFactory{@Overridepublic IphoneProduct iphoneProduct() {return new XiaomiPhone();}@Overridepublic IRouterProduct irouterproduct() {return new XiaomiRouter();}
}//主机，去找一个商品直接去该系列的工厂去寻找并使用
public class Clinet {public static void main(String[] args) {System.out.println("==========小米系列产品==========");//小米工厂XiaomiFactory xiaomiFactory = new XiaomiFactory();IphoneProduct iphoneProduct = xiaomiFactory.iphoneProduct();iphoneProduct.start();iphoneProduct.shutdown();System.out.println("==========华为系列产品==========");//小米工厂HuaweiFactory huaweiFactory = new HuaweiFactory();iphoneProduct = huaweiFactory.iphoneProduct();iphoneProduct.start();iphoneProduct.shutdown();}
}

4.建造者模式

将一个复杂的构建与其表示相分离，使得同样的构建过程可以创建不同的表示。

建造者：创建和提供实例，导演：管理建造出来的实例的依赖关系。

与工厂模式的区别是：建造者模式更加关注与零件装配的顺序

优点： 1、建造者独立，易扩展。 2、便于控制细节风险。

缺点： 1、产品必须有共同点，范围有限制。 2、如内部变化复杂，会有很多的建造类。

使用场景： 1、需要生成的对象具有复杂的内部结构。 2、需要生成的对象内部属性本身相互依赖。

• 建造者与抽象工厂模式的比较：
  • 与抽象工厂 模式相比,建造者模式返回一个组装好的完整产品，而抽象工厂模式返回一系列相关的产品，这些产品位于不同的产品等级结构，构成了一个产品族。
  • 在抽象工厂模式中，客户端实例化工厂类,然后调用工厂方法获取所需产品对象，而在建造者模式中，客户端可以不直接调用建造者的相关方法，而是通过指挥者类来指导如何生成对象，包括对象的组装过程和建造步骤,它侧重于一步步构造一 个复杂对象， 返回一个完整的对象。
  • 如果将抽象工厂模式看成汽车配件生产工厂，生产一个产品族的产品，那么建造者模式就是一个汽车组装工厂，通过对部件的组装可以返回一辆完整的汽车!

public abstract class Builder {abstract void builderA();//地基abstract void builderB();//钢筋水泥abstract void builderC();//铺电线abstract void builderD();//粉刷//完工:得到产品abstract Product getproduct();
}//产品：房子
public class Product {private String builderA;private String builderB;private String builderC;private String builderD;//get set tostring
}//具体建造者：工人
public class Worker extends Builder{private Product product;public Worker() {product = new Product();}@Overridevoid builderA() {product.setBuilderA("地基");System.out.println("地基");}@Overridevoid builderB() {product.setBuilderB("钢筋水泥");System.out.println("钢筋水泥");}@Overridevoid builderC() {product.setBuilderC("铺电线");System.out.println("铺电线");}@Overridevoid builderD() {product.setBuilderD("粉刷");System.out.println("粉刷");}@OverrideProduct getproduct() {return product;}
}//指挥：核心。负责构建一个工程，工程如何构建，由他决定。
public class Director {//指挥工人按照顺序建房子public Product build(Builder builder){builder.builderA();builder.builderB();builder.builderD();builder.builderC();return builder.getproduct();}
}public class Test {public static void main(String[] args) {Director director = new Director();Product build = director.build(new Worker());System.out.println(build);}
}