一、设计模式的分类
1、创建型模式
单例模式、工厂模式、抽象工厂、建造者模式、原型模式
2、结构型模式
适配器模式、桥接模式、装饰者模式、组合模式、外观模式、亨元模式/蝇量模式、代理模式
3、行为型模式
模板方法模式、命令模式、迭代器模式、状态模式、观察者模式、中介者模式、备忘录模式、解释器模式、策略模式、责任链模式、访问者模式
二、OOP七大原则
开闭原则：对扩展开放，对修改关闭
里氏替换原则：继承必须确保超类所拥有的性质在子类中仍然成立
依赖倒置原则：要面向接口编程，不要面向实现编程。
单一职责原则：控制类的粒度大小、将对象解耦、提高其内聚性
接口隔离原则：要为各个类建立它们需要的专用接口
迪米特法则：只与你的直接朋友交谈，不跟陌生人说话
合成复用原则：尽量先使用组合或者聚合等关联关系来实现，其次才考虑使用继承关系来实现
三、单例模式
单例模式的好处就是JVM堆内存中只存在一个我们想要使用的对象，减少了频繁创建、使用、销毁对象所带来的开销，这里给出了两种：
DCL
public class SingletonInstance {
private volatile static SingletonInstance instance = null;
private SingletonInstance(){}
public static SingletonInstance getInstance(){
if (null == instance){
synchronized (SingletonInstance.class){
if (null == instance){
instance = new SingletonInstance();
}
}
}
return instance;
}
}
instance = new SingletonInstance()创建对象分为三步
memory = allocate(); //1:分配对象的内存空间
ctorInstance(memory); //2:初始化对象
instance = memory;// 3:设置instance指向刚分配的内存地址
而第二步和第三步存在指令重排的可能，因此在多线程执行的时候，可能存在A线程还未初始化对象完成，B线程就拿到了这个对象的内存地址，这时只是一个null对象，产生问题。采用volatile关键字可以禁止指令重排，起到顺序执行的效果，保证拿到对象的内存地址的时候，对象一定是初始化完成的。
内部类
public class SingletonInstance2 {
private SingletonInstance2(){}
private static class SingletonInstance2Hold{
private static final SingletonInstance2 instance = new SingletonInstance2();
}
public SingletonInstance2 getInstance(){
return SingletonInstance2Hold.instance;
}
}
采用内部类的方式，是通过JVM类加载的机制实现，第一次JVM不会加载内部类，因此不会创建对象占用内存。当我们调用getInstance的时候，会触发加载内部类并初始化，但是JVM只会让其中的一个线程执行类加载初始化，从而保证了只存在一个对象，并且实现了懒加载的效果。
四、工厂模式
先说一下简单工厂
结构如下：
抽象产品 ：定义了产品的规范，描述了产品的主要特性和功能。
具体产品 ：实现或者继承抽象产品的子类
具体工厂 ：提供了创建产品的方法，调用者通过该方法来获取产品。
public abstract class Coffee {
public abstract String getName();
//加糖
public void addsugar() {
System.out.println("加糖");
}
//加奶
public void addMilk() {
System.out.println("加奶");
}
}
public class LatteCoffee extends Coffee {
public String getName() {
return "拿铁咖啡";
}
}
public class AmericanCoffee extends Coffee {
public String getName() {
return "美式咖啡";
}
}
public class SimpleCoffeeFactory {
public static Coffee createCoffee(String type) {
//声明Coffee类型的变量，根据不同类型创建不同的coffee子类对象
Coffee coffee = null;
if("american".equals(type)) {
coffee = new AmericanCoffee();
} else if("latte".equals(type)) {
coffee = new LatteCoffee();
} else {
throw new RuntimeException("对不起，您所点的咖啡没有");
}
return coffee;
}
}
public class CoffeeStore {
public Coffee orderCoffee(String type) {
//调用生产咖啡的方法
Coffee coffee = SimpleCoffeeFactory.createCoffee(type);
//加配料
coffee.addMilk();
coffee.addsugar();
return coffee;
}
}
public class Client {
public static void main(String[] args) {
//创建咖啡店类对象
CoffeeStore store = new CoffeeStore();
Coffee coffee = store.orderCoffee("latte");
System.out.println(coffee.getName());
}
}
有一个coffee店，它有两种coffee，后续可能还会有更多的coffee，然后客户点单获取coffee。这里用到的简单工厂，通过传值的方式来判断实例化哪个coffee。
工厂模式还可以通过配置文件的方式优化
创建配置文件
american=com.ren.design.abstract_factory.AmericanCoffee
latte=com.ren.design.abstract_factory.LatteCoffee
修改工厂类
public class CoffeeFactory {
//加载配置文件，获取配置文件中配置的全类名，并创建该类的对象进行存储
//1,定义容器对象存储咖啡对象
private static HashMap<String,Coffee> map = new HashMap<String, Coffee>();
//2,加载配置文件， 只需要加载一次
static {
//2.1 创建Properties对象
Properties p = new Properties();
//2.2 调用p对象中的load方法进行配置文件的加载
InputStream is = CoffeeFactory.class.getClassLoader().getResourceAsStream("bean.properties");
try {
p.load(is);
//从p集合中获取全类名并创建对象
Set<Object> keys = p.keySet();
for (Object key : keys) {
String className = p.getProperty((String) key);
//通过反射技术创建对象
Class clazz = Class.forName(className);
Coffee coffee = (Coffee) clazz.newInstance();
//将名称和对象存储到容器中
map.put((String)key,coffee);
}
} catch (Exception e) {
e.printStackTrace();
}
}
//根据名称获取对象
public static Coffee createCoffee(String name) {
return map.get(name);
}
}
public class Client {
public static void main(String[] args) {
Coffee coffee = CoffeeFactory.createCoffee("american");
System.out.println(coffee.getName());
System.out.println("=============");
Coffee latte = CoffeeFactory.createCoffee("latte");
System.out.println(latte.getName());
}
}
其实简单工厂只是编码的一种方式，还不能算是工厂方法设计模式，接下来说一下工厂方法设计模式。
模式定义：定义一个用于创建对象的接口，让子类决定实例化哪一个类，使得一个类的实例化延迟到子类。
结构如下：
抽象工厂(Abstract Factory)：提供了创建产品的接口，它包含多个创建产品的方法，可以创建多个不同等级的产品。
具体工厂(Concrete Factory)：主要是实现抽象工厂中的多个抽象方法，完成具体产品的创建。
抽象产品(Product)：定义了产品的规范，描述了产品的主要特性和功能，抽象工厂模式有多个抽象产品。
具体产品(ConcreteProduct)：实现了抽象产品角色所定义的接口，由具体工厂来创建，它同具体工厂之间是多对一的关系。
public interface CoffeeFactory {
//创建咖啡对象的方法
Coffee createCoffee();
}
public class AmericanCoffeeFactory implements CoffeeFactory {
public Coffee createCoffee() {
return new AmericanCoffee();
}
}
public class LatteCoffeeFactory implements CoffeeFactory {
public Coffee createCoffee() {
return new LatteCoffee();
}
}
public class CoffeeStore {
private CoffeeFactory factory;
public void setFactory(CoffeeFactory factory) {
this.factory = factory;
}
//点咖啡功能
public Coffee orderCoffee() {
Coffee coffee = factory.createCoffee();
//加配料
coffee.addMilk();
coffee.addsugar();
return coffee;
}
}
public class Client {
public static void main(String[] args) {
//创建咖啡店对象
CoffeeStore store = new CoffeeStore();
//创建对象
//CoffeeFactory factory = new AmericanCoffeeFactory();
CoffeeFactory factory = new LatteCoffeeFactory();
store.setFactory(factory);
//点咖啡
Coffee coffee = store.orderCoffee();
System.out.println(coffee.getName());
}
}
定义了一个工厂接口，让创建实例交给了子类去实现，让子类决定实例化哪个coffee，这样在我们扩展产品的时候才不会修改之前的代码，只需要创建新的子类去实现就可以了。
应用场景：
1、当你不知道使用对象确切类型的时候
2、当你希望为库或框架提供扩展内部组件的方法的时候
优点：
1、将具体产品和创建者解耦
2、符合单一职责原则
3、符合开闭原则
缺点：
会产生类爆炸问题，每增加一个产品都需要增加一个对应的工厂类
工厂方法模式的应用
Collection.iterator
public class Demo {
public static void main(String[] args) {
List<String> list = new ArrayList<>();
list.add("令狐冲");
list.add("风清扬");
list.add("任我行");
//获取迭代器对象
Iterator<String> it = list.iterator();
//使用迭代器遍历
while(it.hasNext()) {
String ele = it.next();
System.out.println(ele);
}
}
}
Collection接口是抽象工厂类，ArrayList是具体的工厂类；Iterator接口是抽象商品类，ArrayList类中的Iter内部类是具体的商品类，在具体的工厂类中iterator()方法创建具体的商品类的对象。
除此之外：DateForamt类中的getInstance()方法使用的是工厂模式，Calendar类中的getInstance()方法也使用的是工厂模式。
五、抽象工厂模式
上面说的工厂方法只能生产同类型的产品，无法生产多级别类型的产品，比如：一家咖啡店既可以生产咖啡，还可以生产甜点，那么就需要抽象工厂的模式来解决。结构如下：
抽象工厂(Abstract Factory)：提供了创建产品的接口，它包含多个创建产品的方法，可以创建多个不同等级的产品。
具体工厂(Concrete Factory)：主要是实现抽象工厂中的多个抽象方法，完成具体产品的创建。
抽象产品(Product)：定义了产品的规范，描述了产品的主要特性和功能，抽象工厂模式有多个抽象产品。
具体产品(ConcreteProduct)：实现了抽象产品角色所定义的接口，由具体工厂来创建，它同具体工厂之间是多对一的关系。
例如：咖啡店的业务要生产咖啡和甜点，如提拉米苏、抹茶慕斯等，要是按照工厂方法模式，需要定义提拉米苏类、抹茶慕斯类、提拉米苏工厂、抹茶慕斯工厂、甜点工厂类，很容易发生类爆炸情况。
我们可以把他们的共同点抽象归类一下：
其中拿铁咖啡、美式咖啡是一个产品等级，都是咖啡；提拉米苏、抹茶慕斯也是一个产品等级，都是甜点；
拿铁咖啡和提拉米苏是同一产品族，也就是都属于意大利风味；美式咖啡和抹茶慕斯是同一产品族，也就是都属于美式风味。
所以这个案例可以使用抽象工厂模式实现。类图如下：
定义抽象类coffee，并且由两个子类
public abstract class Coffee {
public abstract String getName();
//加糖
public void addsugar() {
System.out.println("加糖");
}
//加奶
public void addMilk() {
System.out.println("加奶");
}
}
public class AmericanCoffee extends Coffee {
@Override
public String getName() {
return "美式咖啡";
}
}
public class LatteCoffee extends Coffee {
@Override
public String getName() {
return "拿铁咖啡";
}
}
定义甜点Dessert，也有两个子类
public abstract class Dessert {
public abstract void show();
}
public class MatchaMousse extends Dessert {
public void show() {
System.out.println("抹茶慕斯");
}
}
public class Trimisu extends Dessert {
public void show() {
System.out.println("提拉米苏");
}
}
定义顶级工厂，可以生产coffee和dessert，并有两种工厂实现
public interface DessertFactory {
Coffee createCoffee();
Dessert createDessert();
}
public class AmericanDessertFactory implements DessertFactory{
@Override
public Coffee createCoffee() {
return new AmericanCoffee();
}
@Override
public Dessert createDessert() {
return new MatchaMousse();
}
}
public class ItalyDessertFactory implements DessertFactory {
public Coffee createCoffee() {
return new LatteCoffee();
}
public Dessert createDessert() {
return new Trimisu();
}
}
定义coffee店
public class CoffeeStore {
private DessertFactory factory;
public void setFactory(DessertFactory factory) {
this.factory = factory;
}
//点咖啡功能
public Coffee orderCoffee() {
Coffee coffee = factory.createCoffee();
//加配料
coffee.addMilk();
coffee.addsugar();
return coffee;
}
//点甜点功能
public Dessert orderDessert(){
Dessert dessert = factory.createDessert();
return dessert;
}
}
测试
public class Client {
public static void main(String[] args) {
//创建咖啡店对象
CoffeeStore store = new CoffeeStore();
//创建对象
DessertFactory factory = new ItalyDessertFactory();
store.setFactory(factory);
//点咖啡
Coffee coffee = store.orderCoffee();
//点甜点
Dessert dessert = store.orderDessert();
System.out.println(coffee.getName());
dessert.show();
}
}
通过测试类可以发现，我们通过具体的实现类工厂来确定到底生产哪一种coffee和dessert。
优点：
当一个产品族中的多个对象被设计成一起工作时，它能保证客户端始终只使用同一个产品族中的对象。
缺点：
当产品族中需要增加一个新的产品时，所有的工厂类都需要进行修改。
使用场景：
当需要创建的对象是一系列相互关联或相互依赖的产品族时，如电器工厂中的电视机、洗衣机、空调等。
系统中有多个产品族，但每次只使用其中的某一族产品。如有人只喜欢穿某一个品牌的衣服和鞋。
系统中提供了产品的类库，且所有产品的接口相同，客户端不依赖产品实例的创建细节和内部结构。
如：输入法换皮肤，一整套一起换。生成不同操作系统的程序。
六、原型模式
定义：用一个已经创建的实例作为原型，通过复制该原型对象来创建一个和原型对象相同的新对象。
结构如下：
抽象原型类：规定了具体原型对象必须实现的的 clone() 方法。
具体原型类：实现抽象原型类的 clone() 方法，它是可被复制的对象。
访问类：使用具体原型类中的 clone() 方法来复制新的对象。
原型模式的克隆分为浅克隆和深克隆。
浅克隆：创建一个新对象，新对象的属性和原来对象完全相同，对于非基本类型属性，仍指向原有属性所指向的对象的内存地址。
深克隆：创建一个新对象，属性中引用的其他对象也会被克隆，不再指向原有对象地址。
Java中的Object类中提供了 clone() 方法来实现浅克隆。 Cloneable接口是上面的类图中的抽象原型类，而实现了Cloneable接口的子实现类就是具体的原型类，所以我们也不需要自定义接口类了。
具体的原型类
public class Realizetype implements Cloneable {
private User user;
public Realizetype() {
System.out.println("具体的原型对象创建完成！");
}
@Override
public Realizetype clone() throws CloneNotSupportedException {
System.out.println("具体原型复制成功！");
return (Realizetype) super.clone();
}
public User getUser() {
return user;
}
public void setUser(User user) {
this.user = user;
}
}
测试类：
public class client {
public static void main(String[] args) throws CloneNotSupportedException {
//创建一个原型类对象
Realizetype realizetype = new Realizetype();
User user = new User();
realizetype.setUser(user);
//调用Realizetype类中的clone方法进行对象的克隆
Realizetype clone = realizetype.clone();
System.out.println("原型对象和克隆出来的是否是同一个对象？" + (realizetype == clone));
System.out.println("0:"+user);
System.out.println("1:"+realizetype.getUser());
System.out.println("2:"+clone.getUser());
}
}
结果：
具体的原型对象创建完成！
具体原型复制成功！
原型对象和克隆出来的是否是同一个对象？false
0:com.ren.design.prototype.demo.User@378bf509
1:com.ren.design.prototype.demo.User@378bf509
2:com.ren.design.prototype.demo.User@378bf509
1、clone出来的对象并不是通过构造器创建的
2、clone出来的对象跟原对象不是同一个
3、clone出来的对象的属性跟原对象的属性是同一个
如果想要进行深克隆，需要用到对象流，这里不再赘述。
七、建造者模式
定义：将一个复杂对象的构建与表示分离，使得同样的构建过程可以创建不同的表示。
解释：
1、分离了部件的构造(由Builder来负责)和装配(由Director负责)。 从而可以构造出复杂的对象。这个模式适用于：某个对象的构建过程复杂的情况。
2、由于实现了构建和装配的解耦。不同的构建器，相同的装配，也可以做出不同的对象；相同的构建器，不同的装配顺序也可以做出不同的对象。也就是实现了构建算法、装配算法的解耦，实现了更好的复用。
3、建造者模式可以将部件和其组装过程分开，一步一步创建一个复杂的对象。用户只需要指定复杂对象的类型就可以得到该对象，而无须知道其内部的具体构造细节。
机构如下：
抽象建造者类（Builder）：这个接口规定要实现复杂对象的那些部分的创建，并不涉及具体的部件对象的创建。
具体建造者类（ConcreteBuilder）：实现 Builder 接口，完成复杂产品的各个部件的具体创建方法。在构造过程完成后，提供产品的实例。
产品类（Product）：要创建的复杂对象。
指挥者类（Director）：调用具体建造者来创建复杂对象的各个部分，在指导者中不涉及具体产品的信息，只负责保证对象各部分完整创建或按某种顺序创建。
复杂对象
public class Bike {
private String frame;//车架
private String 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 {
//声明Bike类型的变量，并进行赋值
protected Bike bike = new Bike();
public abstract void buildFrame();
public abstract void buildSeat();
//构建自行车的方法
public abstract Bike createBike();
}
具体建造者
public class MobileBuilder extends Builder {
public void buildFrame() {
bike.setFrame("碳纤维车架");
}
public void buildSeat() {
bike.setSeat("真皮车座");
}
public Bike createBike() {
return bike;
}
}
public class OfoBuilder extends Builder {
public void buildFrame() {
bike.setFrame("铝合金车架");
}
public void buildSeat() {
bike.setSeat("橡胶车座");
}
public Bike createBike() {
return bike;
}
}
指挥者
public class Director {
//声明builder类型的变量
private Builder builder;
public Director(Builder builder) {
this.builder = builder;
}
//组装自行车的功能
public Bike build() {
builder.buildFrame();
builder.buildSeat();
return builder.createBike();
}
}
测试类
public class Client {
public static void main(String[] args) {
//创建指挥者对象
Director director = new Director(new MobileBuilder());
//让指挥者只会组装自行车
Bike bike = director.build();
System.out.println(bike.getFrame());
System.out.println(bike.getSeat());
}
}
有时候为了简化操作，会把指挥者融合到建造者里去
public abstract class Builder {
//声明Bike类型的变量，并进行赋值
protected Bike bike = new Bike();
public abstract void buildFrame();
public abstract void buildSeat();
//构建自行车的方法
public abstract Bike createBike();
public Bike build() {
this.buildFrame();
this.buildSeat();
return this.createBike();
}
}
public class Client2 {
public static void main(String[] args) {
Bike bike = new OfoBuilder()
.build();
System.out.println(bike.getFrame());
System.out.println(bike.getSeat());
}
}
不过这样的化不符合单一职责的原则
优点：
建造者模式的封装性很好。使用建造者模式可以有效的封装变化，在使用建造者模式的场景中，一般产品类和建造者类是比较稳定的，因此，将主要的业务逻辑封装在指挥者类中对整体而言可以取得比较好的稳定性。
在建造者模式中，客户端不必知道产品内部组成的细节，将产品本身与产品的创建过程解耦，使得相同的创建过程可以创建不同的产品对象。
可以更加精细地控制产品的创建过程 。将复杂产品的创建步骤分解在不同的方法中，使得创建过程更加清晰，也更方便使用程序来控制创建过程。
建造者模式很容易进行扩展。如果有新的需求，通过实现一个新的建造者类就可以完成，基本上不用修改之前已经测试通过的代码，因此也就不会对原有功能引入风险，符合开闭原则。
缺点：
造者模式所创建的产品一般具有较多的共同点，其组成部分相似，如果产品之间的差异性很大，则不适合使用建造者模式，因此其使用范围受到一定的限制。
使用场景
建造者（Builder）模式创建的是复杂对象，其产品的各个部分经常面临着剧烈的变化，但将它们组合在一起的算法却相对稳定，所以它通常在以下场合使用。
1、创建的对象较复杂，由多个部件构成，各部件面临着复杂的变化，但构件间的建造顺序是稳定的。
2、创建复杂对象的算法独立于该对象的组成部分以及它们的装配方式，即产品的构建过程和最终的表示是独立的。
模式扩展
建造者模式除了上面的用途外，在开发中还有一个常用的使用方式，就是当一个类构造器需要传入很多参数时，如果创建这个类的实例，代码可读性会非常差，而且很容易引入错误，此时就可以利用建造者模式进行重构。
优化前
public class Phone {
private String cpu;
private String screen;
private String memory;
private String mainboard;
public Phone(String cpu, String screen, String memory, String mainboard) {
this.cpu = cpu;
this.screen = screen;
this.memory = memory;
this.mainboard = mainboard;
}
···
}
public class Client {
public static void main(String[] args) {
//构建Phone对象
Phone phone = new Phone("intel","三星屏幕","金士顿","华硕");
System.out.println(phone);
}
}
优化后
public class Phone {
private String cpu;
private String screen;
private String memory;
private String mainboard;
private Phone(Builder builder) {
cpu = builder.cpu;
screen = builder.screen;
memory = builder.memory;
mainboard = builder.mainboard;
}
public static final class Builder {
private String cpu;
private String screen;
private String memory;
private String mainboard;
public Builder() {}
public Builder cpu(String val) {
cpu = val;
return this;
}
public Builder screen(String val) {
screen = val;
return this;
}
public Builder memory(String val) {
memory = val;
return this;
}
public Builder mainboard(String val) {
mainboard = val;
return this;
}
public Phone build() {
return new Phone(this);}
}
@Override
public String toString() {
return "Phone{" +
"cpu='" + cpu + '\'' +
", screen='" + screen + '\'' +
", memory='" + memory + '\'' +
", mainboard='" + mainboard + '\'' +
'}';
}
}
public class Client {
public static void main(String[] args) {
Phone phone = new Phone.Builder()
.cpu("intel")
.mainboard("华硕")
.memory("金士顿")
.screen("三星")
.build();
System.out.println(phone);
}
}
重构优化后，代码的可读性就提高了。
详细的教学请移步：https://www.bilibili.com/video/BV1Np4y1z7BU