Java设计模式（搭配代码讲解）

Java设计模式

一.概念

　　1.什么是设计模式？

　　设计模式是对软件设计中普遍存在（反复出现）的各种问题，所提出的解决方案。

　　2.目的？

　　1）代码重用性（即：相同功能代码，不用多次编写）

　　2）可读性 （即：编程规范性，便于其他程序员阅读和理解）

　　3）可扩展性 （即：当需要增加功能时，非常方便）

　　4）可靠性 （即：增加新功能后，对原来功能没影响）

　　5）使程序高内聚，低耦合

二.七大原则

　   详细代码看 https://github.com/ShawnSunVip/demos-collections/tree/main/demo-parent/demo-design/src/main/java/com/sun/principle

　　1.单一职责原则

　　　　1）概念

　　　　即一个类应该只负责一项职责　

　　　　2）实例　

　　　　动物的运动方式

public class SingleDemo1 {
    public static void main(String[] args) {
        Animal vehicle =new Animal();
        vehicle.run("马");
        vehicle.run("鸟");
        vehicle.run("鱼");
    }
}

//动物类
class Animal {
    public void run(String vehicel) {
        System.out.println(vehicel+"	 在公路上跑");
    }
}　

　　　　demo1  
　　　　1.run方法违反了单一职责原则
　　　　2.解决思路，根据不同动物对运动方式，分解成不同类　　　　　

public class SingleDemo2 {
    public static void main(String[] args) {
        RoadAnimal roadAnimal = new RoadAnimal();
        roadAnimal.run("马");

        WaterAnimal waterAnimal = new WaterAnimal();
        waterAnimal.run("鱼");

        AirAnimal airAnimal = new AirAnimal();
        roadAnimal.run("鸟");

    }
}

//demo2
class RoadAnimal {
    public void run(String vehicel) {
        System.out.println(vehicel+"	 在公路上跑");
    }
}
class WaterAnimal {
    public void run(String vehicel) {
        System.out.println(vehicel+"	 在水里游");
    }
}
class AirAnimal {
    public void run(String vehicel) {
        System.out.println(vehicel+"	 在天上飞");
    }
}

　　　　demo2
　　　　1.遵守了单一职责原则
　　　　2.改动很大，类分解
　　　　3.还可以怎么改？

public class SingleDemo3 {
    public static void main(String[] args) {
        NewAnimal newAnimal = new NewAnimal();
        newAnimal.run("马");
        newAnimal.runWater("鱼");
        newAnimal.runAir("鸟");
    }
}

//demo3
class NewAnimal {
    public void run(String vehicel) {
        System.out.println(vehicel+"	 在公路上跑");
    }
    public void runWater(String vehicel) {
        System.out.println(vehicel+"	 在水里游");
    }
    public void runAir(String vehicel) {
        System.out.println(vehicel+"	 在天上飞");
    }
}

　　　　demo3
　　　　1.只是在原来方法上添加方法
　　　　2.在类上没有遵守单一职责原则，但在方法上，仍然遵守单一职责原则

　　　　3)注意点

　　　　　　降低类复杂度，一个类只负责一项职责

　　　　　　提高可读性，可维护性

　　　　　　降低变更引起的风险

　　　　　　一般情况下，要遵守单一职责原则，只有逻辑特别简单，才可以在类级别违反单一职责原则，但至少保证方法的单一职责原则

　　2.接口隔离原则

 　　　　1)概念

　　　　客户端不应该依赖它不需要的接口，即一个类对另一个类依赖建立在最小对接口上

　　　　2)实例

　　　　类A通过接口依赖类C，类B通过接口依赖D

　　　　改进前　

public class SegregationDemo1 {
    public static void main(String[] args) {
        // 写个demo 类A通过接口依赖类C 类B通过接口依赖类D
        // 以下方法不符合接口隔离原则
        A a = new A();
        B b = new B();
        a.do1(new C());
        a.do2(new C());
        a.do3(new C());
        b.do1(new D());
        b.do4(new D());
        b.do5(new D());
    }
}

// 定义接口 有方法1，2，3，4，5
interface Interface1{
    void method1();
    void method2();
    void method3();
    void method4();
    void method5();
}

// 类C实现接口
class C implements  Interface1{

    public void method1() {
        System.out.println("C 实现method1");
    }

    public void method2() {
        System.out.println("C 实现method2");
    }

    public void method3() {
        System.out.println("C 实现method3");
    }

    public void method4() {
        System.out.println("C 实现method4");
    }

    public void method5() {
        System.out.println("C 实现method5");
    }
}

// 类D实现接口
class D implements  Interface1 {

    public void method1() {
        System.out.println("D 实现method1");
    }

    public void method2() {
        System.out.println("D 实现method2");
    }

    public void method3() {
        System.out.println("D 实现method3");
    }

    public void method4() {
        System.out.println("D 实现method4");
    }

    public void method5() {
        System.out.println("D 实现method5");
    }
}

// 类A 依赖 C的方法1，2，3
class A {

    public void do1(Interface1 i) {
        i.method1();
    }

    public void do2(Interface1 i) {
        i.method2();
    }

    public void do3(Interface1 i) {
        i.method3();
    }


}

// 类B 依赖 D的方法1，4，5
class B {

    public void do1(Interface1 i) {
        i.method1();
    }

    public void do4(Interface1 i) {
        i.method4();
    }

    public void do5(Interface1 i) {
        i.method5();
    }
}

　　

　　　　改进后 

public class SegregationDemo2 {
    public static void main(String[] args) {
        // 改进
        A1 a = new A1();
        B1 b = new B1();
        a.do1(new C1());
        a.do2(new C1());
        a.do3(new C1());
        b.do1(new D1());
        b.do4(new D1());
        b.do5(new D1());
    }
}

// 定义接口11 有方法1
interface Interface11{
    void method1();
}

// 定义接口12 有方法2，3
interface Interface12{
    void method2();
    void method3();
}

// 定义接口13 有方法4，5
interface Interface13{
    void method4();
    void method5();
}

// 类C实现接口11和12
class C1 implements Interface11,Interface12{

    public void method1() {
        System.out.println("C 实现method1");
    }

    public void method2() {
        System.out.println("C 实现method2");
    }

    public void method3() {
        System.out.println("C 实现method3");
    }
}

// 类D实现接口11，13
class D1 implements  Interface11,Interface13 {

    public void method1() {
        System.out.println("D 实现method1");
    }

    public void method4() {
        System.out.println("D 实现method4");
    }

    public void method5() {
        System.out.println("D 实现method5");
    }
}

// 类A 依赖 C的方法1，2，3
class A1 {

    public void do1(Interface11 i) {
        i.method1();
    }

    public void do2(Interface12 i) {
        i.method2();
    }

    public void do3(Interface12 i) {
        i.method3();
    }


}

// 类B 依赖 D的方法1，4，5
class B1 {

    public void do1(Interface11 i) {
        i.method1();
    }

    public void do4(Interface13 i) {
        i.method4();
    }

    public void do5(Interface13 i) {
        i.method5();
    }
}

　　3.依赖倒置原则

 　　　　1）概念

　　　　程序要依赖抽象接口，不用依赖于具体实现

　　　　2）实例　　　

public class InversionDemo1 {
    public static void main(String[] args) {
        Person person = new Person();
        person.receive(new Email());
    }
}

class Email {
    public String getMessage(){
        return "获得邮件";
    }
}

class Person {
    public void receive(Email e){
        System.out.println(e.getMessage());
    }
}

　　　　demo1 简单容易

　　　　但是如果获取对象是微信，短信，那么需要新增类，同时Person类也需要增加相应接收方法。怎么改进？？？　

public class InversionDemo2 {
    public static void main(String[] args) {
        NewPerson person = new NewPerson();
        person.receive(new Email2());
        person.receive(new Weixin());
    }
}

interface IReceiver {
    String getMessage();
}

class Email2 implements IReceiver {
    public String getMessage() {
        return "获得邮件消息";
    }
}

class Weixin implements IReceiver {
    public String getMessage() {
        return "获得微信消息";
    }
}

class NewPerson {
    public void receive(IReceiver e){
        System.out.println(e.getMessage());
    }
}

　　　　3）总结

　　　　高层模块不应该依赖低层模块，二者都应该依赖其抽象

　　　　抽象不应该依赖细节，细节应该依赖抽象

　　　　中心思想是面向接口编程

　　　　相对于细节都多变性，抽象要稳定都多，以抽象为基础搭建多架构比以细节为基础多架构更稳定。抽象即接口或抽象类，细节即具体的实现类

　　　　用接口或抽象类目的是制定规范，而不设计具体操作，把展示细节交给实现类完成

　　　　4)扩展 

　　　　依赖倒置的三种方法

public class InversionDemo3 {
    public static void main(String[] args) {
        // 方式一
        Tourism tourism = new Tourism();
        tourism.ride(new Bus());

        // 方式二
          Tourism tourism = new Tourism(new AirCraft());
          tourism.ride();
        // 方式三
          Tourism tourism = new Tourism();
          tourism.setTraffic(new Bus());
          tourism.ride();
    }
}

// 方式1。接口传递
//旅行
interface ITourism {
    public void ride(ITraffic i);
}

// 交通
interface ITraffic {
    public void tool();
}

//大巴
class Bus implements ITraffic {
    public void tool() {
        System.out.println("乘大巴旅行");
    }
}

//飞机
class AirCraft implements ITraffic {
    public void tool() {
        System.out.println("乘飞机旅行");
    }
}

// 旅行类
class Tourism implements ITourism {
    public void ride(ITraffic t) {
        t.tool();
    }
}


//方式2 构造
interface ITourism {
    public void ride();
}
// 交通
interface ITraffic {
    public void tool();
}

//大巴
class Bus implements ITraffic{
    public void tool() {
        System.out.println("乘大巴旅行");
   }
}

//飞机
class AirCraft implements ITraffic{
    public void tool() {
        System.out.println("乘飞机旅行");
    }
}

// 旅行类
class Tourism implements ITourism {
    public ITraffic t;
    public Tourism (ITraffic t){
        this.t =t;
    }
    public void ride() {
        t.tool();
    }
}

// 方式三 Setter注入
interface ITourism {
   public void ride();
    public void setTraffic(ITraffic t);
}
// 交通
interface ITraffic {
    public void tool();
}

//大巴
class Bus implements ITraffic{
    public void tool() {
        System.out.println("乘大巴旅行");
    }
}

////飞机
class AirCraft implements ITraffic{
    public void tool() {
        System.out.println("乘飞机旅行");
    }
}

// 旅行类
class Tourism implements ITourism {
    private ITraffic t;
    public void setTraffic(ITraffic t) {
        this.t =t;
    }
    public void ride() {
        t.tool();
    }
}

　　　

　　4.里氏替换原则

　　　　1）概念

　　　　子类可以扩展父类功能，但不能改变父类原有功能。将一个基类对象替换成它子类，程序不会产生任何错误和异常

　　　　2）实例　

public class RichterReplaceDemo1 {
    public static void main(String[] args) {
        A a = new A();
        System.out.println("8+1:"+a.method(8, 1));

        B b = new B();
        System.out.println("8+1:"+b.method(8,1));


    }
}

class A {
    public int method(int n1,int n2){
        return n1+n2;
    }
}

class B extends A {
    // 不小心重写父类方法
    public int method(int n1,int n2){
        return n1-n2;
    }

    public int method2(int n1,int n2) {
        return (n1+n2)*3;
    }
}

　　　　B类继承A类，调用者不小心修改父类方法。怎么改进尼？建立一个更小的基类。

public class RichterReplaceDemo2 {
    public static void main(String[] args) {
        A1 a = new A1();
        System.out.println("8+1:"+a.method(8, 1));

        B1 b = new B1();
        System.out.println("8-1:"+b.method(8,1));
    }
}

//添加一个更基础但基类
class Base {

}

class A1 extends Base {
    public int method(int n1,int n2){
        return n1+n2;
    }
}

// B类不在继承A，调用功能很明确，调用者不会改错
class B1 extends Base {
    public int method(int n1,int n2){
        return n1-n2;
    }

    public int method2(int n1,int n2) {
        return (n1+n2)*3;
    }
}

　　　

 

　　5.开闭原则

　　　　1）概念

　　　　对扩展开发，对修改关闭。

　　　　2）实例　

public class OpenCloseDemo1 {
    public static void main(String[] args) {
        BackHome backHome = new BackHome();
        backHome.backHome(new Walk());
        backHome.backHome(new Car());
    }
}

// 回家
class BackHome {
    public void backHome(Back b){
        if(b.type ==1){
            walk();
        }else if (b.type ==2){
            car();
        }
    }

    public void walk(){
        System.out.println("步行回家");
    }

    public void car(){
        System.out.println("开车回家");
    }
}
// 基类
class Back {
    int type;
}
//步行
class Walk extends Back{
    Walk(){
        super.type=1;
    }
}
//开车
class Car extends Back{
    Car(){
        super.type=2;
    }
}

　　　　优点：理解很容易

　　　　缺点：难扩展，违反开闭原则

　　　　改进：基类改成抽象类 并提供抽象方法

public class OpenCloseDemo2 {
    public static void main(String[] args) {
        NewBackHome newBackHome = new NewBackHome();
        newBackHome.backHome(new NewWalk());
        newBackHome.backHome(new NewCar());
        newBackHome.backHome(new NewSubWay());
    }
}

// 回家
class NewBackHome {
    public void backHome(NewBack b){
        b.BackHome();
    }

}
// 基类-》改成抽象类
abstract class NewBack {
    int type;
    public abstract void BackHome();// 抽象方法
}
//步行
class NewWalk extends NewBack{
    NewWalk(){
        super.type=1;
    }

    public void BackHome() {
        System.out.println("步行回家");
    }
}
//开车
class NewCar extends NewBack{
    NewCar(){
        super.type=2;
    }

    public void BackHome() {
        System.out.println("开车回家");
    }
}

//地铁
class NewSubWay extends NewBack{
    NewSubWay(){
        super.type=3;
    }

    public void BackHome() {
        System.out.println("地铁回家");
    }
}

 

　　6.迪米特法原则（最少知道原则）

　　　　1）概念

　　　　一个类对它依赖对类知道对越少越好，我们称成员变量，方法参数，方法返回值为直接朋友，而局部变量不是直接朋友。

　　　　2）实例

public class LodDemo1 {
    public static void main(String[] args) {
        D d = new D();
        d.printAll(new C());
    }
}

class A {
    private int id;
    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }
}

class B {
    private int id;
    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }
}

class C {
    public List<A> getAllA(){
        List<A> as = new ArrayList<A>();
        for (int i = 0; i <5 ; i++) {
            A a = new A();
            a.setId(i);
            as.add(a);
        }
        return as;
    }
}

class D {
    public List<B> getAllB(){
        List<B> bs = new ArrayList<B>();
        for (int i = 0; i <10 ; i++) {
            B b = new B();
            b.setId(i);
            bs.add(b);
        }
        return bs;
    }

    public void printAll(C c){
        List<A> allA = c.getAllA();
        for (A a: allA) {
            System.out.println("A:"+a.getId());
        }
        List<B> allB = this.getAllB();
        for (B b: allB) {
            System.out.println("B:"+b.getId());
        }
    }
}

　　　　类D的直接朋友：类B（方法返回值） 类C（方法参数）。非直接朋友：类A  

　　　　违法迪米特原则，怎么改进？？？

public class LodDemo2 {
    public static void main(String[] args) {
        D1 d = new D1();
        d.printAll(new C1());
    }
}

class A1 {
    private int id;
    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }
}

class B1 {
    private int id;
    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }
}

class C1 {
    public List<A1> getAllA(){
        List<A1> as = new ArrayList<A1>();
        for (int i = 0; i <5 ; i++) {
            A1 a = new A1();
            a.setId(i);
            as.add(a);
        }
        return as;
    }

    public void printA(){
        List<A1> allA = getAllA();
        for (A1 a: allA) {
            System.out.println("A:"+a.getId());
        }
    }

}

class D1 {
    public List<B1> getAllB(){
        List<B1> bs = new ArrayList<B1>();
        for (int i = 0; i <10 ; i++) {
            B1 b = new B1();
            b.setId(i);
            bs.add(b);
        }
        return bs;
    }

    public void printAll(C1 c){
        c.printA();
        List<B1> allB = this.getAllB();
        for (B1 b: allB) {
            System.out.println("B:"+b.getId());
        }
    }
}

 

　　7.合成复用原则

　　　　1）概念

　　　　尽量使用合成/聚合方式，而不是使用继承

　　　　 2）实例

public class CompositeDemo1 {
    public static void main(String[] args) {
        B b = new B();
        b.method3();
    }
}

class A {
    public void method1(){
        System.out.println("A:method1");
    }
    
    public void method2(){
        System.out.println("A:method2");
    }
}

class B extends A {
    public void method3(){
        method1();
    }
}

　　　　为了使用类A的方法，类B去继承类A，增强了A和B的耦合

public class CompositeDemo2 {
    public static void main(String[] args) {
        B1 b1 = new B1();
        // 解决方法1 依赖
        b1.method3(new A1());

        //解决方法2  聚合
        b1.setA(new A1());
        b1.method4();

        //解决方法2  组合
        b1.method5();

    }
}

class A1 {
    public void method1(){
        System.out.println("A:method1");
    }

    public void method2(){
        System.out.println("A:method2");
    }
}

class B1 {
    // 解决方法一
    public void method3(A1 a){
       a.method1();
    }

    // 解决方法二
    private A1 a;

    public A1 getA() {
        return a;
    }

    public void setA(A1 a) {
        this.a = a;
    }

    public void method4(){
        a.method1();
    }

    // 解决方法3
    private A1 a1 = new A1();
    public void method5(){
        a1.method1();
    }
}

 　　

　　总结：　

　　　　1.找出应用中可能变化之处，把它独立出来。

　　　　2.针对接口编程，而不是实现编程

　　　　3.为了交互设计之间松耦合设计

 

三.二十三种设计模式

　1.创建型模式

　　1）单例模式

　　　　详细代码看https://github.com/ShawnSunVip/demos-collections/tree/main/demo-parent/demo-design/src/main/java/com/sun/singleton

　　　　1⃣️饿汉式 静态常量

　　　　  优点：类加载就实例化，避免线程同步

　　　　  缺点：如果类没被使用，则导致内存浪费　   

class Sigleton01 {
    // 私有构造器 防止被new对象
    private Sigleton01(){}

    // 内部创建对象
    private final static Sigleton01 instance =new Sigleton01();

    // 对外暴露静态公共方法
    public static Sigleton01 getInstance(){
        return instance;
    }
}

　　　　　2⃣️饿汉式 静态代码块

　　　　  优缺点同上

class Singleton02{
    private Singleton02(){}

    private static Singleton02 instance;

    // 静态代码块 创建实例
    static {
        instance=new Singleton02();
    }

    public static Singleton02 getInstance(){
        return instance;
    }
}

　　　　　3⃣️懒汉式 线程不安全

　　　　  优点：调用时候才实例化，节省内存

　　　　  缺点：多线程不安全

class Singleton03{
    private Singleton03(){}

    private static Singleton03 instance;

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

　　　　   4⃣️懒汉式 synchranized

　　　　　优点：线程安全

　　　　　缺点：同步效率低

class Singleton04{
    private Singleton04(){}

    private static Singleton04 instance;

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

    private static Singleton04 instance;

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

                 5⃣️懒汉式 双端检锁检测（推荐）

                 优点：线程安全，同步效率高

class Singleton05{
    private Singleton05(){}

    private volatile static Singleton05 instance;

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

　　　　   6⃣️静态内部类（推荐）

　　　　   优点：线程安全，同步效率高

　　　　   原理：类的静态属性只有在第一次加载时初始化，jvm保证了线程的安全。静态内部类被装载时不会实例化，调用时候才会

class Singleton06{
    private Singleton06(){}

    private static class Singleton06Instance{
        private static final Singleton06 INSTANCE=new Singleton06();
    }

    public static  Singleton06 getInstance(){
        return Singleton06Instance.INSTANCE;
    }
}

　　　　　7⃣️枚举（推荐）

　　　　  优点：线程安全，防反序列化重写创建对象

enum Singleton07{
    INSTANCE;
}

　　　　   总结：

　　　　　 针对一些需要频繁创建和销毁的对象使用如工具类，数据源等。

　　2）抽象工厂模式

　　3）原型模式

　　4）建造者模式

　　5）工厂模式

　　　　本实例demo通过设计一个计算器来讲述工厂模式的实现流程。

　　　　详细代码查看：https://github.com/ShawnSunVip/demos-collections/tree/main/demo-parent/demo-design/src/main/java/com/sun/factory

    2.结构型模式

　　1）适配器模式

　　2）桥接模式

　　3）装饰者模式

　　　　本实例demo通过设计人物服饰装配来讲述装饰者模式的实现流程

　　　　详细代码查看：https://github.com/ShawnSunVip/demos-collections/tree/main/demo-parent/demo-design/src/main/java/com/sun/decorator

　　4）组合模式

　　5）外观模式

　　6）享元模式

　　7）代理模式

　3.行为型模式

　　1）模板方法模式

　　2）命令模式

　　3）访问者模式

　　4）迭代器模式

　　5）观察者模式

　　6）中介者模式

　　7）备忘录模式

　　8）解释器模式

　　9）状态模式

　　10）策略模式

　　　　本实例demo通过设计一个超市的收款方式来讲述策略模式的实现流程。

　　　　详细代码查看：https://github.com/ShawnSunVip/demos-collections/tree/main/demo-parent/demo-design/src/main/java/com/sun/strategy

　　11）责任链模式

 

持续更新...