下载文档原格式
23种设计模式及应用设计模式是指在软件设计过程中，针对常见问题的解决方案的经验总结。
它们提供了解决特定或常见问题的可重用方案，使得软件设计更加灵活、可扩展和可维护。
1. 创建型模式：- 单例模式：确保一个类只有一个实例，并提供全局访问点。
- 简单工厂模式：通过一个共同的接口创建不同的对象实例。
- 工厂方法模式：定义一个创建对象的接口，由子类决定具体创建哪个对象。
- 抽象工厂模式：提供一个创建一系列相关或互相依赖对象的接口。
- 建造者模式：将一个复杂对象的构建与其表示分离，使得同样的构建过程可以创建不同的表示。
2. 结构型模式：- 适配器模式：将一个类的接口转换为客户端所期待的另一种接口。
- 桥接模式：将抽象部分与它的实现部分分离，使它们可以独立变化。
- 组合模式：将对象组合成树形结构以表示"整体-部分"的层次结构。
- 装饰器模式：动态地给对象添加额外的功能，避免继承带来的类膨胀问题。
- 外观模式：为子系统中一组接口提供一个一致的界面。
3. 行为型模式：- 策略模式：定义一系列算法，将它们封装起来，并使它们可以相互替换。
- 观察者模式：定义对象之间的依赖关系，当对象状态改变时自动通知依赖方。
- 模板方法模式：定义一个操作中的算法骨架，将一些步骤延迟到子类中实现。
- 命令模式：将一个请求封装成一个对象，从而使您可以用不同的请求参数化客户端对象。
- 状态模式：允许对象在其内部状态改变时改变其行为。
4. J2EE模式：- MVC模式：将应用程序划分为三个核心组件：模型、视图和控制器。
- 业务代表模式：将对业务对象的访问和业务逻辑从表示层分离出来。
- 数据访问对象模式：用于将业务逻辑和数据访问逻辑分离。
- 前端控制器模式：通过一个单一的入口点来处理应用程序的所有请求。
- 传输对象模式：用于在客户端和服务器之间传输数据。
5. 并发模式：- 线程池模式：创建一组预先初始化的线程对象来处理任务。
23种Java设计模式设计模式分两类：创建型模式、行为型模式。
一、创建型模式 :1、FACTORY—追MM少不了请吃饭了，麦当劳的鸡翅和肯德基的鸡翅都是MM爱吃的东西，虽然口味有所不同，但不管你带MM去麦当劳或肯德基，只管向服务员说“来四个鸡翅”就行了。
麦当劳和肯德基就是生产鸡翅的Factory1、工厂模式：客户类和工厂类分开。
消费者任何时候需要某种产品，只需向工厂请求即可。
消费者无须修改就可以接纳新产品。
缺点是当产品修改时，工厂类也要做相应的修改。
如：如何创建及如何向客户端提供。
2、BUILDER—MM最爱听的就是“我爱你”这句话了，见到不同地方的MM,要能够用她们的方言跟她说这句话哦，我有一个多种语言翻译机，上面每种语言都有一个按键，见到MM我只要按对应的键，它就能够用相应的语言说出“我爱你”这句话了，国外的MM也可以轻松搞掂，这就是我的“我爱你” builder。
（这一定比美军在伊拉克用的翻译机好卖）2、建造模式：将产品的内部表象和产品的生成过程分割开来，从而使一个建造过程生成具有不同的内部表象的产品对象。
建造模式使得产品内部表象可以独立的变化，客户不必知道产品内部组成的细节。
建造模式可以强制实行一种分步骤进行的建造过程。
3、FACTORY METHOD—请MM去麦当劳吃汉堡，不同的MM有不同的口味，要每个都记住是一件烦人的事情，我一般采用Factory Method模式，带着MM到服务员那儿，说“要一个汉堡”，具体要什么样的汉堡呢，让MM直接跟服务员说就行了。
3、工厂方法模式：核心工厂类不再负责所有产品的创建，而是将具体创建的工作交给子类去做，成为一个抽象工厂角色，仅负责给出具体工厂类必须实现的接口，而不接触哪一个产品类应当被实例化这种细节。
4、PROTOTYPE—跟MM用QQ聊天，一定要说些深情的话语了，我搜集了好多肉麻的情话，需要时只要copy出来放到QQ里面就行了，这就是我的情话prototype了。
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种设计模式分为三⼤类创建型模式（5种）：⼯⼚⽅法模式、抽象⼯⼚模式、单例模式、建造者模式、原型模式。
结构型模式（7种）：适配器模式、装饰器模式、代理模式、外观模式、桥接模式、组合模式、享元模式。
⾏为型模式（11种）：策略模式、模板⽅法模式、观察者模式、迭代⼦模式、责任链模式、命令模式、备忘录模式、状态模式、访问者模式、中介者模式、解释器模式。
⾯向对象编程（杂）所有编程初学者都会有这样的问题，就是碰到问题就直觉地⽤计算机能够理解的逻辑来描述和表达待解决问题及具体的求解过程，这其实是⽤计算机的⽅式去思考，⽐如计算器这个程序，先要求输⼊两个数和运算符号，然后根据运算符号判断如何运算，得到结果，这本⾝没有错，但这样的思维却使得我们的程序只为满⾜实现当前的需求，程序不容易维护，不容易扩展，更不容易复⽤。
从⽽达不到⾼质量代码的要求。
如何才能容易维护，容易扩展，⼜容易复⽤呢？例：活字印刷术：改：只需改相应字（可维护），创造出这些字⽤完以后就并⾮⽆⽤，完全可以在后来的印刷中重复使⽤（可复⽤），若要加字，只需另刻字即可（可扩展），同时实现了字体的横向摆放或纵向摆放问题（灵活性好），活字印刷是思想的成功，⾯向对象（将每个字当做⼀个对象来处理）的胜利。
⾯向对象编程设计思想：通过封装，继承，多态把程序的耦合度降低。
复制VS复⽤：编程有⼀原则，就是⽤尽可能的办法去避免重复，以计算器为例，我们可以让计算和显⽰分开（哪些与控制台相关，哪些与计算相关）（实际就是让业务逻辑和界⾯逻辑分开，让他们之间的耦合度下降，只有分离开，才可以容易达到维护和扩展。
）⾯向对象的编程，并不是类越多越好，类的划分是为了封装，但分类的基础是抽象，具有相同属性和功能的对象的抽象集合才是类。
例：打⼀折和打九折只是形式的不同，抽象分析出来，所有的打折算法都是⼀样的，所以打折算法应该是⼀个类。
23种设计模式详解设计模式是指面向对象编程中，经过多次验证、被广泛接受的代码实现方法。
这些设计模式可以帮助开发者更快地解决问题，提高代码的可读性、可维护性、可扩展性。
目前，常用的设计模式有23种。
下面，我们来详细介绍一下这23种设计模式。
1. 单例模式(Singleton)单例模式是一种只允许生成一个实例的模式。
在实例化对象时，单例模式的生成过程比较特殊，需要先判断该类是否已经实例化过，如果已经实例化，则直接返回已有的实例对象，否则再进行实例化。
2. 工厂模式(Factory)工厂模式是一种生产对象实例的设计模式。
它将对象实例的生成过程封装在一个工厂类中，客户端需要对象时，只需要调用工厂类中对应的方法即可。
3. 抽象工厂模式(Abstract Factory)抽象工厂模式是一种扩展了工厂模式的模式。
它可以生成一系列相关或相互依赖的对象实例。
具体实现时，通常需要定义一个抽象工厂类和一些具体工厂类，来生产各种相关的对象实例。
4. 建造者模式(Builder)建造者模式是一种用于构建复杂对象的模式。
它将一个复杂对象的构建过程分解成多个简单的步骤，然后通过一个指挥者来管理这些步骤的执行，最终构建出一个复杂的对象。
5. 原型模式(Prototype)原型模式是一种通过复制已有对象来创建新对象的模式。
一般来说，系统中的对象包含大量相同或相似的部分，通过复制对象可以帮助我们节省生成对象的时间和资源。
6. 适配器模式(Adapter)适配器模式是一种将不兼容接口转换为兼容接口的模式。
具体实现时，需要定义一个适配器类，该类实现了客户端所期望的接口，而且还包装了原有不兼容的接口，使其能够兼容客户端期望的接口。
7. 桥接模式(Bridge)桥接模式是一种将抽象部分与其实现部分分离开来的模式。
具体实现时，需要定义抽象部分和实现部分的接口，然后定义一个桥接类，将抽象部分和实现部分联系起来。
8. 组合模式(Composite)组合模式是一种将具有相同属性和方法的对象组合成树形结构的模式。
设计题编写代码比较使用迭代器遍历链表和使用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 + } }编写饿汉式和懒汉式单件模式示意代码，并说明这两种方式的适应性。
种设计模式及事例重点时辰，第一时间送到！个人Github-24 种设计模式事例链接种设计模式案例维导图创立型模式工厂模式工厂模式（FactoryPattern）是Java中最常用的设计模式之一。
这类种类的设计模式属于创立型模式，它供应了一种创立对象的最正确方式。
在工厂模式中，我们在创立对象时不会对客户端裸露创立逻辑，并且是经过使用一个共同的接口来指向新创立的对象。
介绍企图：定义一个创立对象的接口，让其子类自己决定实例化哪一个工厂类，工厂模式使其创立过程延缓到子类进行。
主要解决：主要解决接口选择的问题。
何时使用：我们明确地计划不一样条件下创立不一样实例时。
怎样解决：让其子类实现工厂接口，返回的也是一个抽象的产品。
重点代码：创立过程在其子类履行。
应用实例：1、您需要一辆汽车，能够直接从工厂里面提货，而不用去管这辆汽车是怎么做出来的，以及这个汽车里面的详细实现。
2、Hibernate换数据库只需换方言和驱动就能够。
长处：1、一个调用者想创立一个对象，只需知道其名称就能够了。
2、扩展性高，假如想增添一个产品，只需扩展一个工厂类就能够。
3、障蔽产品的详细实现，调用者只关怀产品的接口。
弊端：每次增添一个产品时，都需要增添一个详细类和对象实现工厂，使得系统中类的个数成倍增添，在必定程度上增添了系统的复杂度，同时也增添了系统详细类的依靠。
这其实不是什么好事。
使用处景：1、日记记录器：记录可能记录到当地硬盘、系统事件、远程服务器等，用户能够选择记录日记到什么地方。
2、数据库接见，当用户不知道最后系统采纳哪一类数据库，以及数据库可能有变化时。
3、设计一个连结服务器的框架，需要三个协议，'POP3'、'IMAP'、'HTTP'，能够把这三个作为产品类，共同实现一个接口。
注意事项：作为一种创立类模式，在任何需要生成复杂对象的地方，都能够使用工厂方法模式。
有一点需要注意的地方就是复杂对象适合使用工厂模式，而简单对象，特别是只需要经过new 就能够达成创立的对象，无需使用工厂模式。
设计题编写代码比较使用迭代器遍历链表和使用get(int index)方法遍历链表所有的时间。
mport java.util.*;public class TestSpeed {public static void main(String[] args) {LinkedList<String> list = new LinkedList<String>();for (int i = 0; i <= 60096; i++) {list.add("speed" + i);}Iterator<String> iter = list.iterator();long starttime = System.currentTimeMillis();while (iter.hasNext()) {String te = iter.next();}long endTime = System.currentTimeMillis();;long result = endTime - starttime;System.out.println("使用迭代遍历集合所用时间" + result + "毫秒");starttime = System.currentTimeMillis();for (int i = 0; i < list.size(); i++) {String te = list.get(i);}endTime = System.currentTimeMillis();result = endTime - starttime;System.out.println("使用get方法历集合所用时间" + result + "毫秒");}}编写饿汉式和懒汉式单件模式示意代码，并说明这两种方式的适应性。
（1）饿汉式：public class Singleton {private static Singleton unigueInstance = new Singleton();private Singleton() {}public static Singleton getInstance() {return unigueInstance;}}（2）懒汉式：public class Singleton {private static Singleton unigueInstance;private Singleton() {}public static synchronized Singleton getInstance() {if (unigueInstance == null) {unigueInstance = new Singleton();}return unigueInstance;}}以下你看到的类和接口是取自一个动作冒险游戏，它们代表游戏角色(Character)的类和角色可以使用的武器行为的类。
每个角色一次只能使用一种武器，但是可以在游戏的过程中换武器。
你的工作是使用策略模式实现该游戏的架构。
public abstract class Character {WeaponBehavior weapon;public void performWeapon() {eWeapon();}public abstract void fight();public void setWeaponBehavior(WeaponBehavior w) {this.weapon = w;}}public class Queen extends Character {public Queen() {weapon = new KnifeBehavior();}public void fight() {System.out.println("皇后在战斗。
");}}public class King extends Character {public King(){w eapon=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 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 { public void useWeapon() {System.out.println("使用斧头战斗！");}}public class SwordBehavior implements WeaponBehavior { public void useWeapon() {// TODO Auto-generated method stubSystem.out.println("使用宝剑战斗！");}}public class Game {public static void main(String[] args) {//King king=new King();Character king=new King();//显示谁在战斗king.fight();//使用武器king.performWeapon();//改变武器(对象)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型数据计算阶乘。
用户可以使用责任链计算任意整数的阶乘，类图如下所示。
注意：不够写可写到背面并注明public interface Handler {public abstract void compuerMultiply(String number);public abstract void setNextHandler(Handler handler);}public class UseInt implements Handler{private Handler handler;private int result=1;public void compuerMultiply(String number) {try{int n=Integer.parseInt(number);int i=1;while(i<=n){result=result*i;if(result<=0){System.out.println("超出我的能力范围，我计算不了");puerMultiply(number);return;}i++;}System.out.println(number+"的阶乘:"+result);}catch(NumberFormatException exp){System.out.println(exp.toString());}}public void setNextHandler(Handler handler) {this.handler=handler;}}public class UseLong implements Handler{private Handler handler;private long result=1;public void compuerMultiply(String number) {try{long n=Long.parseLong(number);long i=1;while(i<=n){result=result*i;if(result<=0){System.out.println("超出我的能力范围，我计算不了");puerMultiply(number);return;}i++;}System.out.println(number+"的阶乘:"+result);}catch(NumberFormatException exp){System.out.println(exp.toString());}}public void setNextHandler(Handler handler) {this.handler=handler;}}import java.math.BigInteger;public class UseBigInteger implements Handler{private Handler handler;private BigInteger result=new BigInteger("1");public void compuerMultiply(String number) {try{BigInteger n=new BigInteger(number);BigInteger ONE=new BigInteger("1");BigInteger i=ONE;while(pareTo(n)<=0){result=result.multiply(i);i=i.add(ONE);}System.out.println(number+"的阶乘:"+result);}catch(NumberFormatException exp){System.out.println(exp.toString());}}public void setNextHandler(Handler handler) {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){ puerMultiply(number);}public static void main(String args[]){Application application=new Application();application.createChain();application.reponseClient("32");}}。
