设计模式

1、简述

GoF23种设计模式。

2、基本要素

模式名称、问题、解决方案、效果

3、23种设计模式

image.png
创建型模式：让创建和使用分离
结构型模式：让类和对象组成更大的结构
行为型模式：让类和对象相互协作完成单个对象无法完成的任务

4、OOP七大原则

开闭原则
里氏替代原则：子类可以扩展方法但父类方法尽量不要改动
依赖倒置原则：面向接口编程
单一职责原则：粒度，一个方法尽可能处理一件事情，说的是具体实现
接口隔离原则：和单一职责原则差不多，说的是接口
迪米特法则：和朋友直接交谈、不跟陌生人交谈
合成复用原则：尽量使用has-a，避免使用is-a

5、工厂设计模式

作用：
分类：
简单工厂模式：也叫静态工厂模式，以工厂类代替new。缺点：违背开闭原则
工厂方法模式：
抽象工厂模式：

传统方式

image.png

  1. package model.factory.tradition;
  3. public interface Car {
  4.     void name();
  5. }
  1. package model.factory.tradition;
  3. public class WuLing implements Car {
  4.     @Override
  5.     public void name() {
  6.         System.out.println("五菱宏光");
  7.     }
  8. }
  1. package model.factory.tradition;
  3. public class Tesla implements Car {
  4.     @Override
  5.     public void name() {
  6.         System.out.println("Tesla");
  7.     }
  8. }
  1. package model.factory.tradition;
  3. //传统情况
  4. public class Consumer {
  5.     public static void main(String[] args) {
  6.         Car car1 = new WuLing();//五菱宏光
  7.         Car car2 = new Tesla();//Tesla
  9.         car1.name();
  10.         car2.name();
  11.     }
  12. }

image.png

缺点

调用者与实现者高度耦合，需要new

简单工厂模式

image.png

  1. package model.factory.simple;
  3. public interface Car {
  4.     void name();
  5. }
  1. package model.factory.simple;
  3. public class WuLing implements Car {
  4.     @Override
  5.     public void name() {
  6.         System.out.println("五菱宏光");
  7.     }
  8. }
  1. package model.factory.simple;
  3. public class Tesla implements Car {
  4.     @Override
  5.     public void name() {
  6.         System.out.println("Tesla");
  7.     }
  8. }
  1. package model.factory.simple;
  3. public class CarFactory {
  4.     public static Car getCar(String car){
  5.         if ("五菱宏光".equals(car)){
  6.             return new WuLing();
  7.         }else if ("Tesla".equals(car)){
  8.             return new Tesla();
  9.         }else {
  10.             return null;
  11.         }
  12.     }
  13. }
  1. package model.factory.simple;
  3. public class Consumer {
  4.     public static void main(String[] args) {
  5.         Car car1 = CarFactory.getCar("五菱宏光");
  6.         Car car2 = CarFactory.getCar("Tesla");
  8.         car1.name();//五菱宏光
  9.         car2.name();//Tesla
  10.     }
  11. }

image.png

优点

代码简单，实现容易

缺点

不满足开闭原则

工厂方法模式

image.png

  1. package model.factory.method;
  3. public interface Car {
  4.     void name();
  5. }
  1. package model.factory.method;
  3. public class WuLing implements Car {
  4.     @Override
  5.     public void name() {
  6.         System.out.println("五菱宏光");
  7.     }
  8. }
  1. package model.factory.method;
  3. public class Tesla implements Car {
  4.     @Override
  5.     public void name() {
  6.         System.out.println("Tesla");
  7.     }
  8. }
  1. package model.factory.method;
  3. public interface CarFactory {
  4.     public Car getCar();
  5. }
  1. package model.factory.method;
  3. public class WuLingFactory implements CarFactory {
  4.     @Override
  5.     public Car getCar() {
  6.         return new WuLing();
  7.     }
  8. }
  1. package model.factory.method;
  3. public class TeslaFactory implements CarFactory {
  4.     @Override
  5.     public Car getCar() {
  6.         return new Tesla();
  7.     }
  8. }
  1. package model.factory.method;
  3. public class Consumer {
  4.     public static void main(String[] args) {
  5.         Car car1 = new WuLingFactory().getCar();
  6.         Car car2 = new TeslaFactory().getCar();
  8.         car1.name();//五菱宏光
  9.         car2.name();//Tesla
  10.     }
  11. }

优点

扩展性好，即使后面来了大众、宝马等车，也满足代码的开闭原则

缺点

写的类有点多
image.png

抽象工厂模式

image.png

  1. package model.factory.abstract0;
  3. public interface PhoneProduct {
  4.     public void callUp();
  5.     public void sendMsg();
  6. }
  1. package model.factory.abstract0;
  3. public class XiaomiProduct implements PhoneProduct {
  4.     @Override
  5.     public void callUp() {
  6.         System.out.println("小米手机打电话");
  7.     }
  9.     @Override
  10.     public void sendMsg() {
  11.         System.out.println("小米手机发消息");
  12.     }
  13. }
  1. package model.factory.abstract0;
  3. public class HuaweiProduct implements PhoneProduct {
  4.     @Override
  5.     public void callUp() {
  6.         System.out.println("华为手机打电话");
  7.     }
  9.     @Override
  10.     public void sendMsg() {
  11.         System.out.println("华为手机发消息");
  12.     }
  13. }
  1. package model.factory.abstract0;
  3. public interface PhoneRounter {
  4.     void openWifi();
  5.     void closeWifi();
  6. }
  1. package model.factory.abstract0;
  3. public class XiaomiRounter implements PhoneRounter {
  4.     @Override
  5.     public void openWifi() {
  6.         System.out.println("打开小米路由器");
  7.     }
  9.     @Override
  10.     public void closeWifi() {
  11.         System.out.println("关闭小米路由器");
  12.     }
  13. }
  1. package model.factory.abstract0;
  3. public class HuaweiRounter implements PhoneRounter {
  4.     @Override
  5.     public void openWifi() {
  6.         System.out.println("打开华为路由器");
  7.     }
  9.     @Override
  10.     public void closeWifi() {
  11.         System.out.println("关闭华为路由器");
  12.     }
  13. }
  1. package model.factory.abstract0;
  3. public interface PhoneFactory {
  4.     PhoneProduct phoneProduct();
  5.     PhoneRounter phoneRouter();
  6. }
  1. package model.factory.abstract0;
  3. public class XiaomiFactory implements PhoneFactory {
  4.     @Override
  5.     public PhoneProduct phoneProduct() {
  6.         return new XiaomiProduct();
  7.     }
  9.     @Override
  10.     public PhoneRounter phoneRouter() {
  11.         return new XiaomiRounter();
  12.     }
  13. }
  1. package model.factory.abstract0;
  3. public class HuaweiFactory implements PhoneFactory {
  4.     @Override
  5.     public PhoneProduct phoneProduct() {
  6.         return new HuaweiProduct();
  7.     }
  9.     @Override
  10.     public PhoneRounter phoneRouter() {
  11.         return new HuaweiRounter();
  12.     }
  13. }
  1. package model.factory.abstract0;
  3. public class Consumer {
  4.     public static void main(String[] args) {
  5.         PhoneProduct xiaomiPhone = new XiaomiFactory().phoneProduct();
  6.         xiaomiPhone.callUp();//小米手机打电话
  7.         xiaomiPhone.sendMsg();//小米手机发消息
  9.         PhoneRounter huaweiRouter = new HuaweiFactory().phoneRouter();
  10.         huaweiRouter.openWifi();//打开华为路由器
  11.         huaweiRouter.closeWifi();//关闭华为路由器
  12.     }
  13. }

image.png

优点

具体产品在应用层的代码隔离，无需关心创建的细节；
将一个系列的产品统一到一起创建

缺点

扩展性差；
增加了系统的抽象性和理解难度

6、建造者模式

image.png

  1. package model.factory.builder;
  3. //抽象建造者
  4. //建造一个产品需要经历几个步骤
  5. public abstract class Builder {
  6.     abstract void builderA();//地基
  7.     abstract void builderB();//钢筋工程
  8.     abstract void builderC();//铺电缆
  9.     abstract void builderD();//粉刷
  11.     //完工：得到产品
  12.     abstract Product getProduct();
  13. }
  1. package model.factory.builder;
  3. public class Product {
  4.     private String BuildA;
  5.     private String BuildB;
  6.     private String BuildC;
  7.     private String BuildD;
  9.     @Override
  10.     public String toString() {
  11.         return "Produt{" +
  12.                 "BuildA='" + BuildA + '\'' +
  13.                 ", BuildB='" + BuildB + '\'' +
  14.                 ", BuildC='" + BuildC + '\'' +
  15.                 ", BuildD='" + BuildD + '\'' +
  16.                 '}';
  17.     }
  19.     public String getBuildA() {
  20.         return BuildA;
  21.     }
  23.     public void setBuildA(String buildA) {
  24.         BuildA = buildA;
  25.     }
  27.     public String getBuildB() {
  28.         return BuildB;
  29.     }
  31.     public void setBuildB(String buildB) {
  32.         BuildB = buildB;
  33.     }
  35.     public String getBuildC() {
  36.         return BuildC;
  37.     }
  39.     public void setBuildC(String buildC) {
  40.         BuildC = buildC;
  41.     }
  43.     public String getBuildD() {
  44.         return BuildD;
  45.     }
  47.     public void setBuildD(String buildD) {
  48.         BuildD = buildD;
  49.     }
  50. }
  1. package model.factory.builder;
  3. //工人就完成这些步骤和返回结果
  4. public class Worker extends Builder {
  5.     private Product product;
  7.     public Worker() {
  8.         product = new Product();
  9.     }
  11.     @Override
  12.     void builderA() {
  13.         product.setBuildA("地基");
  14.         System.out.println("地基");
  15.     }
  17.     @Override
  18.     void builderB() {
  19.         product.setBuildB("钢筋工程");
  20.         System.out.println("钢筋工程");
  21.     }
  23.     @Override
  24.     void builderC() {
  25.         product.setBuildC("铺电缆");
  26.         System.out.println("铺电缆");
  27.     }
  29.     @Override
  30.     void builderD() {
  31.         product.setBuildD("粉刷");
  32.         System.out.println("粉刷");
  33.     }
  35.     @Override
  36.     Product getProduct() {
  37.         return product;
  38.     }
  39. }
  1. package model.factory.builder;
  3. //指挥是核心，负责指挥构建一个工程，工程如何构建，由它决定
  4. public class Director {
  5.     public Product build(Builder builder){
  7.         //指挥工人按顺序建房子
  8.         builder.builderA();
  9.         builder.builderC();
  10.         builder.builderD();
  11.         builder.builderB();
  13.         return builder.getProduct();
  14.     }
  15. }
  1. package model.factory.builder;
  3. public class Test {
  4.     public static void main(String[] args) {
  5.         //指挥
  6.         Director director = new Director();
  7.         //指挥具体的工人完成产品
  8.         //输出：Produt{BuildA='地基', BuildB='钢筋工程', BuildC='铺电缆', BuildD='粉刷'}
  9.         Product build = director.build(new Worker());
  10.         System.out.println(build);
  11.     }
  12. }

image.png

优点

可以切换类的构建顺序，灵活

缺点

客户就是Director，没有使用静态内部类的方式，显得僵硬了点

7、原型模式

浅拷贝

image.png

  1. package model.factory.prototype.demo1;
  3. import java.util.Date;
  5. public class Video implements Cloneable {
  6.     private String name;
  7.     private Date createTime;
  9.     @Override
  10.     public String toString() {
  11.         return "Video{" +
  12.                 "name='" + name + '\'' +
  13.                 ", createTime=" + createTime +
  14.                 '}';
  15.     }
  17.     @Override
  18.     protected Object clone() throws CloneNotSupportedException {
  19.         return super.clone();
  20.     }
  22.     public String getName() {
  23.         return name;
  24.     }
  26.     public void setName(String name) {
  27.         this.name = name;
  28.     }
  30.     public Date getCreateTime() {
  31.         return createTime;
  32.     }
  34.     public void setCreateTime(Date createTime) {
  35.         this.createTime = createTime;
  36.     }
  38.     public Video(String name, Date createTime) {
  39.         this.name = name;
  40.         this.createTime = createTime;
  41.     }
  43.     public Video() {
  44.     }
  45. }
  1. package model.factory.prototype.demo1;
  3. import java.util.Date;
  5. public class Test01 {
  6.     public static void main(String[] args) throws CloneNotSupportedException {
  7.         Date date = new Date();
  8.         Video v1 = new Video("up主", date);
  9.         Video v2 = (Video) v1.clone();
  10.         System.out.println(v1);
  11.         System.out.println(v1.hashCode());
  12.         System.out.println("========================");
  13.         System.out.println(v2);
  14.         System.out.println(v2.hashCode());
  15.     }
  16. }

深拷贝

image.png

  1. package model.factory.prototype.demo2;
  3. import java.util.Date;
  5. public class Video implements Cloneable {
  6.     private String name;
  7.     private Date createTime;
  9.     @Override
  10.     public String toString() {
  11.         return "Video{" +
  12.                 "name='" + name + '\'' +
  13.                 ", createTime=" + createTime +
  14.                 '}';
  15.     }
  17.     @Override
  18.     protected Object clone() throws CloneNotSupportedException {
  19.         Object obj = super.clone();
  20.         Video v = (Video) obj;
  21.         v.createTime = (Date) this.createTime.clone();
  22.         return obj;
  23.     }
  25.     public String getName() {
  26.         return name;
  27.     }
  29.     public void setName(String name) {
  30.         this.name = name;
  31.     }
  33.     public Date getCreateTime() {
  34.         return createTime;
  35.     }
  37.     public void setCreateTime(Date createTime) {
  38.         this.createTime = createTime;
  39.     }
  41.     public Video(String name, Date createTime) {
  42.         this.name = name;
  43.         this.createTime = createTime;
  44.     }
  46.     public Video() {
  47.     }
  48. }
  1. package model.factory.prototype.demo2;
  3. import java.util.Date;
  5. public class Test02 {
  6.     public static void main(String[] args) throws CloneNotSupportedException {
  7.         Date date = new Date();
  8.         Video v1 = new Video("up主", date);
  9.         Video v2 = (Video) v1.clone();
  10.         System.out.println(v1);
  11.         System.out.println(v2);
  12.         System.out.println("========================");
  13.         date.setTime(21123281);
  14.         System.out.println(v1);
  15.         System.out.println(v2);
  16.     }
  17. }

8、适配器模式

继承方式

image.png

  1. package model.adapter;
  3. //网线，用来上网
  4. public class Adaptee {
  5.     public void request(){
  6.         System.out.println("网线可以用来上网");
  7.     }
  8. }
  1. package model.adapter;
  3. //适配器接口，可以造很多种适配器
  4. public interface NetToUsb {
  5.     public void handleRequest();
  6. }
  1. package model.adapter;
  3. public class Adapt extends Adaptee implements NetToUsb {
  4.     @Override
  5.     public void handleRequest() {
  6.         super.request();
  7.     }
  8. }
  1. package model.adapter;
  3. public class Computer {
  4.     public void net(NetToUsb adapt){
  5.         //上网的具体实现
  6.         adapt.handleRequest();
  7.     }
  9.     public static void main(String[] args) {
  10.         Computer computer = new Computer();
  11.         Adapt adapt = new Adapt();
  12.         Adaptee adaptee = new Adaptee();
  13.         computer.net(adapt);
  14.     }
  15. }

image.png

组合方式

image.png

  1. package model.adapter;
  3. //网线，用来上网
  4. public class Adaptee {
  5.     public void request(){
  6.         System.out.println("网线可以用来上网");
  7.     }
  8. }
  1. package model.adapter;
  3. //适配器接口，可以造很多种适配器
  4. public interface NetToUsb {
  5.     public void handleRequest();
  6. }
  1. package model.adapter;
  3. //继承和组合。继承是单继承，也称类适配器；常用的是组合，如下：
  4. public class Adapt2 implements NetToUsb{
  5.     private Adaptee adaptee;
  7.     public Adapt2(Adaptee adaptee) {
  8.         this.adaptee = adaptee;
  9.     }
  11.     @Override
  12.     public void handleRequest() {
  13.         adaptee.request();
  14.     }
  15. }
  1. package model.adapter;
  3. public class Computer {
  4.     public void net(NetToUsb adapt){
  5.         //上网的具体实现
  6.         adapt.handleRequest();
  7.     }
  9.     public static void main(String[] args) {
  10.         Computer computer = new Computer();
  11.         Adaptee adaptee = new Adaptee();
  12.         Adapt2 adapt2 = new Adapt2(adaptee);
  13.         computer.net(adapt2);
  14.     }
  15. }

image.png

9、桥接模式

image.png
image.png
image.png

  1. package model.bridge;
  3. //品牌用接口
  4. public interface Brand {
  5.     void info();
  6. }
  1. package model.bridge;
  3. //联想品牌
  4. public class Lenovo implements Brand {
  5.     @Override
  6.     public void info() {
  7.         System.out.print("联想");
  8.     }
  9. }
  1. package model.bridge;
  3. //苹果品牌
  4. public class Apple implements Brand {
  5.     @Override
  6.     public void info() {
  7.         System.out.print("苹果");
  8.     }
  9. }
  1. package model.bridge;
  3. //抽象的电脑类型
  4. public abstract class Computer {
  5.     //组合、品牌
  6.     protected Brand brand;
  8.     public Computer(Brand brand) {
  9.         this.brand = brand;
  10.     }
  12.     public void info(){
  13.         brand.info();//自带品牌
  14.     }
  15. }
  17. class Desktop extends Computer{
  19.     public Desktop(Brand brand) {
  20.         super(brand);
  21.     }
  23.     @Override
  24.     public void info() {
  25.         super.info();
  26.         System.out.print("台式机");
  27.     }
  28. }
  30. class Laptop extends Computer{
  32.     public Laptop(Brand brand) {
  33.         super(brand);
  34.     }
  36.     @Override
  37.     public void info() {
  38.         super.info();
  39.         System.out.print("笔记本");
  40.     }
  41. }
  1. package model.bridge;
  3. public class Test {
  4.     public static void main(String[] args) {
  5.         //苹果笔记本
  6.         Computer computer1 = new Laptop(new Apple());
  7.         computer1.info();
  8.         System.out.println();
  9.         //联想台式机
  10.         Computer computer2 = new Desktop(new Lenovo());
  11.         computer2.info();
  12.     }
  13. }

特点
避免使用继承而多使用组合。