java设计模式详解
Posted 野生java研究僧
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了java设计模式详解相关的知识，希望对你有一定的参考价值。
java设计模式详解
- 0.设计模式的七大原则
- 1.单例模式
- 2.工厂模式
- 3.原型模式
- 4.建造者模式
- 5.适配器模式
- 6.享元模式
- 7.门面模式
- 8.组合模式
- 9.装饰者模式
- 10.代理模式
- 11.桥接模式
- 12.模板方法
- 13.迭代器模式
- 14.责任链模式
- 15.策略模式
- 17.备忘录模式
- 19.命令模式
- 20.访问者模式
- 21.观察者模式
- 22.解释器模式
- 23.状态模式
- 24.中介模式
0.设计模式的七大原则
通过本文章，你可以了解到常用的设计模式，本文的设计模式都是通过java语言进行讲解的，这也是我个人的一个学习笔记，设计模式以及数据结构和算法可能实际开发中用不到，但是这是程序员的基本功，这也就是你看框架源代码的时候头晕，看不懂，不知道别人到底写的什么玩意儿。那么你该静下心来好好学习基础知识了，记住一句话，罗马不少一天建成的，万丈高楼平地其，一切都以基础为准，框架层出不穷，但是万变不离其宗，都是以我们的核心基础知识来的。学完设计模式，你对写代码的一个水平会有一个很好的提升。
设计模式的目的
编写软件过程中，程序员面临着来自 耦合性，内聚性以及可维护性，可扩展性，重用性，灵活性 等多方面的挑战， 设计模式是为了让程序(软件)，具有如下更好的特性
设计模式在软件中哪里？
面向对象(oo)=>功能模块[设计模式+算法(数据结构)]=>框架[使用到多种设计模式]=> 架构 [服务器集群]
- 代码重用性 (即：相同功能的代码，不用多次编写)
- 可读性 (即：编程规范性，便于其他程序员的阅读和理解)
- 可扩展性 (即：当需要增加新的功能时，非常的方便，称为可维护)
- 可靠性 (即：当我们增加新的功能后，对原来的功能没有影响)
- 使程序呈现高内聚， 低耦合的特性(程序内部紧凑，模块之间依赖性小)
设计模式原则，其实就是程序员在编程时，应当遵守的原则， 也是各种设计模式的基础(即： 设计模式为什么这样设计的依据)
设计模式常用的七大原则有:
- 单一职责原则
- 接口隔离原则
- 依赖倒转(倒置)原则
- 里氏替换原则
- 开闭原则
- 迪米特法则
- 合成复用原则
1.单一职责原则
对类来说的，即一个类应该只负责一项职责。如类A负责两个不同职责：职责1，职责2。当职责1需求变更而改变A时，可能造成职责2执行错误， 所以需要将类A的粒度分解为A1， A2
就比如说我们的javaWeb开发的到层，一个UserDao就对用户表增删改查，一个OrderDao就对我们的订单表增删改查，如果UserDao和OrderDao的功能都放到一个类只能，那么就可能会出现，UserDao出现错误导致OrderDao也不能用。所以我们就需要使用单一职责，让一个类做一个事情，降低代码的耦合度，使其代码之间的依赖性不少那么强。
单一职责案例
错误案例1：这的逻辑是不对的，造成代码的逻辑混乱
/** 单一职责
* @author compass
* @version 1.0
* @date 2021-07-04 0:34
*/
public class SingleResponsibility1
public static void main(String[] args)
Vehicle vehicle = new Vehicle();
vehicle.run("摩托车");
vehicle.run("汽车");
vehicle.run("飞机");
/**
* 交通工具类Vehicle
* 1. 这种方式违反了单一职责
* 2.解决的方案非常简单，根据不同的交通工具分解未不同的类 提供run方法
*/
class Vehicle
public void run(String vehicle)
System.out.println(vehicle+"在公路上运行");
解决思路：将业务进行拆分，就是根据不同的业务，构建出不同的类，让不同的类去做不同的事情，让他们互不影响。
正确案例2：但是这样做改动很大，即将类进行分解，同时会修改客户端，接下来我们看第三种改进的方式。
/** 单一职责（正确示范）
* @author compass
* @version 1.0
* @date 2021-07-04 0:34
*/
public class SingleResponsibility2
public static void main(String[] args)
RoadVehicle roadVehicle = new RoadVehicle();
roadVehicle.run("汽车");
WaterVehicle waterVehicle = new WaterVehicle();
waterVehicle.run("轮船");
AirVehicle airVehicle = new AirVehicle();
airVehicle.run("飞机");
/**
* 公路类
*/
class RoadVehicle
public void run(String vehicle)
System.out.println(vehicle+"在公路上运行");
/**
* 天空类
*/
class AirVehicle
public void run(String vehicle)
System.out.println(vehicle+"在天空中运行");
/**
* 天空类
*/
class WaterVehicle
public void run(String vehicle)
System.out.println(vehicle+"在水中运行");
改进方案3：直接修改Vehicle类，改动的代码比较少
/** 单一职责（错误示范）
* @author compass
* @version 1.0
* @date 2021-07-04 0:34
*/
public class SingleResponsibility3
public static void main(String[] args)
Vehicle3 vehicle = new Vehicle3();
vehicle.runARoad("汽车");
vehicle.runAir("飞机");
vehicle.runWater("轮船");
/**
* 交通工具类Vehicle3
* 1. 这种方式虽然违反了单一职责，但是在方法级别上并没有违法单一职责，仍然遵守我们的单一职责
* 2.在业务量很小的时候，可以这样，但是业务量很多，而且不同类型很多，那就不太建议了
*/
class Vehicle3
public void runAir(String vehicle)
System.out.println(vehicle+"在天上运行");
public void runWater(String vehicle)
System.out.println(vehicle+"在水里运行");
public void runARoad(String vehicle)
System.out.println(vehicle+"在公路上运行");
-
单一职责原则的注意事项和原则
- 降低类的复杂度，一个类只负责一项职责
- 提高类的可读性，可维护性
- 降低变更引起的风险
- 通常情况下， 我们应当遵守单一职责原则，只有逻辑足够简单，才可以在代码级违反单一职责原则；只有类中方法数量足够少，可以在方法级别保持单一职责原则
2.接口隔离原则
基本介绍：客户端不应该依赖它不需要的接口，即一个类对另一个类的依赖应该建立在最小的接口上
举例说明
案例1：
- 类A通过接口Interface1依赖类B，类C通过接口Interface1依赖类D，如果接口Interface1对于类A和类C来说不是最小接口，那么类B和类D必须去实现他们不需要的方法。
- 按隔离原则应当这样处理：将接口Interface1拆分为独立的几个接口，类A和类C分别与他们需要的接口建立依赖关系。也就是采用接口隔离原则
代码实现：
** 接口隔离原则（错误示范）
* @author compass
* @version 1.0
* @date 2021-07-04 11:35
*/
public class Segregation1
/**
* 接口
*/
interface Interface1
void operation1();
void operation2();
void operation3();
void operation4();
void operation5();
/**
* 实现interface1接口 并且实现其中的五个方法
*/
class B1 implements Interface1
@Override
public void operation1()
System.out.println("B1 中实现了operation1");
@Override
public void operation2()
System.out.println("B1 中实现了operation2");
@Override
public void operation3()
System.out.println("B1 中实现了operation3");
@Override
public void operation4()
System.out.println("B1 中实现了operation4");
@Override
public void operation5()
System.out.println("B1 中实现了operation5");
/**
* 实现interface1接口 并且实现其中的五个方法
*/
class D1 implements Interface1
@Override
public void operation1()
System.out.println("D1 中实现了operation1");
@Override
public void operation2()
System.out.println("D2 中实现了operation2");
@Override
public void operation3()
System.out.println("D3 中实现了operation3");
@Override
public void operation4()
System.out.println("D4 中实现了operation4");
@Override
public void operation5()
System.out.println("D5 中实现了operation5");
/**
* A类通过接口 Interface1 依赖使用B类 但是只会使用到 1，2，3，方法
*/
class A1
public void depend1(Interface1 i)
i.operation1();
public void depend2(Interface1 i)
i.operation2();
public void depend3(Interface1 i)
i.operation3();
/**
* C类通过接口 Interface1 依赖使用D类 但是只会使用到 1，4，2，方法
*/
class C1
public void depend1(Interface1 i)
i.operation1();
public void depend4(Interface1 i)
i.operation4();
public void depend5(Interface1 i)
i.operation5();
案例2：
分析传统方法的问题，使用接口隔离原则改进程序结构
- 类A通过接口Interface1依赖类B，类C通过接口Interface1依赖类D，如果接口Interface1对于类A和类C来说不是最小接口，那么类B和类D必须去实现他们不需要的方法
- 将接口Interface1拆分为独立的几个接口，类A和类C分别与他们需要的接口建立依赖关系。也就是采用接口隔离原则
- 接口Interface1中出现的方法，根据实际情况拆分为三个接口
代码实现：
/** 接口隔离原则（正确示范）
* @author compass
* @version 1.0
* @date 2021-07-04 11:35
*/
public class Segregation2
public static void main(String[] args)
A a = new A();
a.depend1(new B()); // A类通过接口去依赖B类
a.depend2(new B());
a.depend3(new B());
C c = new C();
c.depend1(new D()); // C类通过接口去依赖(使用)D类
c.depend4(new D());
c.depend5(new D());
// 接口1
interface Interface1
void operation1();
// 接口2
interface Interface2
void operation2();
void operation3();
// 接口3
interface Interface3
void operation4();
void operation5();
class B implements Interface1, Interface2
public void operation1()
System.out.println("B 实现了 operation1");
public void operation2()
System.out.println("B 实现了 operation2");
public void operation3()
System.out.println("B 实现了 operation3");
class D implements Interface1, Interface3
public void operation1()
System.out.println("D 实现了 operation1");
public void operation4()
System.out.println("D 实现了 operation4");
public void operation5()
System.out.println("D 实现了 operation5");
class A // A 类通过接口Interface1,Interface2 依赖(使用) B类，但是只会用到1,2,3方法
public void depend1(Interface1 i)
i.operation1();
public void depend2(Interface2 i)
i.operation2();
public void depend3(Interface2 i)
i.operation3();
class C // C 类通过接口Interface1,Interface3 依赖(使用) D类，但是只会用到1,4,5方法
public void depend1(Interface1 i)
i.operation1();
public void depend4(Interface3 i)
i.operation4();
public void depend5(Interface3 i)
i.operation5();
3.依赖倒转原则
依赖倒转原则(Dependence Inversion Principle)是指：
- 高层模块不应该依赖低层模块，二者都应该依赖其抽象
- 抽象不应该依赖细节，细节应该依赖抽象
- 依赖倒转(倒置)的中心思想是面向接口编程
- 依赖倒转原则是基于这样的设计理念：相对于细节的多变性，抽象的东西要稳定的多。以抽象为基础搭建的架构比以细节为基础的架构要稳定的多。在java中，抽象指的是接口或抽象类，细节就是具体的实现类
- 使用接口或抽象类的目的是制定好规范，而不涉及任何具体的操作，把展现细节的任务交给他们的实现类去完成
案例1：
未遵循依赖倒置原则，Person 类与 Email 类耦合，如果我们还想获取其他消息，比如微信、短信、QQ 等、则需要添加相应的实现方法
/** 接口依赖倒置原则
* @author compass
* @version 1.0
* @date 2021-07-04 13:37
*/
public class DependencyInversion
public static void main(String[] args)
Person person = new Person();
person.receive(new Email());
class Email
public String getInfo()
return "电子邮件信息: hello,world";
//完成Person接收消息的功能
//方式1分析
//1. 简单，比较容易想到
//2. 如果我们获取的对象是 微信，短信等等，则新增类，同时Peron也要增加相应的接收方法
//3. 解决思路：引入一个抽象的接口IReceiver, 表示接收者, 这样Person类与接口IReceiver发生依赖
// 因为Email, WeiXin 等等属于接收的范围，他们各自实现IReceiver 接口就ok, 这样我们就符号依赖倒转原则
class Person
public void receive(Email email)
System.out.println(email.getInfo());
案例2：
引入一个抽象的接口 IReceiver，表示接收者（Email、微信、短信、QQ 等），接受者分别实现 IReceiver 接口中的方法，实现各自接收消息的逻辑，Person 类与 IReceiver 接口发生依赖，达到接收消息的功能
/** 接口依赖倒置原则
* @author compass
* @version 1.0
* @date 2021-07-04 13:37
*/
public class DependencyInversion2
public static void main(String[] args)
Person2 person2 = new Person2();
person2.receive(new Email2());
person2.receive(new WeiXin());
interface IReceiver
public String getInfo();
class Email2 implements IReceiver
public String getInfo()
return "电子邮件信息: hello,world";
//增加微信
class WeiXin implements IReceiver
public Str以上是关于java设计模式详解的主要内容，如果未能解决你的问题，请参考以下文章
设计模式 - 命令模式详解及其在JdbcTemplate中的应用