接口隔离原则——面向对象设计原则

接口隔离原则的定义

接口隔离原则的优点

接口隔离原则的实现方法

迪米特法则——面向对象设计原则

迪米特法则的定义

迪米特法则的优点

迪米特法则的实现方法

合成复用原则——面向对象设计原则

合成复用原则的定义

合成复用原则的重要性

合成复用原则的实现方法

创建型模式的特点和分类

单例模式（单例设计模式）详解

单例模式的定义与特点

单例模式的优点和缺点

单例模式的应用场景

单例模式的结构与实现

1. 单例模式的结构

单例模式的应用实例

单例模式的扩展

原型模式（原型设计模式）详解

原型模式的定义与特点

原型模式的结构与实现

原型模式的应用实例

原型模式的应用场景

原型模式的扩展

接口隔离原则——面向对象设计原则

面向对象设计原则除了开闭原则、里氏替换原则、依赖倒置原则和单一职责原则以外，还有接口隔离原则、迪米特法则和合成复用原则。本节将详细介绍接口隔离原则。

接口隔离原则的定义

接口隔离原则（Interface Segregation Principle，ISP）要求程序员尽量将臃肿庞大的接口拆分成更小的和更具体的接口，让接口中只包含客户感兴趣的方法。

2002 年罗伯特·C.马丁给“接口隔离原则”的定义是：客户端不应该被迫依赖于它不使用的方法（Clients should not be forced to depend on methods they do not use）。该原则还有另外一个定义：一个类对另一个类的依赖应该建立在最小的接口上（The dependency of one class to another one should depend on the smallest possible interface）。

以上两个定义的含义是：要为各个类建立它们需要的专用接口，而不要试图去建立一个很庞大的接口供所有依赖它的类去调用。

接口隔离原则和单一职责都是为了提高类的内聚性、降低它们之间的耦合性，体现了封装的思想，但两者是不同的：

单一职责原则注重的是职责，而接口隔离原则注重的是对接口依赖的隔离。
单一职责原则主要是约束类，它针对的是程序中的实现和细节；接口隔离原则主要约束接口，主要针对抽象和程序整体框架的构建。

接口隔离原则的优点

接口隔离原则是为了约束接口、降低类对接口的依赖性，遵循接口隔离原则有以下 5 个优点。

将臃肿庞大的接口分解为多个粒度小的接口，可以预防外来变更的扩散，提高系统的灵活性和可维护性。
接口隔离提高了系统的内聚性，减少了对外交互，降低了系统的耦合性。
如果接口的粒度大小定义合理，能够保证系统的稳定性；但是，如果定义过小，则会造成接口数量过多，使设计复杂化；如果定义太大，灵活性降低，无法提供定制服务，给整体项目带来无法预料的风险。
使用多个专门的接口还能够体现对象的层次，因为可以通过接口的继承，实现对总接口的定义。
能减少项目工程中的代码冗余。过大的大接口里面通常放置许多不用的方法，当实现这个接口的时候，被迫设计冗余的代码。

接口隔离原则的实现方法

在具体应用接口隔离原则时，应该根据以下几个规则来衡量。

接口尽量小，但是要有限度。一个接口只服务于一个子模块或业务逻辑。
为依赖接口的类定制服务。只提供调用者需要的方法，屏蔽不需要的方法。
了解环境，拒绝盲从。每个项目或产品都有选定的环境因素，环境不同，接口拆分的标准就不同深入了解业务逻辑。
提高内聚，减少对外交互。使接口用最少的方法去完成最多的事情。

下面以学生成绩管理程序为例介绍接口隔离原则的应用。

【例1】学生成绩管理程序。

分析：学生成绩管理程序一般包含插入成绩、删除成绩、修改成绩、计算总分、计算均分、打印成绩信息、査询成绩信息等功能，如果将这些功能全部放到一个接口中显然不太合理，正确的做法是将它们分别放在输入模块、统计模块和打印模块等 3 个模块中，其类图如图 1 所示。

package principle;public class ISPtest {public static void main(String[] args) {InputModule input = StuScoreList.getInputModule();CountModule count = StuScoreList.getCountModule();PrintModule print = StuScoreList.getPrintModule();input.insert();count.countTotalScore();print.printStuInfo();//print.delete();}
}//输入模块接口
interface InputModule {void insert();void delete();void modify();
}//统计模块接口
interface CountModule {void countTotalScore();void countAverage();
}//打印模块接口
interface PrintModule {void printStuInfo();void queryStuInfo();
}//实现类
class StuScoreList implements InputModule, CountModule, PrintModule {private StuScoreList() {}public static InputModule getInputModule() {return (InputModule) new StuScoreList();}public static CountModule getCountModule() {return (CountModule) new StuScoreList();}public static PrintModule getPrintModule() {return (PrintModule) new StuScoreList();}public void insert() {System.out.println("输入模块的insert()方法被调用！");}public void delete() {System.out.println("输入模块的delete()方法被调用！");}public void modify() {System.out.println("输入模块的modify()方法被调用！");}public void countTotalScore() {System.out.println("统计模块的countTotalScore()方法被调用！");}public void countAverage() {System.out.println("统计模块的countAverage()方法被调用！");}public void printStuInfo() {System.out.println("打印模块的printStuInfo()方法被调用！");}public void queryStuInfo() {System.out.println("打印模块的queryStuInfo()方法被调用！");}
}

程序的运行结果如下：

输入模块的insert()方法被调用！
统计模块的countTotalScore()方法被调用！
打印模块的printStuInfo()方法被调用！

迪米特法则——面向对象设计原则

前几节分别详细介绍了面向对象设计原则中的开闭原则、里氏替换原则、依赖倒置原则、单一职责原则和接口隔离原则，本节将详细介绍迪米特法则。

迪米特法则的定义

迪米特法则（Law of Demeter，LoD）又叫作最少知识原则（Least Knowledge Principle，LKP)，产生于 1987 年美国东北大学（Northeastern University）的一个名为迪米特（Demeter）的研究项目，由伊恩·荷兰（Ian Holland）提出，被 UML 创始者之一的布奇（Booch）普及，后来又因为在经典著作《程序员修炼之道》（The Pragmatic Programmer）提及而广为人知。

迪米特法则的定义是：只与你的直接朋友交谈，不跟“陌生人”说话（Talk only to your immediate friends and not to strangers）。其含义是：如果两个软件实体无须直接通信，那么就不应当发生直接的相互调用，可以通过第三方转发该调用。其目的是降低类之间的耦合度，提高模块的相对独立性。

迪米特法则中的“朋友”是指：当前对象本身、当前对象的成员对象、当前对象所创建的对象、当前对象的方法参数等，这些对象同当前对象存在关联、聚合或组合关系，可以直接访问这些对象的方法。

迪米特法则的优点

迪米特法则要求限制软件实体之间通信的宽度和深度，正确使用迪米特法则将有以下两个优点。

降低了类之间的耦合度，提高了模块的相对独立性。
由于亲合度降低，从而提高了类的可复用率和系统的扩展性。

但是，过度使用迪米特法则会使系统产生大量的中介类，从而增加系统的复杂性，使模块之间的通信效率降低。所以，在釆用迪米特法则时需要反复权衡，确保高内聚和低耦合的同时，保证系统的结构清晰。

迪米特法则的实现方法

从迪米特法则的定义和特点可知，它强调以下两点：

从依赖者的角度来说，只依赖应该依赖的对象。
从被依赖者的角度说，只暴露应该暴露的方法。

所以，在运用迪米特法则时要注意以下 6 点。

在类的划分上，应该创建弱耦合的类。类与类之间的耦合越弱，就越有利于实现可复用的目标。
在类的结构设计上，尽量降低类成员的访问权限。
在类的设计上，优先考虑将一个类设置成不变类。
在对其他类的引用上，将引用其他对象的次数降到最低。
不暴露类的属性成员，而应该提供相应的访问器（set 和 get 方法）。
谨慎使用序列化（Serializable）功能。

【例1】明星与经纪人的关系实例。

分析：明星由于全身心投入艺术，所以许多日常事务由经纪人负责处理，如与粉丝的见面会，与媒体公司的业务洽淡等。这里的经纪人是明星的朋友，而粉丝和媒体公司是陌生人，所以适合使用迪米特法则，其类图如图 1 所示。

package principle;public class LoDtest {public static void main(String[] args) {Agent agent = new Agent();agent.setStar(new Star("林心如"));agent.setFans(new Fans("粉丝韩丞"));agent.setCompany(new Company("中国传媒有限公司"));agent.meeting();agent.business();}
}//经纪人
class Agent {private Star myStar;private Fans myFans;private Company myCompany;public void setStar(Star myStar) {this.myStar = myStar;}public void setFans(Fans myFans) {this.myFans = myFans;}public void setCompany(Company myCompany) {this.myCompany = myCompany;}public void meeting() {System.out.println(myFans.getName() + "与明星" + myStar.getName() + "见面了。");}public void business() {System.out.println(myCompany.getName() + "与明星" + myStar.getName() + "洽淡业务。");}
}//明星
class Star {private String name;Star(String name) {this.name = name;}public String getName() {return name;}
}//粉丝
class Fans {private String name;Fans(String name) {this.name = name;}public String getName() {return name;}
}//媒体公司
class Company {private String name;Company(String name) {this.name = name;}public String getName() {return name;}
}

程序的运行结果如下：

粉丝韩丞与明星林心如见面了。
中国传媒有限公司与明星林心如洽淡业务。

合成复用原则——面向对象设计原则

合成复用原则是面向对象设计原则的 7 条原则中剩下的最后一条，下面我们将对其进行详细地介绍。

合成复用原则的定义

合成复用原则（Composite Reuse Principle，CRP）又叫组合/聚合复用原则（Composition/Aggregate Reuse Principle，CARP）。它要求在软件复用时，要尽量先使用组合或者聚合等关联关系来实现，其次才考虑使用继承关系来实现。

如果要使用继承关系，则必须严格遵循里氏替换原则。合成复用原则同里氏替换原则相辅相成的，两者都是开闭原则的具体实现规范。

合成复用原则的重要性

通常类的复用分为继承复用和合成复用两种，继承复用虽然有简单和易实现的优点，但它也存在以下缺点。

继承复用破坏了类的封装性。因为继承会将父类的实现细节暴露给子类，父类对子类是透明的，所以这种复用又称为“白箱”复用。
子类与父类的耦合度高。父类的实现的任何改变都会导致子类的实现发生变化，这不利于类的扩展与维护。
它限制了复用的灵活性。从父类继承而来的实现是静态的，在编译时已经定义，所以在运行时不可能发生变化。

采用组合或聚合复用时，可以将已有对象纳入新对象中，使之成为新对象的一部分，新对象可以调用已有对象的功能，它有以下优点。

它维持了类的封装性。因为成分对象的内部细节是新对象看不见的，所以这种复用又称为“黑箱”复用。
新旧类之间的耦合度低。这种复用所需的依赖较少，新对象存取成分对象的唯一方法是通过成分对象的接口。
复用的灵活性高。这种复用可以在运行时动态进行，新对象可以动态地引用与成分对象类型相同的对象。

合成复用原则的实现方法

合成复用原则是通过将已有的对象纳入新对象中，作为新对象的成员对象来实现的，新对象可以调用已有对象的功能，从而达到复用。

下面以汽车分类管理程序为例来介绍合成复用原则的应用。

【例1】汽车分类管理程序。

分析：汽车按“动力源”划分可分为汽油汽车、电动汽车等；按“颜色”划分可分为白色汽车、黑色汽车和红色汽车等。如果同时考虑这两种分类，其组合就很多。图 1 所示是用继承关系实现的汽车分类的类图。

从图 1 可以看出用继承关系实现会产生很多子类，而且增加新的“动力源”或者增加新的“颜色”都要修改源代码，这违背了开闭原则，显然不可取。但如果改用组合关系实现就能很好地解决以上问题，其类图如图 2 所示。

结合前几节的内容，我们一共介绍了 7 种设计原则，它们分别为开闭原则、里氏替换原则、依赖倒置原则、单一职责原则、接口隔离原则、迪米特法则和合成复用原则。

这 7 种设计原则是软件设计模式必须尽量遵循的原则，是设计模式的基础。在实际开发过程中，并不是一定要求所有代码都遵循设计原则，而是要综合考虑人力、时间、成本、质量，不刻意追求完美，要在适当的场景遵循设计原则。这体现的是一种平衡取舍，可以帮助我们设计出更加优雅的代码结构。

各种原则要求的侧重点不同，下面我们分别用一句话归纳总结软件设计模式的七大原则，如下表所示。

设计原则	一句话归纳	目的
开闭原则	对扩展开放，对修改关闭	降低维护带来的新风险
依赖倒置原则	高层不应该依赖低层，要面向接口编程	更利于代码结构的升级扩展
单一职责原则	一个类只干一件事，实现类要单一	便于理解，提高代码的可读性
接口隔离原则	一个接口只干一件事，接口要精简单一	功能解耦，高聚合、低耦合
迪米特法则	不该知道的不要知道，一个类应该保持对其它对象最少的了解，降低耦合度	只和朋友交流，不和陌生人说话，减少代码臃肿
里氏替换原则	不要破坏继承体系，子类重写方法功能发生改变，不应该影响父类方法的含义	防止继承泛滥
合成复用原则	尽量使用组合或者聚合关系实现代码复用，少使用继承	降低代码耦合

实际上，这些原则的目的只有一个：降低对象之间的耦合，增加程序的可复用性、可扩展性和可维护性。

记忆口诀：访问加限制，函数要节俭，依赖不允许，动态加接口，父类要抽象，扩展不更改。

在程序设计时，我们应该将程序功能最小化，每个类只干一件事。若有类似功能基础之上添加新功能，则要合理使用继承。对于多方法的调用，要会运用接口，同时合理设置接口功能与数量。最后类与类之间做到低耦合高内聚。

创建型模式的特点和分类

创建型模式的主要关注点是“怎样创建对象？”，它的主要特点是“将对象的创建与使用分离”。这样可以降低系统的耦合度，使用者不需要关注对象的创建细节，对象的创建由相关的工厂来完成。就像我们去商场购买商品时，不需要知道商品是怎么生产出来一样，因为它们由专门的厂商生产。

创建型模式分为以下几种。

单例（Singleton）模式：某个类只能生成一个实例，该类提供了一个全局访问点供外部获取该实例，其拓展是有限多例模式。
原型（Prototype）模式：将一个对象作为原型，通过对其进行复制而克隆出多个和原型类似的新实例。
工厂方法（FactoryMethod）模式：定义一个用于创建产品的接口，由子类决定生产什么产品。
抽象工厂（AbstractFactory）模式：提供一个创建产品族的接口，其每个子类可以生产一系列相关的产品。
建造者（Builder）模式：将一个复杂对象分解成多个相对简单的部分，然后根据不同需要分别创建它们，最后构建成该复杂对象。

以上 5 种创建型模式，除了工厂方法模式属于类创建型模式，其他的全部属于对象创建型模式，我们将在之后的教程中详细地介绍它们的特点、结构与应用。

单例模式（单例设计模式）详解

在有些系统中，为了节省内存资源、保证数据内容的一致性，对某些类要求只能创建一个实例，这就是所谓的单例模式。

单例模式的定义与特点

单例（Singleton）模式的定义：指一个类只有一个实例，且该类能自行创建这个实例的一种模式。例如，Windows 中只能打开一个任务管理器，这样可以避免因打开多个任务管理器窗口而造成内存资源的浪费，或出现各个窗口显示内容的不一致等错误。

在计算机系统中，还有 Windows 的回收站、操作系统中的文件系统、多线程中的线程池、显卡的驱动程序对象、打印机的后台处理服务、应用程序的日志对象、数据库的连接池、网站的计数器、Web 应用的配置对象、应用程序中的对话框、系统中的缓存等常常被设计成单例。

单例模式在现实生活中的应用也非常广泛，例如公司 CEO、部门经理等都属于单例模型。J2EE 标准中的 ServletContext 和 ServletContextConfig、Spring 框架应用中的 ApplicationContext、数据库中的连接池等也都是单例模式。

单例模式有 3 个特点：

单例类只有一个实例对象；
该单例对象必须由单例类自行创建；
单例类对外提供一个访问该单例的全局访问点。

单例模式的优点和缺点

单例模式的优点：

单例模式可以保证内存里只有一个实例，减少了内存的开销。
可以避免对资源的多重占用。
单例模式设置全局访问点，可以优化和共享资源的访问。

单例模式的缺点：

单例模式一般没有接口，扩展困难。如果要扩展，则除了修改原来的代码，没有第二种途径，违背开闭原则。
在并发测试中，单例模式不利于代码调试。在调试过程中，如果单例中的代码没有执行完，也不能模拟生成一个新的对象。
单例模式的功能代码通常写在一个类中，如果功能设计不合理，则很容易违背单一职责原则。

单例模式看起来非常简单，实现起来也非常简单。单例模式在面试中是一个高频面试题。希望大家能够认真学习，掌握单例模式，提升核心竞争力，给面试加分，顺利拿到 Offer。

单例模式的应用场景

对于 Java 来说，单例模式可以保证在一个 JVM 中只存在单一实例。单例模式的应用场景主要有以下几个方面。

需要频繁创建的一些类，使用单例可以降低系统的内存压力，减少 GC。
某类只要求生成一个对象的时候，如一个班中的班长、每个人的身份证号等。
某些类创建实例时占用资源较多，或实例化耗时较长，且经常使用。
某类需要频繁实例化，而创建的对象又频繁被销毁的时候，如多线程的线程池、网络连接池等。
频繁访问数据库或文件的对象。
对于一些控制硬件级别的操作，或者从系统上来讲应当是单一控制逻辑的操作，如果有多个实例，则系统会完全乱套。
当对象需要被共享的场合。由于单例模式只允许创建一个对象，共享该对象可以节省内存，并加快对象访问速度。如 Web 中的配置对象、数据库的连接池等。

单例模式的结构与实现

单例模式是设计模式中最简单的模式之一。通常，普通类的构造函数是公有的，外部类可以通过“new 构造函数()”来生成多个实例。但是，如果将类的构造函数设为私有的，外部类就无法调用该构造函数，也就无法生成多个实例。这时该类自身必须定义一个静态私有实例，并向外提供一个静态的公有函数用于创建或获取该静态私有实例。

下面来分析其基本结构和实现方法。

1. 单例模式的结构

单例模式的主要角色如下。

单例类：包含一个实例且能自行创建这个实例的类。
访问类：使用单例的类。

其结构如图 1 所示。

public class LazySingleton {private static volatile LazySingleton instance = null;    //保证 instance 在所有线程中同步private LazySingleton() {}    //private 避免类在外部被实例化public static synchronized LazySingleton getInstance() {//getInstance 方法前加同步if (instance == null) {instance = new LazySingleton();}return instance;}
}

注意：如果编写的是多线程程序，则不要删除上例代码中的关键字 volatile 和 synchronized，否则将存在线程非安全的问题。如果不删除这两个关键字就能保证线程安全，但是每次访问时都要同步，会影响性能，且消耗更多的资源，这是懒汉式单例的缺点。

第 2 种：饿汉式单例

该模式的特点是类一旦加载就创建一个单例，保证在调用 getInstance 方法之前单例已经存在了。

public class HungrySingleton {private static final HungrySingleton instance = new HungrySingleton();private HungrySingleton() {}public static HungrySingleton getInstance() {return instance;}
}

饿汉式单例在类创建的同时就已经创建好一个静态的对象供系统使用，以后不再改变，所以是线程安全的，可以直接用于多线程而不会出现问题。

单例模式的应用实例

【例1】用懒汉式单例模式模拟产生美国当今总统对象。

分析：在每一届任期内，美国的总统只有一人，所以本实例适合用单例模式实现，图 2 所示是用懒汉式单例实现的结构图。

public class SingletonLazy {public static void main(String[] args) {President zt1 = President.getInstance();zt1.getName();    //输出总统的名字President zt2 = President.getInstance();zt2.getName();    //输出总统的名字if (zt1 == zt2) {System.out.println("他们是同一人！");} else {System.out.println("他们不是同一人！");}}
}class President {private static volatile President instance = null;    //保证instance在所有线程中同步//private避免类在外部被实例化private President() {System.out.println("产生一个总统！");}public static synchronized President getInstance() {//在getInstance方法上加同步if (instance == null) {instance = new President();} else {System.out.println("已经有一个总统，不能产生新总统！");}return instance;}public void getName() {System.out.println("我是美国总统：特朗普。");}
}

程序运行结果如下：

产生一个总统！
我是美国总统：特朗普。
已经有一个总统，不能产生新总统！
我是美国总统：特朗普。
他们是同一人！

【例2】用饿汉式单例模式模拟产生猪八戒对象。

分析：同上例类似，猪八戒也只有一个，所以本实例同样适合用单例模式实现。本实例由于要显示猪八戒的图像（点此下载该程序所要显示的猪八戒图片），所以用到了框架窗体 JFrame 组件，这里的猪八戒类是单例类，可以将其定义成面板 JPanel 的子类，里面包含了标签，用于保存猪八戒的图像，客户窗体可以获得猪八戒对象，并显示它。图 3 所示是用饿汉式单例实现的结构图。

import java.awt.*;
import javax.swing.*;public class SingletonEager {public static void main(String[] args) {JFrame jf = new JFrame("饿汉单例模式测试");jf.setLayout(new GridLayout(1, 2));Container contentPane = jf.getContentPane();Bajie obj1 = Bajie.getInstance();contentPane.add(obj1);Bajie obj2 = Bajie.getInstance();contentPane.add(obj2);if (obj1 == obj2) {System.out.println("他们是同一人！");} else {System.out.println("他们不是同一人！");}jf.pack();jf.setVisible(true);jf.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);}
}class Bajie extends JPanel {private static Bajie instance = new Bajie();private Bajie() {JLabel l1 = new JLabel(new ImageIcon("src/Bajie.jpg"));this.add(l1);}public static Bajie getInstance() {return instance;}
}

程序运行结果如图 4 所示。

单例模式的扩展

单例模式可扩展为有限的多例（Multitcm）模式，这种模式可生成有限个实例并保存在 ArrayList 中，客户需要时可随机获取，其结构图如图 5 所示。

原型模式（原型设计模式）详解

在有些系统中，存在大量相同或相似对象的创建问题，如果用传统的构造函数来创建对象，会比较复杂且耗时耗资源，用原型模式生成对象就很高效，就像孙悟空拔下猴毛轻轻一吹就变出很多孙悟空一样简单。

原型模式的定义与特点

原型（Prototype）模式的定义如下：用一个已经创建的实例作为原型，通过复制该原型对象来创建一个和原型相同或相似的新对象。在这里，原型实例指定了要创建的对象的种类。用这种方式创建对象非常高效，根本无须知道对象创建的细节。例如，Windows 操作系统的安装通常较耗时，如果复制就快了很多。在生活中复制的例子非常多，这里不一一列举了。

原型模式的优点：

Java 自带的原型模式基于内存二进制流的复制，在性能上比直接 new 一个对象更加优良。
可以使用深克隆方式保存对象的状态，使用原型模式将对象复制一份，并将其状态保存起来，简化了创建对象的过程，以便在需要的时候使用（例如恢复到历史某一状态），可辅助实现撤销操作。

原型模式的缺点：

需要为每一个类都配置一个 clone 方法
clone 方法位于类的内部，当对已有类进行改造的时候，需要修改代码，违背了开闭原则。
当实现深克隆时，需要编写较为复杂的代码，而且当对象之间存在多重嵌套引用时，为了实现深克隆，每一层对象对应的类都必须支持深克隆，实现起来会比较麻烦。因此，深克隆、浅克隆需要运用得当。

原型模式的结构与实现

由于 Java 提供了对象的 clone() 方法，所以用 Java 实现原型模式很简单。

1. 模式的结构

原型模式包含以下主要角色。

抽象原型类：规定了具体原型对象必须实现的接口。
具体原型类：实现抽象原型类的 clone() 方法，它是可被复制的对象。
访问类：使用具体原型类中的 clone() 方法来复制新的对象。

其结构图如图 1 所示。

2. 模式的实现

原型模式的克隆分为浅克隆和深克隆。

浅克隆：创建一个新对象，新对象的属性和原来对象完全相同，对于非基本类型属性，仍指向原有属性所指向的对象的内存地址。
深克隆：创建一个新对象，属性中引用的其他对象也会被克隆，不再指向原有对象地址。

Java 中的 Object 类提供了浅克隆的 clone() 方法，具体原型类只要实现 Cloneable 接口就可实现对象的浅克隆，这里的 Cloneable 接口就是抽象原型类。其代码如下：

//具体原型类
class Realizetype implements Cloneable {Realizetype() {System.out.println("具体原型创建成功！");}public Object clone() throws CloneNotSupportedException {System.out.println("具体原型复制成功！");return (Realizetype) super.clone();}
}//原型模式的测试类
public class PrototypeTest {public static void main(String[] args) throws CloneNotSupportedException {Realizetype obj1 = new Realizetype();Realizetype obj2 = (Realizetype) obj1.clone();System.out.println("obj1==obj2?" + (obj1 == obj2));}
}

程序的运行结果如下：

具体原型创建成功！
具体原型复制成功！
obj1==obj2?false

原型模式的应用实例

【例1】用原型模式模拟“孙悟空”复制自己。

分析：孙悟空拔下猴毛轻轻一吹就变出很多孙悟空，这实际上是用到了原型模式。这里的孙悟空类 SunWukong 是具体原型类，而 Java 中的 Cloneable 接口是抽象原型类。

同前面介绍的猪八戒实例一样，由于要显示孙悟空的图像（点击此处下载该程序所要显示的孙悟空的图片），所以将孙悟空类定义成面板 JPanel 的子类，里面包含了标签，用于保存孙悟空的图像。

另外，重写了 Cloneable 接口的 clone() 方法，用于复制新的孙悟空。访问类可以通过调用孙悟空的 clone() 方法复制多个孙悟空，并在框架窗体 JFrame 中显示。图 2 所示是其结构图。

import java.awt.*;
import javax.swing.*;class SunWukong extends JPanel implements Cloneable {private static final long serialVersionUID = 5543049531872119328L;public SunWukong() {JLabel l1 = new JLabel(new ImageIcon("src/Wukong.jpg"));this.add(l1);}public Object clone() {SunWukong w = null;try {w = (SunWukong) super.clone();} catch (CloneNotSupportedException e) {System.out.println("拷贝悟空失败!");}return w;}
}public class ProtoTypeWukong {public static void main(String[] args) {JFrame jf = new JFrame("原型模式测试");jf.setLayout(new GridLayout(1, 2));Container contentPane = jf.getContentPane();SunWukong obj1 = new SunWukong();contentPane.add(obj1);SunWukong obj2 = (SunWukong) obj1.clone();contentPane.add(obj2);jf.pack();jf.setVisible(true);jf.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);}
}

程序的运行结果如图 3 所示。

用原型模式除了可以生成相同的对象，还可以生成相似的对象，请看以下实例。

【例2】用原型模式生成“三好学生”奖状。

分析：同一学校的“三好学生”奖状除了获奖人姓名不同，其他都相同，属于相似对象的复制，同样可以用原型模式创建，然后再做简单修改就可以了。图 4 所示是三好学生奖状生成器的结构图。

public class ProtoTypeCitation {public static void main(String[] args) throws CloneNotSupportedException {citation obj1 = new citation("张三", "同学：在2016学年第一学期中表现优秀，被评为三好学生。", "韶关学院");obj1.display();citation obj2 = (citation) obj1.clone();obj2.setName("李四");obj2.display();}
}//奖状类
class citation implements Cloneable {String name;String info;String college;citation(String name, String info, String college) {this.name = name;this.info = info;this.college = college;System.out.println("奖状创建成功！");}void setName(String name) {this.name = name;}String getName() {return (this.name);}void display() {System.out.println(name + info + college);}public Object clone() throws CloneNotSupportedException {System.out.println("奖状拷贝成功！");return (citation) super.clone();}
}

程序运行结果如下：

奖状创建成功！
张三同学：在2016学年第一学期中表现优秀，被评为三好学生。韶关学院
奖状拷贝成功！
李四同学：在2016学年第一学期中表现优秀，被评为三好学生。韶关学院

原型模式的应用场景

原型模式通常适用于以下场景。

对象之间相同或相似，即只是个别的几个属性不同的时候。
创建对象成本较大，例如初始化时间长，占用CPU太多，或者占用网络资源太多等，需要优化资源。
创建一个对象需要繁琐的数据准备或访问权限等，需要提高性能或者提高安全性。
系统中大量使用该类对象，且各个调用者都需要给它的属性重新赋值。

在 Spring 中，原型模式应用的非常广泛，例如 scope='prototype'、JSON.parseObject() 等都是原型模式的具体应用。

原型模式的扩展

原型模式可扩展为带原型管理器的原型模式，它在原型模式的基础上增加了一个原型管理器 PrototypeManager 类。该类用 HashMap 保存多个复制的原型，Client 类可以通过管理器的 get(String id) 方法从中获取复制的原型。其结构图如图 5 所示。

【例3】用带原型管理器的原型模式来生成包含“圆”和“正方形”等图形的原型，并计算其面积。分析：本实例中由于存在不同的图形类，例如，“圆”和“正方形”，它们计算面积的方法不一样，所以需要用一个原型管理器来管理它们，图 6 所示是其结构图。

import java.util.*;interface Shape extends Cloneable {public Object clone();    //拷贝public void countArea();    //计算面积
}class Circle implements Shape {public Object clone() {Circle w = null;try {w = (Circle) super.clone();} catch (CloneNotSupportedException e) {System.out.println("拷贝圆失败!");}return w;}public void countArea() {int r = 0;System.out.print("这是一个圆，请输入圆的半径：");Scanner input = new Scanner(System.in);r = input.nextInt();System.out.println("该圆的面积=" + 3.1415 * r * r + "\n");}
}class Square implements Shape {public Object clone() {Square b = null;try {b = (Square) super.clone();} catch (CloneNotSupportedException e) {System.out.println("拷贝正方形失败!");}return b;}public void countArea() {int a = 0;System.out.print("这是一个正方形，请输入它的边长：");Scanner input = new Scanner(System.in);a = input.nextInt();System.out.println("该正方形的面积=" + a * a + "\n");}
}class ProtoTypeManager {private HashMap<String, Shape> ht = new HashMap<String, Shape>();public ProtoTypeManager() {ht.put("Circle", new Circle());ht.put("Square", new Square());}public void addshape(String key, Shape obj) {ht.put(key, obj);}public Shape getShape(String key) {Shape temp = ht.get(key);return (Shape) temp.clone();}
}public class ProtoTypeShape {public static void main(String[] args) {ProtoTypeManager pm = new ProtoTypeManager();Shape obj1 = (Circle) pm.getShape("Circle");obj1.countArea();Shape obj2 = (Shape) pm.getShape("Square");obj2.countArea();}
}

运行结果如下所示：

这是一个圆，请输入圆的半径：3
该圆的面积=28.2735这是一个正方形，请输入它的边长：3
该正方形的面积=9

今日先更新到这我们下期再见了。

java设计模式（13-19节）相关推荐

JAVA设计模式（19）：行为型-观察者模式（Observer）
观察者模式是设计模式中的"超级模式",其应用随处可见,在之后几篇文章里,我将向大家详细介绍观察者模式. "红灯停,绿灯行",在日常生活中,交通信号灯装点着我们 ...
【java设计模式】-00目录
开篇 [java设计模式]-01设计模式简介创建型模式: [java设计模式]-02工厂模式(Factory Pattern) [java设计模式]-03抽象工厂模式(Abstract Factor ...
Java设计模式（16）中介模式（Mediator模式）
Mediator定义:用一个中介对象来封装一系列关于对象交互行为. 为何使用Mediator模式/中介模式各个对象之间的交互操作非常多,每个对象的行为操作都依赖彼此对方,修改一个对象的行为,同时会涉 ...
Java设计模式（7）装饰模式（Decorator模式）
Decorator常被翻译成"装饰",我觉得翻译成"油漆工"更形象点,油漆工(decorator)是用来刷油漆的,那么被刷油漆的对象我们称decoratee.这 ...
Java设计模式（1）工厂模式（Factory模式）
工厂模式定义:提供创建对象的接口. 为何使用工厂模式工厂模式是我们最常用的模式了,著名的Jive论坛,就大量使用了工厂模式,工厂模式在Java程序系统可以说是随处可见. 为什么工厂模式是如此常用?因 ...
Java设计模式（8）组合模式（Composite模式）
Composite定义:将对象以树形结构组织起来,以达成"部分-整体" 的层次结构,使得客户端对单个对象和组合对象的使用具有一致性. Composite比较容易理解,想到Compo ...
Java设计模式（10）代理模式（Proxy模式）
理解并使用设计模式,能够培养我们良好的面向对象编程习惯,同时在实际应用中,可以如鱼得水,享受游刃有余的乐趣. Proxy是比较有用途的一种模式,而且变种较多,应用场合覆盖从小结构到整个系统的大结构,P ...
Java设计模式（疯狂Java联盟版）
目录(?)[+] 1. 设计模式.................................................................................... ...
常见的java设计模式详解
常见的java设计模式详解 1. 根据目的来分 2 GoF的23种设计模式的功能 3.下面介绍几种常见的模式单例(Singleton)模式前言 1)单例(Singleton)模式的定义 2)特点 ...

java设计模式（13-19节）

接口隔离原则——面向对象设计原则

接口隔离原则的定义

接口隔离原则的优点

接口隔离原则的实现方法

迪米特法则——面向对象设计原则

迪米特法则的定义

迪米特法则的优点

迪米特法则的实现方法

合成复用原则——面向对象设计原则

合成复用原则的定义

合成复用原则的重要性

合成复用原则的实现方法

创建型模式的特点和分类

单例模式（单例设计模式）详解

单例模式的定义与特点

单例模式的优点和缺点

单例模式的应用场景

单例模式的结构与实现

1. 单例模式的结构

单例模式的应用实例

单例模式的扩展

原型模式（原型设计模式）详解

原型模式的定义与特点

原型模式的结构与实现

原型模式的应用实例

原型模式的应用场景

原型模式的扩展

java设计模式（13-19节）相关推荐

最新文章

热门文章