下载文档原格式
创建型1。
Factory Method（工厂方法）2。
Abstract Factory(抽象工厂）3。
Builder（建造者）4. Prototype（原型）5。
Singleton（单例)结构型6。
Adapter Class/Object(适配器）7. Bridge(桥接）8. Composite（组合）9. Decorator(装饰）10。
Facade(外观）11. Flyweight（享元)12. Proxy（代理）行为型13. Interpreter（解释器）14。
Template Method（模板方法)15。
Chain of Responsibility（责任链）16. Command（命令)17. Iterator（迭代器）18. Mediator(中介者)19。
Memento(备忘录)20. Observer（观察者）21。
State(状态）22。
Strategy（策略）23. Visitor(访问者）创建型1.Factory Method（工厂方法）FactoryMethod.uml定义一个用于创建对象的接口，让子类决定实例化哪一个类。
Factory Method 使一个类的实例化延迟到其子类。
适用性：当一个类不知道它所必须创建的对象的类的时候.当一个类希望由它的子类来指定它所创建的对象的时候。
当类将创建对象的职责委托给多个帮助子类中的某一个，并且你希望将哪一个帮助子类是代理者这一信息局部化的时候。
2.Abstract Factory（抽象工厂)意图:提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。
适用性：一个系统要独立于它的产品的创建、组合和表示时。
一个系统要由多个产品系列中的一个来配置时。
当你要强调一系列相关的产品对象的设计以便进行联合使用时.当你提供一个产品类库,而只想显示它们的接口而不是实现时。
3.Builder（建造者)意图：将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。
设计模式总结一、设计原则1、单一职责原则一个类，只有一个引起它变化的缘由。
应当只有一个职责。
每一个职责都是变化的一个轴线，假设一个类有一个以上的职责，这些职责就耦合在了一起。
这会导致脆弱的设计。
当一个职责发生变化时，可能会影响其它的职责。
另外，多个职责耦合在一起，会影响复用性。
例如：要实现规律和界面的分别。
from：百度百科2、开闭原则〔Open Close Principle〕开闭原则就是说对扩开放放，对修改关闭。
在程序需要进展拓展的时候，不能去修改原有的代码，实现一个热插拔的效果。
所以一句话概括就是：为了使程序的扩展性好，易于维护和升级。
想要到达这样的效果，我们需要使用接口和抽象类，后面的具体设计中我们会提到这点。
3、里氏代换原则〔Liskov Substitution Principle〕里氏代换原则(Liskov Substitution Principle LSP)面对对象设计的根本原则之一。
里氏代换原则中说，任何基类可以消灭的地方，子类肯定可以消灭。
L SP 是继承复用的基石，只有当衍生类可以替换掉基类，软件单位的功能不受到影响时，基类才能真正被复用，而衍生类也能够在基类的根底上增加的行为。
里氏代换原则是对“开-闭”原则的补充。
实现“开-闭”原则的关键步骤就是抽象化。
而基类与子类的继承关系就是抽象化的具体实现，所以里氏代换原则是对实现抽象化的具体步骤的标准。
from：百度百科4、依靠倒转原则〔Dependence Inversion Principle〕所谓依靠倒置原则〔Dependence Inversion Principle〕就是要依靠于抽象，不要依靠于具体。
简洁的说就是要求对抽象进展编程，不要对实现进展编程，这样就降低了客户与实现模块间的耦合。
实现开闭原则的关键是抽象化，并且从抽象化导出具体化实现，假设说开闭原则是面对对象设计的目标的话，那么依靠倒转原则就是面对对象设计的主要手段。
24种设计模式及案例设计模式是软件工程中经过验证的解决其中一类常见问题的可复用设计的描述。
它们提供了一套经过验证的最佳实践，可以帮助开发人员解决各种设计问题，并提高代码的可维护性、重用性和灵活性。
本文将介绍24种常见的设计模式，并为每种模式提供一个案例，以便更好地理解和应用这些设计模式。
1.创建型模式：- 简单工厂模式（Simple Factory Pattern）：通过一个工厂类根据输入参数的不同来创建不同类的对象。
- 工厂方法模式（Factory Method Pattern）：定义一个创建对象的接口，但让子类决定实例化哪一个类。
- 抽象工厂模式（Abstract Factory Pattern）：提供一个创建一系列相关或相互依赖对象的接口，而无需指定具体的类。
- 单例模式（Singleton Pattern）：确保一个类只有一个实例，并提供一个全局的访问点来获取该实例。
2.结构型模式：- 适配器模式（Adapter Pattern）：将不兼容的接口转换为可兼容的接口，以便不同类之间可以协同工作。
- 装饰器模式（Decorator Pattern）：动态地给一个对象添加一些额外的职责，而不需要修改原始类的代码。
- 代理模式（Proxy Pattern）：为其他对象提供一种代理以控制对该对象的访问。
- 外观模式（Facade Pattern）：提供了一个简化接口，用于使用一组复杂子系统的更高级别接口。
3.行为型模式：- 策略模式（Strategy Pattern）：定义一系列算法，将每个算法封装起来，并使它们可以互相替换。
- 观察者模式（Observer Pattern）：定义了对象之间的一对多依赖关系，当一个对象的状态发生变化时，其所有依赖对象都会收到通知并自动更新。
- 模板方法模式（Template Method Pattern）：定义了一个操作的算法框架，而将一些步骤的实现延迟到子类中。
23种设计模式范文设计模式是软件开发中常用的解决方案模式，它们代表了在面对特定问题时的最佳实践和经验总结。
设计模式可以帮助我们更好地组织和设计代码，提高代码的可读性、可维护性和可扩展性。
在本文中，我们将介绍23种常用的设计模式，并分别讨论它们的实现原理和在实际开发中的应用场景。
1. 单例模式（Singleton Pattern）单例模式是最简单的设计模式之一，它确保一个类只有一个实例，并提供一个全局访问点。
在实现上，可以通过将构造函数私有化，然后提供一个静态方法返回实例来实现单例。
应用场景：在需要实现全局唯一访问点的场景下，比如线程池、配置管理器等。
2. 工厂模式（Factory Pattern）工厂模式是用来创建对象的一种模式，它将对象的创建和实现分离，使得代码更易于维护和扩展。
工厂模式有简单工厂模式、工厂方法模式和抽象工厂模式等几种不同的变体。
应用场景：在需要根据不同条件创建不同对象的场景下，比如数据库连接、日志记录等。
3. 抽象工厂模式（Abstract Factory Pattern）抽象工厂模式是工厂模式的一种扩展，它提供一个创建一系列相关或相互依赖对象的接口，而无需指定实际的类。
抽象工厂模式将一组工厂类封装起来，使其可以交换或者替换。
应用场景：在需要创建一组相关对象（如界面主题、操作系统等）并且需要保持一致性的场景下。
4. 建造者模式（Builder Pattern）建造者模式是用来生成复杂对象的一种模式，它将对象的构建与其表现分离，采用逐步构建的方式生成对象，可以让客户端不需要知道具体的构建细节。
应用场景：在构造过程比较复杂，需要多个组件协同工作的场景下，比如构建复杂的UI界面。
5. 原型模式（Prototype Pattern）原型模式是用来克隆对象的一种模式，它通过复制已有对象的原型来创建新的对象，避免了通过构造函数创建对象和初始化成员变量的重复过程。
应用场景：在需要创建大量相似对象或者初始化成本较高的对象时，可以使用原型模式。
23种设计模式详解设计模式是指面向对象编程中，经过多次验证、被广泛接受的代码实现方法。
这些设计模式可以帮助开发者更快地解决问题，提高代码的可读性、可维护性、可扩展性。
目前，常用的设计模式有23种。
下面，我们来详细介绍一下这23种设计模式。
1. 单例模式(Singleton)单例模式是一种只允许生成一个实例的模式。
在实例化对象时，单例模式的生成过程比较特殊，需要先判断该类是否已经实例化过，如果已经实例化，则直接返回已有的实例对象，否则再进行实例化。
2. 工厂模式(Factory)工厂模式是一种生产对象实例的设计模式。
它将对象实例的生成过程封装在一个工厂类中，客户端需要对象时，只需要调用工厂类中对应的方法即可。
3. 抽象工厂模式(Abstract Factory)抽象工厂模式是一种扩展了工厂模式的模式。
它可以生成一系列相关或相互依赖的对象实例。
具体实现时，通常需要定义一个抽象工厂类和一些具体工厂类，来生产各种相关的对象实例。
4. 建造者模式(Builder)建造者模式是一种用于构建复杂对象的模式。
它将一个复杂对象的构建过程分解成多个简单的步骤，然后通过一个指挥者来管理这些步骤的执行，最终构建出一个复杂的对象。
5. 原型模式(Prototype)原型模式是一种通过复制已有对象来创建新对象的模式。
一般来说，系统中的对象包含大量相同或相似的部分，通过复制对象可以帮助我们节省生成对象的时间和资源。
6. 适配器模式(Adapter)适配器模式是一种将不兼容接口转换为兼容接口的模式。
具体实现时，需要定义一个适配器类，该类实现了客户端所期望的接口，而且还包装了原有不兼容的接口，使其能够兼容客户端期望的接口。
7. 桥接模式(Bridge)桥接模式是一种将抽象部分与其实现部分分离开来的模式。
具体实现时，需要定义抽象部分和实现部分的接口，然后定义一个桥接类，将抽象部分和实现部分联系起来。
8. 组合模式(Composite)组合模式是一种将具有相同属性和方法的对象组合成树形结构的模式。
种设计模式及事例重点时辰，第一时间送到！个人Github-24 种设计模式事例链接种设计模式案例维导图创立型模式工厂模式工厂模式（FactoryPattern）是Java中最常用的设计模式之一。
这类种类的设计模式属于创立型模式，它供应了一种创立对象的最正确方式。
在工厂模式中，我们在创立对象时不会对客户端裸露创立逻辑，并且是经过使用一个共同的接口来指向新创立的对象。
介绍企图：定义一个创立对象的接口，让其子类自己决定实例化哪一个工厂类，工厂模式使其创立过程延缓到子类进行。
主要解决：主要解决接口选择的问题。
何时使用：我们明确地计划不一样条件下创立不一样实例时。
怎样解决：让其子类实现工厂接口，返回的也是一个抽象的产品。
重点代码：创立过程在其子类履行。
应用实例：1、您需要一辆汽车，能够直接从工厂里面提货，而不用去管这辆汽车是怎么做出来的，以及这个汽车里面的详细实现。
2、Hibernate换数据库只需换方言和驱动就能够。
长处：1、一个调用者想创立一个对象，只需知道其名称就能够了。
2、扩展性高，假如想增添一个产品，只需扩展一个工厂类就能够。
3、障蔽产品的详细实现，调用者只关怀产品的接口。
弊端：每次增添一个产品时，都需要增添一个详细类和对象实现工厂，使得系统中类的个数成倍增添，在必定程度上增添了系统的复杂度，同时也增添了系统详细类的依靠。
这其实不是什么好事。
使用处景：1、日记记录器：记录可能记录到当地硬盘、系统事件、远程服务器等，用户能够选择记录日记到什么地方。
2、数据库接见，当用户不知道最后系统采纳哪一类数据库，以及数据库可能有变化时。
3、设计一个连结服务器的框架，需要三个协议，'POP3'、'IMAP'、'HTTP'，能够把这三个作为产品类，共同实现一个接口。
注意事项：作为一种创立类模式，在任何需要生成复杂对象的地方，都能够使用工厂方法模式。
有一点需要注意的地方就是复杂对象适合使用工厂模式，而简单对象，特别是只需要经过new 就能够达成创立的对象，无需使用工厂模式。
24种设计模式及案例图标放到了最后⾯思维导图创建型模式⼯⼚模式⼯⼚模式（Factory Pattern）是 Java 中最常⽤的设计模式之⼀。
这种类型的设计模式属于创建型模式，它提供了⼀种创建对象的最佳⽅式。
在⼯⼚模式中，我们在创建对象时不会对客户端暴露创建逻辑，并且是通过使⽤⼀个共同的接⼝来指向新创建的对象。
介绍意图：定义⼀个创建对象的接⼝，让其⼦类⾃⼰决定实例化哪⼀个⼯⼚类，⼯⼚模式使其创建过程延迟到⼦类进⾏。
主要解决：主要解决接⼝选择的问题。
何时使⽤：我们明确地计划不同条件下创建不同实例时。
如何解决：让其⼦类实现⼯⼚接⼝，返回的也是⼀个抽象的产品。
关键代码：创建过程在其⼦类执⾏。
应⽤实例： 1、您需要⼀辆汽车，可以直接从⼯⼚⾥⾯提货，⽽不⽤去管这辆汽车是怎么做出来的，以及这个汽车⾥⾯的具体实现。
2、Hibernate 换数据库只需换⽅⾔和驱动就可以。
优点： 1、⼀个调⽤者想创建⼀个对象，只要知道其名称就可以了。
2、扩展性⾼，如果想增加⼀个产品，只要扩展⼀个⼯⼚类就可以。
3、屏蔽产品的具体实现，调⽤者只关⼼产品的接⼝。
缺点：每次增加⼀个产品时，都需要增加⼀个具体类和对象实现⼯⼚，使得系统中类的个数成倍增加，在⼀定程度上增加了系统的复杂度，同时也增加了系统具体类的依赖。
这并不是什么好事。
使⽤场景： 1、⽇志记录器：记录可能记录到本地硬盘、系统事件、远程服务器等，⽤户可以选择记录⽇志到什么地⽅。
2、数据库访问，当⽤户不知道最后系统采⽤哪⼀类数据库，以及数据库可能有变化时。
3、设计⼀个连接服务器的框架，需要三个协议，"POP3"、"IMAP"、"HTTP"，可以把这三个作为产品类，共同实现⼀个接⼝。
注意事项：作为⼀种创建类模式，在任何需要⽣成复杂对象的地⽅，都可以使⽤⼯⼚⽅法模式。
有⼀点需要注意的地⽅就是复杂对象适合使⽤⼯⼚模式，⽽简单对象，特别是只需要通过 new 就可以完成创建的对象，⽆需使⽤⼯⼚模式。
24种设计模式Factory Pattern(⼯⼚模式)：1. 创建对象的接⼝，封装对象的创建；2. 使具体化类的⼯作延迟到⼦类中。
（维护⼀类对象）AbstractFactory Pattern(抽象⼯⼚模型)：该模式将⼀组对象的创建封装到⼀个⽤于创建对象的类中。
（解决的问题：要创建⼀组或者相互依赖的对象）。
Singleton Pattern(单例模式)：该模式在⾯向纯粹的⾯向对象的范式中⽤于创建唯⼀的实例，值得注意的是Singleton不能被实例化，因此将其构造函数声明为protected或private类型。
Singleton Pattern经常与Factory Pattern结合使⽤，因为Factory对象只能有⼀个。
Builder Pattern(创建者模式)：将⼀个复杂的对象的构建与它的表⽰分离，使得同样的构建构成可以创建不同的表⽰。
如建筑师画图纸，⽽⼯⼈建造房屋。
Prototype Pattern(原型模式)：提供⼀个通过已存在对象进⾏新对象创建的接⼝（clone）。
（浅拷贝和深拷贝）Bridge Pattern(桥梁模式)：将抽象部分与实现部分分开实现，使他们都可以独⽴地变化，并使⽤组合的⽅式将多维度的抽象⽅法联系在⼀起。
⽐如咖啡分⼩杯、中杯、⼤杯以及加奶和不加奶，则抽象部分为：⼩杯、中杯、⼤杯，⾏为为：加奶和不加奶。
Adapter Pattern(适配器模式)：适配就是由“源”到“⽬标”的适配，⽽当中链接两者的关系就是适配器。
它负责把“源”过度到“⽬标”。
将⼀个类的接⼝转换成客户希望的另外⼀个接⼝。
Adapter模式使得原本由于接⼝不兼容⽽不能⼀起⼯作的那些类可以⼀起⼯作。
适配器模式分为两种：①⾯向类的设计模式；②⾯向对象的设计模式。
①⾯向类的适配器：该模式使⽤继承和接⼝实现的⽅式复⽤需要适配器的类。
②⾯向对象的适配器：该模式使⽤组合的⽅式实现需要复⽤的类。
Decorator模式（装饰模式）：动态地给⼀个对象添加⼀些额外的职责。
23种设计模式详解设计模式是软件工程中的一种经验总结或优秀实践的规范化形式，它提供了在特定情境中解决特定问题的解决方案。
设计模式可以帮助开发人员更好地应对复杂的软件设计和开发过程中遇到的挑战，并提供了一种通用且可重用的方法来解决这些问题。
下面将详细介绍23种常见的设计模式：1. 单例模式(Singleton Pattern)单例模式确保类只能有一个实例，并提供全局访问该实例的接口。
2. 简单工厂模式(Simple Factory Pattern)简单工厂模式通过一个工厂类来封装对象的创建过程，实现了对象的创建与使用的解耦。
3. 工厂方法模式(Factory Method Pattern)工厂方法模式定义了一个用于创建对象的接口，由子类决定实例化哪个类。
4. 抽象工厂模式(Abstract Factory Pattern)抽象工厂模式提供一个接口，用于创建相关或依赖对象的家族，而不需要指定具体实现类。
5. 建造者模式(Builder Pattern)建造者模式将一个复杂对象的构建过程与其表示相分离，使得同样的构建过程可以创建不同的表示。
6. 原型模式(Prototype Pattern)原型模式通过复制现有对象来创建新的对象，避免了通过类的构造函数创建新对象的过程。
7. 适配器模式(Adapter Pattern)适配器模式将一个类的接口转换成客户希望的另一个接口，使得原本由于接口不兼容而不能在一起工作的类可以一起工作。
8. 桥接模式(Bridge Pattern)桥接模式将抽象部分与它的实现部分分离，使得它们可以独立地变化。
9. 装饰者模式(Decorator Pattern)装饰者模式动态地给一个对象添加一些额外的职责，而不需要子类化扩展该对象。
组合模式将对象组合成树形结构，并使得用户对单个对象和组合对象的使用具有一致性。
11. 外观模式(Facade Pattern)外观模式提供一个统一的接口，用于访问子系统中的一群接口。
23种设计模式范文设计模式是用来解决软件设计中的常见问题的经验总结和最佳实践。
这些模式抽象了实际应用中的问题，并提供了相应的解决方案。
本文将介绍23种经典的设计模式，并简要描述它们的用途和示例。
1.创建型模式-单例模式：保证一个类只有一个实例，并提供一个全局访问点。
-工厂模式：将对象的创建委托给工厂类，隐藏具体实现细节。
-抽象工厂模式：提供一个用于创建一系列相关或相互依赖对象的接口。
-建造者模式：将一个复杂对象的构建与其表示分离，使得同样的构建过程可以创建不同的表示。
-原型模式：通过复制已有对象来创建新对象，避免了直接创建对象的开销。
2.结构型模式-适配器模式：将一个类的接口转换成客户希望的另一个接口。
-桥接模式：将抽象部分与其实现部分相分离，使它们可以独立变化。
-组合模式：将对象组合成树形结构以表示"部分-整体"的层次结构。
-装饰者模式：动态地给对象添加额外的职责，同时又不改变其结构。
-外观模式：为复杂子系统提供一个简化的接口。
-享元模式：通过共享对象来实现对大量细粒度对象的有效共享。
3.行为型模式-模板方法模式：定义一个操作中的算法框架，将一些步骤的具体实现延迟到子类中。
-命令模式：将一个请求封装为一个对象，从而使你可以用不同的请求对客户进行参数化。
-迭代器模式：提供一种方法顺序访问一个聚合对象中的各个元素，而又不暴露其内部表示。
-观察者模式：定义对象之间的一对多依赖关系，当一个对象状态改变时，所有依赖它的对象都会得到通知。
-中介者模式：用一个中介对象封装一系列对象的交互，使各对象不需要显示地相互引用。
-备忘录模式：在不破坏封装性的前提下，捕获一个对象的内部状态，并在该对象之外保存这个状态。
-解释器模式：给定一个语言，定义它的语法的一种表示，并定义一个解释器来解释该语言中的句子。
-状态模式：允许对象在其内部状态改变时改变它的行为。
-空对象模式：使用一个空对象来代替NULL对象的检查。
23种设计模式详解原⽂链接:/zhangerqing⼀、设计模式的分类总体来说设计模式分为三⼤类：创建型模式，共五种：⼯⼚⽅法模式、抽象⼯⼚模式、单例模式、建造者模式、原型模式。
结构型模式，共七种：适配器模式、装饰器模式、代理模式、外观模式、桥接模式、组合模式、享元模式。
⾏为型模式，共⼗⼀种：策略模式、模板⽅法模式、观察者模式、迭代⼦模式、责任链模式、命令模式、备忘录模式、状态模式、访问者模式、中介者模式、解释器模式。
其实还有两类：并发型模式和线程池模式。
⽤⼀个图⽚来整体描述⼀下：⼆、设计模式的六⼤原则总原则：开闭原则（Open Close Principle）开闭原则就是说对扩展开放，对修改关闭。
在程序需要进⾏拓展的时候，不能去修改原有的代码，⽽是要扩展原有代码，实现⼀个热插拔的效果。
所以⼀句话概括就是：为了使程序的扩展性好，易于维护和升级。
想要达到这样的效果，我们需要使⽤接⼝和抽象类等，后⾯的具体设计中我们会提到这点。
1、单⼀职责原则不要存在多于⼀个导致类变更的原因，也就是说每个类应该实现单⼀的职责，如若不然，就应该把类拆分。
2、⾥⽒替换原则（Liskov Substitution Principle）⾥⽒替换原则中，⼦类对⽗类的⽅法尽量不要重写和重载。
因为⽗类代表了定义好的结构，通过这个规范的接⼝与外界交互，⼦类不应该随便破坏它。
3、依赖倒置原则（Dependence Inversion Principle）这个是开闭原则的基础，具体内容：⾯向接⼝编程，依赖于抽象⽽不依赖于具体。
写代码时⽤到具体类时，不与具体类交互，⽽与具体类的上层接⼝交互。
4、接⼝隔离原则（Interface Segregation Principle）这个原则的意思是：每个接⼝中不存在⼦类⽤不到却必须实现的⽅法，如果不然，就要将接⼝拆分。
使⽤多个隔离的接⼝，⽐使⽤单个接⼝（多个接⼝⽅法集合到⼀个的接⼝）要好。
5、迪⽶特法则（最少知道原则）（Demeter Principle）就是说：⼀个类对⾃⼰依赖的类知道的越少越好。
23种设计模式介绍与6大设计原则下载提示：该文档是本店铺精心编制而成的，希望大家下载后，能够帮助大家解决实际问题。
文档下载后可定制修改，请根据实际需要进行调整和使用，谢谢！本店铺为大家提供各种类型的实用资料，如教育随笔、日记赏析、句子摘抄、古诗大全、经典美文、话题作文、工作总结、词语解析、文案摘录、其他资料等等，想了解不同资料格式和写法，敬请关注！Download tips: This document is carefully compiled by this editor. I hope that after you download it, it can help you solve practical problems. The document can be customized and modified after downloading, please adjust and use it according to actual needs, thank you! In addition, this shop provides you with various types of practical materials, such as educational essays, diary appreciation, sentence excerpts, ancient poems, classic articles, topic composition, work summary, word parsing, copy excerpts, other materials and so on, want to know different data formats and writing methods, please pay attention!23种设计模式介绍与6大设计原则一、设计模式介绍。
设计题编写代码比较使用迭代器遍历链表和使用get(i nt in dex) 方法遍历链表所有的时间。
mport java.util.*;public class TestSpeed {public static void main( Stri ng[] args) {Lin kedList<Stri ng> list = new Lin kedList<Stri ng>();for ( int i = 0; i <= 60096; i++) {list.add( "speed" + i);}IteratorvStri ng> iter = list.iterator();long starttime = System. curre ntTimeMillis ();while (iter.hasNext()) {Stri ng te = iter. next();}long en dTime = System. curre ntTimeMillis ();long result = en dTime - starttime;System. out .println( "使用迭代遍历集合所用时间"+ result +starttime = System. curre ntTimeMillis ();for (int i = 0; i < list.size(); i++) {Stri ng te = list.get(i);}en dTime = System. curre ntTimeMillis ();result = en dTime - starttime;System. out .println( "使用get方法历集合所用时间"+ result + } }编写饿汉式和懒汉式单件模式示意代码，并说明这两种方式的适应性。
(1)饿汉式：public class Sin glet on {private static Sin glet on uni gue In sta nee = new Sin glet on();private Sin glet on() {}public static Sin glet on get In sta nce() {retur n uni gue In sta nee ;}}(2 )懒汉式：public class Sin glet on {private static Sin glet on uni gue In sta nee ;private Sin glet on() {}public static syn chro ni zed Sin glet on get In sta nce() {if ( unigueInstanee == null ) {"毫秒“); "毫秒“);}retur n uni gue In sta nee ;} }以下你看到的类和接口是取自一个动作冒险游戏，它们代表游戏角色 (Character)的类和角 色可以使用的武器行为的类。
每个角色一次只能使用一种武器， 但是可以在游戏的过程中换武器。
你的工作是使用策略模式实现该游戏的架构。
setj ：?on(Wetjpf3nBeh4v: iof w)(this,we^DOjn ■1Jpublic abstract class Character {Weapon Behavior weapon ; public void performWeap on() {weapon .useWeapon(); }public abstract void fight();public void setWeap on Behavior(Weap on Behavior w) { this . weapon = w; } }public classQuee n exte nds Character {publicQuee n() {weap on = new Kni feBehavior(); }public void fight() {System. out .println( "皇后在战斗。
");} }public class Kingexte ndsCharacter { public Kin g(){uni gue In sta neenew Sin glet on();Kfiife BehaviorBiOwAndArrowBeh^vicr「实区 HI T Mccin.t (wfara>3iL__________颐脑Apo 矶TnMIAxeBehjiviar ■Tta 钟(］广实班用聲虽____ Cftjfacta rweapon =new SwordBehavior();}public void fight() {System. out .println( " 国王在战斗。
" ); }public class Troll extends Character { public Troll() {weapon = new BowAndArrowBehavior();public void fight() {System. out .println( " 妖怪在战斗。
" ); }}public class Knight extends Character { public Knight() {weapon = new AxeBehavior();}public void fight() {System. out .println( " 骑士在战斗。
" ); }}public interface WeaponBehavior {public void useWeapon();public void useWeapon() { System. out .println(}}public class SwordBehaviorpublic//void useWeapon() {TODO Auto-generated method stub}public class Game {public static void main(String[] args) {//King king=new King(); Character king= new King(); // 显示谁在战斗 king.fight(); // 使用武器 king.performWeapon();public class KnifeBehavior implements WeaponBehavior {public void useWeapon() { System. out .println( " 使用匕首战斗！ " );}}public class BowAndArrowBehavior implements WeaponBehavior {public void useWeapon() {System. out .println( " 使用弓箭战斗！ " ); }}public class AxeBehavior implements WeaponBehavior {使用斧头战斗！ " );implements WeaponBehavior {System. out .println( 使用宝剑战斗！" );// 改变武器( 对象)king.setWeaponBehavior( new KnifeBehavior()); // 再次使用武器king.performWeapon();System. out .println( "\n 另一个角色" );Character troll= new Troll();//Troll troll=new Troll();troll.fight();troll.performWeapon();troll.setWeaponBehavior( new SwordBehavior());troll.performWeapon();}}使用责任链模式计算阶乘，设计要求：a. 设计一个类，该类使用int 型数据计算阶乘。
b. 设计一个类，该类使用long 型数据计算阶乘。
c. 设计一个类，该类使用BigInteger 型数据计算阶乘。
使用责任链模式将上述对象组成一个责任链，要求责任链上对象的顺序是：首先使用int 型数据计算阶乘，然后使用long 型数据计算阶乘，最后使用BigInteger 型数据计算阶乘。
用户可以使用责任链计算任意整数的阶乘，类图如下所示。
注意：不够写可写到背面并注明result =result *i; if (result <=0){System. out .println( "超岀我的能力范围，我计算不了 han dler .compuerMultiply (n umber);return ; } i++; }System. out .println(number+"的阶乘："+result );}catch (NumberFormatExceptio n exp){ System. out .println(exp.toString()); } }public voidsetNextHa ndler(Ha ndler han dler) {this} .handler =ha ndler;} publicclassprivateUseLong Han dlerimpleme nts han dler ;Han dler{private long result =1;public void compuerMultiply(Stri ng n umber) {public abstract void compuerMultiply(Str ing n umber); public abstract }public class Uselntvoid setNextHa ndler(Ha ndler han dler);impleme nts Han dler{private private Han dler han dlerintresult =1;publictry void compuerMultiply(Stri ng n umber) { {int n=ln teger. parse Int(n umber);i=1;while (i<=n){ int);public in terface Han dler {try {long n=Long. parseL ong (n umber);long i=1;while (i<=n){result =result *i;if (result <=0){System. out .println( ”超岀我的能力范围，我计算不了");han dler .compuerMultiply (n umber);return ;}i++;}System. out .println(number+ "的阶乘："+result );}catch (NumberFormatExceptio n exp){System. out .println(exp.toString());}}public void setNextHa ndler(Ha ndler han dler) {this . handler =handler;}}import java.math.Bigl nteger;public class UseBigI nteger impleme nts Han dler{private Han dler han dler ;private BigInteger result =new BigInteger( "1");public void compuerMultiply(Stri ng n umber) {try {Big In teger n= new Big In teger (n umber);BigInteger ONE= new BigInteger( "1");BigI nteger i=ONE;while (pareTo (n)<=0){result =result .multiply(i);i=i.add(ONE);}System. out .println(number+ "的阶乘:"+result );}catch (NumberFormatExceptio n exp){System. out .println(exp.toString());}}public void setNextHa ndler(Ha ndler han dler) {this . handler =handler;}public class Application {private Handler useInt , useLong , useBig ; public void createChain(){ useInt =new UseInt();useLong =new UseLong();useBig =new UseBigInteger(); useInt .setNextHandler( useLong );useLong .setNextHandler( useBig );}public void reponseClient(String number){useInt .compuerMultiply(number);}public static void main(String args[]){ Application application= new Application();application.createChain();application.reponseClient( "32" );}}。
