Java设计模式学习
一.概述
熟练掌握各种设计模式,并能在实际编程开发中灵活运用它们,不仅能使代码更规范,重用性更高,同时也能保证代码的可靠性,提高开发效率。这段时间又系统看了设计模式的相关内容,
整理学习总结如下:
- 七个设计原则
- 创建型模式(5种)
- 结构型模式(7种)
- 行为型模式(11种)
总体来说设计模式分为三大类:(本文着重讲解标红)
创建型模式,共五种: 工厂方法模式、 抽象工厂模式、 单例模式、 建造者模式、原型模式。
结构型模式,共七种: 适配器模式、装饰器模式、 代理模式、外观模式、桥接模式、组合模式、 享元模式。
行为型模式,共十一种: 策略模式、模板方法模式、 观察者模式、迭代子模式、责任链模式、命令模式、备忘录模式、状态模式、访问者模式、中介者模式、解释器模式。
二.七个设计原则
面向对象编程有七大原则,即经常提到的Design Pattern,提倡它的根本原因是为了代码复用,增加可维护性。设计模式就是实现了这些原则,从而达到了代码复用、增加可维护性的目的。
因为设计模式就是基于这些原则的实现,所以很有必要了解这些原则,下面主要对面向对象编程的几个原则进行简单介绍。
1、单一职责原则 ( SRP )
英文全称是Single Responsibility Principle,定义是一个类,应该只有一个引起它变化的原因。类变化的原因就是职责,如果一个类承担的职责过多,就等于把这些职责耦合在一起了。一个职责的变化可能会削弱或者抑制这个类完成其他职责的能力。这种耦合会导致脆弱的设计,当发生变化时,设计会遭受到意想不到的破坏。而如果想要避免这种现象的发生,就要尽可能的遵守单一职责原则。此原则的核心就是解耦和增强内聚性。
2、开闭原则 ( OCP )
英文全称是Open Close Principle,定义是软件实体(包括类、模块、函数等)应该对于扩展时开放的,对于修改是封闭的。开闭原则是是面向对象设计中最重要的原则之一,其它很多的设计原则都是实现开闭原则的一种手段。
3、里氏替换原则 ( LSP )
英文全称是Liskov Substitution Principle,是面向对象设计的基本原则之一。 定义是任何基类可以出现的地方,子类一定可以出现。LSP 是继承复用的基石,只有当派生类可以替换掉基类,且软件单位的功能不受到影响时,基类才能真正被复用,而派生类也能够在基类的基础上增加新的行为。里氏替换原则是对开闭原则的补充。实现开闭原则的关键步骤就是抽象化,而基类与子类的继承关系就是抽象化的具体实现,所以里氏替换原则是对实现抽象化的具体步骤的规范。
4、依赖倒置原则 ( DIP )
英文全称是Dependence Inversion Principle,这个原则是开闭原则的基础,依赖倒置原则就是要求调用者和被调用者都依赖抽象,这样两者没有直接的关联和接触,在变动的时候,一方的变动不会影响另一方的变动。依赖倒置强调了抽象的重要性,针对接口编程,依赖于抽象而不依赖于具体。
5、接口隔离原则 ( ISP )
英文全称是Interface Segregation Principle,这个原则的意思是使用多个隔离的接口,比使用单个接口要好。目的就是降低类之间的耦合度,便于软件升级和维护。
6、最少知道原则(迪米特原则)
一个实体应当尽量少地与其他实体之间发生相互作用,使得系统功能模块相对独立。通俗地说就是不要和陌生人说话,即一个对象应对其他对象有尽可能少的了解。迪米特法则的初衷在于降低类之间的耦合。由于每个类尽量减少对其他类的依赖,因此,很容易使得系统的功能模块功能独立,相互之间不存在(或很少有)依赖关系。
7、合成/聚合复用(CARP)
英文全称是Composite Reuse Principle,合成/聚合复用原则经常又叫做合成复用原则。合成/聚合复用原则的潜台词是:我只是用你的方法,我们不一定是同类。继承的耦合性更大,比如一个父类后来添加实现一个接口或者去掉一个接口,那子类可能会遭到毁灭性的编译错误,但如果只是组合聚合,只是引用类的方法,就不会有这种巨大的风险,同时也实现了复用。
三.创建者模式(5种)
创建型模式是指这些设计模式提供了一种在创建对象的同时隐藏创建逻辑的方式,而不是使用新的运算符直接实例化对象。这使得程序在判断针对某个给定实例需要创建哪些对象时更加灵活
1.单例模式
- 定义
确保某一个类只有一个实例,并自行实例化向整个系统提供这个实例。
- 简介
单例模式理解起来不难,典型例子有一个公司只能有一个CEO。它主要是为了保证一个类仅有一个实例,这个类中自己提供一个返回实例的方法,方法中先判断系统是否已经有这个单例,如果有则返回,如果没有则创建。如果创建多个实例会消耗过多的资源或者某种类型的对象只应该有且只有一个时,应该考虑使用单例模式。
- 实现
单例模式理解起来不难,重要的是需要掌握它的几种常见写法。
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
public class Singleton { // 直接创建对象 public static Singleton instance = new Singleton(); // 私有化构造函数 private Singleton() { } // 返回对象实例 public static Singleton getInstance() { return instance; } }
懒汉式:
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
//写法一、懒汉式写法 public class Singleton { private static Singleton instance; //构造函数私有 private Singleton (){ } public static synchronized Singleton getInstance() { if (instance == null) { instance = new Singleton(); } return instance; } }
//写法一、懒汉式写法 public class Singleton { private static Singleton instance; //构造函数私有 private Singleton (){ } public static synchronized Singleton getInstance() { if (instance == null) { instance = new Singleton(); } return instance; } }
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
//写法二、DCL(Double Check Lock) 双重校验锁 public class Singleton { private volatile static Singleton singleton; private Singleton (){ } public static Singleton getSingleton() { if (singleton == null) { synchronized (Singleton.class) { if (singleton == null) { singleton = new Singleton(); } } } return singleton; } }
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
//写法三、静态内部类单例模式 public class Singleton { private Singleton (){ } public static final Singleton getInstance() { return SingletonHolder.INSTANCE; } private static class SingletonHolder { private static final Singleton INSTANCE = new Singleton(); } }
2.工厂方法模式
- 定义
定义一个用于创建对象的接口,让子类决定实例化哪一个类。
工厂方法模式分为三种:普通工厂模式,就是建立一个工厂类,对实现了同一接口的一些类进行实例的创建。多个工厂方法模式,是对普通工厂方法模式的改进,在普通工厂方法模式中,如果传递的字符串出错,则不能正确创建对象,而多个工厂方法模式是提供多个工厂方法,分别创建对象。静态工厂方法模式,将上面的多个工厂方法模式里的方法置为静态的,不需要创建实例,直接调用即可 .
(1)普通工厂模式
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
public interface Sender { public void Send(); } public class MailSender implements Sender { @Override public void Send() { System.out.println("this is mail sender!"); } } public class SmsSender implements Sender { @Override public void Send() { System.out.println("this is sms sender!"); } } public class SendFactory { public Sender produce(String type) { if ("mail".equals(type)) { return new MailSender(); } else if ("sms".equals(type)) { return new SmsSender(); } else { System.out.println("请输入正确的类型!"); return null; } } }
(2)多个工厂模式
该模式是对普通工厂方法模式的改进,在普通工厂方法模式中,如果传递的字符串出错,则不能正确创建对象,而多个工厂方法模式是提供多个工厂方法,分别创建对象。
public interface Sender { public void Send(); } public class MailSender implements Sender { @Override public void Send() { System.out.println("this is mail sender!"); } } public class SmsSender implements Sender { @Override public void Send() { System.out.println("this is sms sender!"); } } public class SendFactory { public Sender produce(String type) { if ("mail".equals(type)) { return new MailSender(); } else if ("sms".equals(type)) { return new SmsSender(); } else { System.out.println("请输入正确的类型!"); return null;
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
public class SendFactory { public Sender produceMail(){ return new MailSender(); } public Sender produceSms(){ return new SmsSender(); } } public class FactoryTest { public static void main(String[] args) { SendFactory factory = new SendFactory(); Sender sender = factory.produceMail(); sender.send(); } }
(3)静态工厂模式
静态工厂方法模式,将上面的多个工厂方法模式里的方法置为静态的,不需要创建实例,直接调用即可
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
public class SendFactory { public static Sender produceMail(){ return new MailSender(); } public static Sender produceSms(){ return new SmsSender(); } } public class FactoryTest { public static void main(String[] args) { Sender sender = SendFactory.produceMail(); sender.send(); } }
3.抽象工厂模式
工厂方法模式有一个问题就是,类的创建依赖工厂类,也就是说,如果想要拓展程序,必须对工厂类进行修改,这违背了闭包原则,所以,从设计角度考虑,有一定的问题,如何解决?就用到抽象工厂模式,创建多个工厂类,这样一旦需要增加新的功能, 直接增加新的工厂类就可以了,不需要修改之前的代码。
代码还是在工厂方法模式的基础上改进
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
public interface Provider { public Sender produce(); } ---------------------------------------------------------------------------- public interface Sender { public void send(); } ---------------------------------------------------------------------------- public class MailSender implements Sender { @Override public void send() { System.out.println("this is mail sender!"); } } --------------------------------------------------------------------------- public class SmsSender implements Sender { @Override public void send() { System.out.println("this is sms sender!"); } } --------------------------------------------------------- public class SendSmsFactory implements Provider { @Override public Sender produce() { return new SmsSender(); } } public class SendMailFactory implements Provider { @Override public Sender produce() { return new MailSender(); } } ------------------------------------------------------------- public class Test { public static void main(String[] args) { Provider provider = new SendMailFactory(); Sender sender = provider.produce(); sender.send(); } }
4.建造者模式(Builder )
工厂类模式提供的是创建单个类的模式,而建造者模式则是将各种产品集中起来进行管理,用来创建复合对象,所谓复合对象就是指某个类具有不同的属性,其实建造者模式就是前面抽象工厂模式和最后的 Test 结合起来得到的
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
public class Builder { private List<Sender> list = new ArrayList<Sender>(); public void produceMailSender(int count) { for (int i = 0; i < count; i++) { list.add(new MailSender()); } } public void produceSmsSender(int count) { for (int i = 0; i < count; i++) { list.add(new SmsSender()); } } }
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
public class TestBuilder { public static void main(String[] args) { Builder builder = new Builder(); builder.produceMailSender(10); } }
5.原型模式
- 定义
用原型实例指定创建对象的种类,并且通过拷贝这些原型创建新的对象。
- 简介
原型模式不难理解,它主要是用在实例创建的时候,因为有的时候我们通过new创建一个对象时可能成本过高,这时我们可以考虑直接通过直接克隆实例快速创建对象。克隆后的实例与原实例内部属性一致。原型模式需要注意一个深拷贝和浅拷贝的问题。
四.结构型模式(7种)
结构型模式关注类和对象的组合。继承的概念被用来组合接口和定义组合对象获得新功能的方式。![](https://img2018.cnblogs.com/blog/1408728/201904/1408728-20190411161531228-1079515249.png)
1.适配器设计模式
适配器模式将某个类的接口转换成客户端期望的另一个接口表示,目的是消除由于接口不匹配所造成的类的兼容性问题。主要分为三类:类的适配器模式、对象的适配器模式、接口的适配器模式
- 类的适配器模式
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
public class Source { public void method1() { System.out.println("this is original method!"); } } ------------------------------------------------------------- public interface Targetable { /* 与原类中的方法相同 */ public void method1(); /* 新类的方法 */ public void method2(); } public class Adapter extends Source implements Targetable { @Override public void method2() { System.out.println("this is the targetable method!"); } } public class AdapterTest { public static void main(String[] args) { Targetable target = new Adapter(); target.method1(); target.method2(); } }
- 对象的适配器模式
基本思路和类的适配器模式相同,只是将 Adapter 类作修改,这次不继承 Source 类,而是持有 Source 类的实例,以达到解决兼容性的问题
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
public class Wrapper implements Targetable { private Source source; public Wrapper(Source source) { super(); this.source = source; } @Override public void method2() { System.out.println("this is the targetable method!"); } @Override public void method1() { source.method1(); } } -------------------------------------------------------------- public class AdapterTest { public static void main(String[] args) { Source source = new Source(); Targetable target = new Wrapper(source); target.method1(); target.method2(); } }
- 接口的适配器模式
接口的适配器是这样的:有时我们写的一个接口中有多个抽象方法,当我们写该接口的实现类时,必须实现该接口的所有方法,这明显有时比较浪费,因为并不是所有的方法都是我们需要的,有时只需要某一些,此处为了解决这个问题,我们引入了接口的适配器模式,借助于一个抽象类,该抽象类实现了该接口,实现了所有的方法,而我们不和原始的接口打交道,只和该抽象类取得联系,所以我们写一个类,继承该抽象类,重写我们需要的方法就行。
2.桥接模式
- 定义
将抽象部分与实现部分分离,使它们都可以独立的变化。
- 简介
在软件系统中,某些类型由于自身的逻辑,它具有两个或多个维度的变化,那么如何应对这种“多维度的变化”?这就要使用桥接模式。桥接模式需要重点理解的抽象部分,实现部分,脱耦。一个典型的例子是咖啡加糖问题,抽象部分有Coffee,其下有LargeCoffee,SmallCoffee,实现部分是CoffeeAdd,其下有Sugar,Normal,抽象类Coffee中引用CoffeeAdd,这样CoffeeAdd其实就是一个桥接。查看更多
3.装饰模式
顾名思义,装饰模式就是给一个对象增加一些新的功能,而且是动态的,要求装饰对象和被装饰对象实现同一个 接口,装饰对象持有被装饰对象的实例。![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
public interface Sourceable { public void method(); } ---------------------------------------------------- public class Source implements Sourceable { @Override public void method() { System.out.println("the original method!"); } } ---------------------------------------------------- public class Decorator implements Sourceable { private Sourceable source; public Decorator(Sourceable source) { super(); this.source = source; } @Override public void method() { System.out.println("before decorator!"); source.method(); System.out.println("after decorator!"); } } ---------------------------------------------------- public class DecoratorTest { public static void main(String[] args) { Sourceable source = new Source(); Sourceable obj = new Decorator(source); obj.method(); } }
4.组合模式
- 定义
将对象组合成树形结构以表示“部分-整体”的层次结构,使得用户对单个对象和组合对象的使用具有一致性。
- 简介
组合模式理解起来相对简单,典型的例子就是假设公司A,里面有不同的部门,不同的部分下有不同的员工,这样一个部门下的所有员工组合成了一个部门,所有部门组合成了整个公司。
5.外观模式
- 定义
为子系统中的一组接口提供一个一致的界面,外观模式定义了一个高层接口,这个接口使得这一子系统更加容易使用。
- 简介
外观模式的一个典型例子是去医院看病,挂号、门诊、划价、取药,让患者或患者家属觉得很复杂,如果有提供接待人员,只让接待人员来处理,就很方便。点击查看更多
6.享元模式
- 定义
运用共享技术有效地支持大量细粒度的对象。
- 简介
在有大量对象时,有可能会造成内存溢出,我们把其中共同的部分抽象出来,如果有相同的业务请求,直接返回在内存中已有的对象,避免重新创建。点击查看更多
7.代理模式
- 定义
为其他对象提供一种代理以控制对这个对象的访问。
- 简介
代理模式主要解决在直接访问对象时带来的问题。举个例子,猪八戒去找高翠兰结果是孙悟空变的,可以这样理解:把高翠兰的外貌抽象出来,高翠兰本人和孙悟空都实现了这个接口,猪八戒访问高翠兰的时候看不出来这个是孙悟空,所以说孙悟空是高翠兰代理类。点击查看更多
五、行为型模式 ( 11种 )
这些设计模式特别关注对象之间的通信。
![](https://img2018.cnblogs.com/blog/1408728/201904/1408728-20190411162704221-1907481692.png)
1.模板方法模式
- 定义
一个操作中的算法的框架,而将一些步骤延迟到子类中,使得子类可以不改变一个算法的结构即可重定义该算法的某些特定步骤。
- 例子
模板方法模式一个典型例子就是Android中的异步任务类AsyncTask,它对异步任务的执行进行了流程封装,子类继承它时,只需在指定的流程中实现具体的操作即可。点击查看更多关于模板方法模式的介绍
2.命令模式
- 定义
将一个请求封装为一个对象,从而可用不同的请求对客户进行参数化;对请求排队或记录请求日志,以及支持可取消的操作
- 简介
命令模式主要是通过调用者调用接受者执行命令,这个模式中需要理解的是三个角色:(1) Receiver 真正的命令执行对象 (2) Command 持有一个对Receiver的引用,调用Receiver的相关方法。(3) Invoker 请求者,持有一个对Command的引用,调用Command的方法执行具体命令。点击查看更多关于命令模式的介绍
3.迭代器模式
- 定义
提供一种方法顺序访问一个聚合对象中各个元素, 而又不需暴露该对象的内部表示。
- 简介
在Java集合框架中我们知道对于一个指定的集合类,我们可以使用一个特定的Iterator迭代器来对集合中的所有元素进行遍历。这样结合来看,迭代器模式很好理解了。点击查看更多
4.观察者模式
- 定义
定义对象间的一种一对多的依赖关系,当一个对象的状态发生改变时,所有依赖于它的对象都得到通知并被自动更新。
- 简介
观察者模式可以结合Android中的ListView来理解,ListView关联的适配器Adapter在数据发生变化时会通过notifyDataSetChanged()方法来通知界面刷新。点击查看更多介绍
5.中介者模式
- 定义
用一个中介对象来封装一系列的对象交互。中介者使各对象不需要显式地相互引用,从而使其耦合松散,而且可以独立地改变它们之间的交互。
- 简介
中介者模式的典型例子就是未加入 WTO 之前各个国家相互贸易,结构复杂,大家都加入WTO后是各个国家通过 WTO 来互相贸易,变得规范。点击查看更多介绍
6.备忘录模式
- 定义
在不破坏封装性的前提下,捕获一个对象的内部状态,并在该对象之外保存这个状态。这样以后就可将该对象恢复到保存的状态。
- 简介
备忘录模式的典型例子就是git版本管理工具,它帮我们保存了每次提交后的项目状态,在必要的时候我们可以回退到指定的版本中。点击查看更多
7.解释器模式
- 定义
给定一个语言,定义它的文法的一种表示,并定义一个解释器,这个解释器使用该表示来解释语言中的句子。
- 简介
解释器的典型例子是在编译原理中的应用,如果一种特定类型的问题发生的频率足够高,那么可能就值得将该问题的各个实例表述为一个简单语言中的句子。这样就可以构建一个解释器,该解释器通过解释这些句子来解决该问题。点击查看更多
8.状态模式
- 定义
允许一个对象在其内部状态改变时改变它的行为。对象看起来似乎修改了它的类。
- 简介
状态模式主要解决对象的行为依赖于它的状态(属性),并且可以根据它的状态改变而改变它的相关行为。典型的例子是一个人在不同的状态下完成一件事的结果可能是不同的。点击查看更多
9.策略模式
- 定义
定义一系列的算法,把它们一个个封装起来, 并且使它们可相互替换。本模式使得算法可独立于使用它的客户而变化。
- 简介
从策略模式的定义可以看到它主要是将算法和客户独立开,一个典型的例子是排序算法,我们给定一个数组,输出排序后的结果,但是过程中我们可以采取不同的排序算法,这些算法其实就是策略。点击查看更多
10.责任链模式
- 定义
使多个对象都有机会处理请求,从而避免请求的发送者和接收者之间的耦合关系。将这些对象连成一条链,并沿着这条链传递该请求,直到有一个对象处理它为止。
- 简介
责任链模式,避免请求发送者与接收者耦合在一起,让多个对象都有可能接收请求,将这些对象连接成一条链,并且沿着这条链传递请求,直到有对象处理它为止。点击查看更多
11.访问者模式
- 定义
封装一些作用于某种数据结构中的各元素的操作。它使你可以在不改变各元素的类的前提下定义作用于这些元素的新操作。
- 简介
访问者模式是一种将数据操作和数据结构分离的设计模式,它通常使用在对象结构比较稳定,但是经常需要在此对象结构上定义新的操作,或者需要对一个对象结构中的对象进行很多不同的并且不相关的操作,而需要避免让这些操作"污染"这些对象的类,使用访问者模式将这些封装到类中。点击查看更多
六.总结
到这里,Java设计模式的学习总结就结束了,因为个人能力有限,有些模式只是简单介绍了一下,想要进一步学习的话还是要靠大家自己去查阅相关资料学习。熟练地掌握设计模式,还需多多的实践.