Java常用设计模式 23种设计模式全面解析(超级详细)

一、设计模式概念

1、定义

​ Java包含23种设计模式，是一套对代码设计经验的总结，被人们反复利用，多人熟知的代码设计方式。

2、目的

​ 为了提高代码的可读性，可扩展性以及代码的复用性，为了解决在写代码过程中遇到的代码设计问题。

3、设计模式的六大原则

​3.1开闭原则

​ 对扩展开放，对修改关闭（尽可能对代码少修改）

​3.2里氏替换原则

​ 它是面向对象基本原则之一，任何父类（基类）出现的地方，子类都可以出现，也就是子类可以替换父类的任何功能（体现了父类的可扩展性）

3.3依赖倒转原则

​ 尽可能面向接口编程，依赖接口而不依赖类

3.4接口隔离原则

​ 一个类如果能实现多个接口，尽可能实现多个，为了降低依赖，降低耦合

3.5最少知道原则

​ 一个实体尽可能少的与其他实体产生相互关联关系，将实体的功能独立

3.6合成复用原则

​ 尽量使用合成，聚合的方式，而不使用继承

4、设计模式的分类

Java设计模式分为三大类

创建型模式：对象实例化的模式，创建型模式用于解耦对象的实例化过程。

结构型模式：把类或对象结合在一起形成一个更大的结构。

行为型模式：类和对象如何交互，及划分责任和算法。

如下图所示：

二、常用的几种设计模式

1、单例模式

单例模式是创建对象的一种特殊方式，程序从始至终都只创建一个对象叫单例（单实例）

分为两类

1.1、懒汉式单例

1.  
   public class Person{
2.  
   //为了不让其他类直接访问该成员 懒汉式单例，在使用时创建对象
3.  
   //1、私有静态变量
4.  
   private static Person person=null;
5.  
   //2、将构造器私有化
6.  
   private Person(){
7.  
    
8.  
   }
9.  
   //3、提供一个静态方法，并返回该类的对象
10.  
    public static Person getInstance(){
11.  
    if(person==null){
12.  
    //第一次访问
13.  
    person=new Person();;
14.  
    }
15.  
    return person;
16.  
    }
17.  
    public void sayHello(){
18.  
    System.out.println("sayHello方法");
19.  
    }
20.  
    }

1.2、饿汉式单例

1.  
   public class Student {
2.  
   //1、 饿汉式单例模式， 在类加载时创建一个对象
3.  
   private static Student student = new Student();
4.  
    
5.  
   // 2 构造器私有化
6.  
   private Student(){
7.  
    
8.  
   }
9.  
   // 3 提供返回类对象的静态方法
10.  
    public static Student getInstance(){
11.  
    if(student !=null){
12.  
    return student;
13.  
    }
14.  
    return null;
15.  
    }
16.  
    }

2、工厂方法模式

创建对象的过程不再由当前类实例化，而是由工厂类完成，在工厂类中只需要告知对象类型即可。工厂模式中必须依赖接口

2.1简单工厂模式

​ 简单工厂模式的工厂类一般是使用静态方法，通过接收的参数的不同来返回不同的对象实例。不修改代码的话，是无法扩展的。

​ 以生产“电脑”为例，电脑有办公的功能，可以生产一体机或笔记本

代码与静态工厂一样

2.2静态工厂模式

1.  
   //电脑接口
2.  
   public interface Computer {
3.  
   //电脑办公
4.  
   public void work();
5.  
   }

1.  
   //笔记本
2.  
   public class PersonComputer implements Computer{
3.  
    
4.  
   @Override
5.  
   public void work() {
6.  
   System.out.println("这是笔记本电脑，正在办公");
7.  
   }
8.  
   }

1.  
   //一体机
2.  
   public class WorkComputer implements Computer{
3.  
    
4.  
   @Override
5.  
   public void work() {
6.  
   System.out.println("这是一体机正在办公");
7.  
   }
8.  
   }

1.  
   //用于生产电脑的工厂 （这个工厂既可以生产台式机也可以生产笔记本）
2.  
   public class ComputerFactory {
3.  
    
4.  
   /**
5.  
   * 根据不同的类型 生产不同的产品
6.  
   * @param type
7.  
   * @return
8.  
   */
9.  
   public Computer produce(String type){
10.  
    Computer computer =null;
11.  
    if(type.equals("personComputer")){
12.  
    computer = new PersonComputer();
13.  
    }else if(type.equals("workComputer")){
14.  
    computer = new WorkComputer();
15.  
    }else{
16.  
    System.out.println("不能生产");
17.  
    }
18.  
    return computer;
19.  
    }

1.  
   //静态工厂方法模式
2.  
   public class ComputerFactory2 {
3.  
   /**
4.  
   * 静态工厂方法
5.  
   * @param type
6.  
   * @return
7.  
   */
8.  
   public static Computer produce(String type){
9.  
   // 定义一个接口的引用 通过接口new 一个实现类的对象
10.  
    // 提高扩展性
11.  
    Computer computer=null;
12.  
    if(type.equals("workComputer")){
13.  
    computer = new WorkComputer();
14.  
    }else if(type.equals("personComputer")){
15.  
    computer = new PersonComputer();
16.  
    }else{
17.  
    System.out.println("不能创建对象");
18.  
    }
19.  
    return computer;
20.  
    }
21.  
    }

1.  
   //测试类
2.  
   public class Test1 {
3.  
   public static void main(String[] args) {
4.  
   // 通过工厂类创建对象
5.  
   ComputerFactory factory = new ComputerFactory();
6.  
   // 要对象 找工厂
7.  
   Computer computer1 = factory.produce("workComputer");
8.  
   computer1.work();
9.  
   // 创建笔记本
10.  
    Computer computer2 = factory.produce("personComputer");
11.  
    computer2.work();
12.  
     
13.  
    Computer computer3 = ComputerFactory2.produce("workComputer");
14.  
    computer3.work();
15.  
    }
16.  
    }

3.3工厂方法模式

​ 工厂方法是针对每一种产品提供一个工厂类。通过不同的工厂实例来创建不同的产品实例。在同一等级结构中，支持增加任意产品。

例如：

1.  
   //汽车接口
2.  
   public interface Car {
3.  
   public void showInfo();
4.  
   }

1.  
   public class AudiCar implements Car {
2.  
   @Override
3.  
   public void showInfo() {
4.  
   System.out.println("这是一台奥迪汽车。。");
5.  
   }
6.  
   }
7.  
   public class BMWCar implements Car {
8.  
   @Override
9.  
   public void showInfo() {
10.  
    System.out.println("这是一台宝马汽车。");
11.  
    }
12.  
    }

1.  
   /**
2.  
   生产汽车的工厂接口
3.  
   **/
4.  
   public interface CarFactory {
5.  
   public Car produce();
6.  
   }

1.  
   public class AudiCarFactory implements CarFactory {
2.  
   @Override
3.  
   public Car produce() {
4.  
    
5.  
   return new AudiCar();// 这里AudiCar是Car的实现类
6.  
   }
7.  
   }

1.  
   public class BMWCarFactory implements CarFactory {
2.  
   @Override
3.  
   public Car produce() {
4.  
   return new BMWCar();// 因为BWMCar是Car的实现类
5.  
   }
6.  
   }
7.  
    

1.  
   public class Test1 {
2.  
   public static void main(String[] args) {
3.  
   //先创建 汽车工厂
4.  
   CarFactory bmwFactory = new BMWCarFactory();
5.  
   // 这个工厂生产的汽车就是 宝马
6.  
   Car bmw = bmwFactory.produce();
7.  
   bmw.showInfo();
8.  
    
9.  
   //这个模式对于同一级别的产品，可扩展性高
10.  
    //可以扩展不同品牌的汽车，此时不需要修改代码，只需要增加代码即可
11.  
    // 创建一个新的品牌汽车 大众汽车
12.  
     
13.  
    CarFactory dazhongFactory = new DazhongCarFactory();
14.  
    Car car = dazhongFactory.produce();
15.  
    car.showInfo();
16.  
    }
17.  
    }
18.  
     

3、抽象工厂模式

​ 对于在工厂方法的基础上，对同一个品牌的产品有不同的分类，并对分类产品创建的过程 ，一个汽车产品 会分为不同的种类（迷你汽车 ，SUV汽车 ）

1.  
   /**
2.  
   * 迷你汽车接口
3.  
   */
4.  
   public interface MiniCar {
5.  
   public void showInfo();
6.  
   }

1.  
   /**
2.  
   * SUV汽车接口
3.  
   */
4.  
   public interface SUVCar {
5.  
   public void showInfo();
6.  
    
7.  
   }

1.  
   public class AudiMiniCar implements MiniCar {
2.  
   @Override
3.  
   public void showInfo() {
4.  
   System.out.println("这是奥迪迷你汽车 ");
5.  
   }
6.  
   }
7.  
   public class BMWMiniCar implements MiniCar {
8.  
   @Override
9.  
   public void showInfo() {
10.  
    System.out.println("这是宝马Cooper迷你汽车");
11.  
    }
12.  
    }
13.  
    public class AudiSUVCar implements SUVCar {
14.  
    @Override
15.  
    public void showInfo() {
16.  
    System.out.println("这是一辆 奥迪SUV汽车");
17.  
    }
18.  
    }
19.  
    public class BMWSUVCar implements SUVCar {
20.  
    @Override
21.  
    public void showInfo() {
22.  
    System.out.println("这宝马的SUV系列");
23.  
    }
24.  
    }

1.  
   public interface CarFactory {
2.  
   //生成不同型号的汽车 ，两条产品线
3.  
   public MiniCar produceMiniCar();
4.  
    
5.  
   public SUVCar produceSUVCar();
6.  
   }
7.  
   public class AudiCarFactory implements CarFactory {
8.  
   @Override
9.  
   public MiniCar produceMiniCar() {
10.  
    return new AudiMiniCar();
11.  
    }
12.  
     
13.  
    @Override
14.  
    public SUVCar produceSUVCar() {
15.  
    return new AudiSUVCar();
16.  
    }
17.  
    }
18.  
    public class BMWCarFactory implements CarFactory {
19.  
    // 生成迷你汽车的方法，返回MiniCar
20.  
    @Override
21.  
    public MiniCar produceMiniCar() {
22.  
    return new BMWMiniCar();
23.  
    }
24.  
    //生成SUV汽车的方法， 返回SUVCar
25.  
    @Override
26.  
    public SUVCar produceSUVCar() {
27.  
    return new BMWSUVCar();
28.  
    }
29.  
    }

1.  
   /**
2.  
   * 测试类
3.  
   */
4.  
   public class Test1 {
5.  
   public static void main(String[] args) {
6.  
   //创建宝马迷你汽车 找工厂
7.  
   CarFactory factory = new BMWCarFactory();
8.  
   MiniCar car = factory.produceMiniCar();
9.  
   car.showInfo();
10.  
    }
11.  
    }

总结：对于简单工厂，工厂方法模式和抽象工厂的区别和用途

小结：

★工厂模式中，重要的是工厂类，而不是产品类。产品类可以是多种形式，多层继承或者是单个类都是可以的。但要明确的，工厂模式的接口只会返回一种类型的实例，这是在设计产品类的时候需要注意的，最好是有父类或者共同实现的接口。

★使用工厂模式，返回的实例一定是工厂创建的，而不是从其他对象中获取的。

★工厂模式返回的实例可以不是新创建的，返回由工厂创建好的实例也是可以的。

区别：

1、对于简单工厂，用于生产同一结构中的任意产品，对于新增产品不适用。

2、对于工厂方法，在简单工厂的基础上，生产同一等级结构中笃定产品，可以支持新增产品。

3、抽象工厂，用于生产不同种类（品牌）的相同类型（迷你，SUV），对于新增品牌可以，不支持新增类型

8、模板方法

定义：

​ 模板方法是一种行为模式，父类的一个方法定义完成这个方法的步骤，但不具体实现具体细节，由子类完成各个步骤的实现，在创建子类对象时，最终实现过程是子类的方法。

模板方法的准备：

​ 1、继承关系

​ 2、父类是抽象类：抽象类实现了模板方法，定义了算法的估计

​ 3、子类继承抽象类：实现抽象方法，完成完整的算法

1.  
   public abstract class AbstractPerson {
2.  
   /**
3.  
   * 定义一个模板方法，用于实现这个方法的基本“骨架”
4.  
   * 每一步骤的具体实现由子类完成
5.  
   */
6.  
   public void preparedSchool(){
7.  
   getUp();
8.  
   dressing();
9.  
   eat();
10.  
    }
11.  
    //起床
12.  
    public abstract void getUp();
13.  
    //穿衣服
14.  
    public abstract void dressing();
15.  
    //吃早餐
16.  
    public abstract void eat();
17.  
    }

1.  
   public class Student extends AbstractPerson {
2.  
   @Override
3.  
   public void getUp() {
4.  
   System.out.println("学生起床，起不来，闹钟响3次");
5.  
   }
6.  
    
7.  
   @Override
8.  
   public void dressing() {
9.  
   System.out.println("学生穿衣服，找不到衣服");
10.  
     
11.  
    }
12.  
     
13.  
    @Override
14.  
    public void eat() {
15.  
    System.out.println("学生吃早餐，来不及吃早餐");
16.  
     
17.  
    }
18.  
    }

1.  
   public class Teacher extends AbstractPerson {
2.  
   @Override
3.  
   public void getUp() {
4.  
   System.out.println("老师起床，7点半起床");
5.  
   }
6.  
    
7.  
   @Override
8.  
   public void dressing() {
9.  
   System.out.println("老师要衣服得体，穿工装");
10.  
    }
11.  
     
12.  
    @Override
13.  
    public void eat() {
14.  
    System.out.println("老师吃早餐。");
15.  
    }
16.  
    }

1.  
   public class Test1 {
2.  
   public static void main(String[] args) {
3.  
   Student stu = new Student();
4.  
   stu.preparedSchool();
5.  
    
6.  
   Teacher teacher = new Teacher();
7.  
   teacher.preparedSchool();
8.  
    
9.  
   }
10.  
    }

原贴地址：点我跳转