java设计模式示例
java最常用的六种设计模式及举例
java最常用的六种设计模式及举例设计模式是在软件开发过程中经验总结的一种编码和设计方式，它们可以帮助我们更好地组织代码，提高代码的可维护性和可复用性。
下面是 Java 中最常用的六种设计模式及其举例：1. 单例模式：单例模式确保一个类只有一个实例，并提供一个全局访问点。
典型的例子是 `ng.Runtime` 类，在整个 JVM 中只有一个运行时实例。
2. 工厂模式：工厂模式通过一个工厂类来创建其他类的对象，将对象的创建和使用分离，降低了代码的耦合度。
比如，`java.util.Calendar` 类使用了工厂模式来创建 `Calendar` 对象，其中的 `getInstance()` 方法返回一个 `Calendar` 实例。
3. 观察者模式：观察者模式定义了对象之间的一对多的依赖关系，当一个对象状态发生改变时，其相关依赖对象会收到通知并自动更新。
一个典型的例子是使用 `java.util.Observable` 类和 `java.util.Observer`接口进行监听和通知。
4. 装饰者模式：装饰者模式通过动态地将新功能附加到对象上，为对象提供了灵活的扩展方式，不需要修改原始对象的结构。
比如，`java.io` 包中的各种装饰者类可以用来扩展输入输出功能。
5. 策略模式：策略模式定义了一组算法，并将每个算法封装到可互换的对象中，使得算法的变化不会影响到使用算法的客户端。
一个常见的例子是使用 `parator` 接口来实现不同的比较策略。
6. 适配器模式：适配器模式将一个类的接口转换成客户端所期望的另一个接口，使得原本不兼容的类可以一起工作。
比如，`java.util.Arrays` 类中的 `asList()` 方法返回的是一个适配器，可以将数组转换成 List。
通过学习这些设计模式，我们可以更好地组织和设计代码，提高代码的可读性和可维护性。
在实际的开发中，我们可以针对具体的需求选择合适的设计模式，并根据需要进行一定的修改和定制。
java最常用的六种设计模式及举例
java最常用的六种设计模式及举例
1. 单例模式（Singleton Pattern）：保证一个类只有一个实例，并提供一个全局访问点。
例如，数据库连接池的设计使用了单例模式。
2. 工厂模式（Factory Pattern）：通过使用工厂方法来创建对象，而不是直接调用构造函数，从而实现封装和解耦的目的。
例如，Java中的Calendar类的getInstance()方法返回一个Calendar对象。
3. 观察者模式（Observer Pattern）：定义对象间的一种一对多的依赖关系，当一个对象的状态改变时，所有依赖于它的对象都会自动接收到通知并更新。
例如，Java中的事件处理机制，使用了观察者模式。
4. 装饰者模式（Decorator Pattern）：动态地给一个对象添加一些额外的职责，同时又不改变其结构。
例如，Java IO中的InputStream类是一个抽象类，而以其为基础的FileInputStream 类和BufferedInputStream类则是具体的装饰者。
5. 适配器模式（Adapter Pattern）：将一个类的接口转换成客户希望的另外一个接口。
例如，Java中的Collections类中的方法Arrays.asList()可以将数组转换为List类型。
6. 策略模式（Strategy Pattern）：封装一系列的算法，使得它们可以互相替换，而不影响使用它们的客户端。
例如，Java中
的Comparator接口和Comparable接口，用于定义排序算法的策略。
java几种常用设计模式简单示例
java⼏种常⽤设计模式简单⽰例1.单例设计模式所谓单例设计模式简单说就是⽆论程序如何运⾏，采⽤单例设计模式的类（Singleton类）永远只会有⼀个实例化对象产⽣。
具体实现步骤如下：(1) 将采⽤单例设计模式的类的构造⽅法私有化（采⽤private修饰）。
(2) 在其内部产⽣该类的实例化对象，并将其封装成private static类型。
(3) 定义⼀个静态⽅法返回该类的实例。
⽰例代码如下：class Singleton {private static Singleton instance = new Singleton();// 在内部产⽣本类的实例化对象public static Singleton getInstance() { // 通过静态⽅法返回instance对象return instance;}private Singleton() { // 将构造⽅法封装为私有化}public void print() {System.out.println("Hello World");}}public class SingletonDemo {public static void main(String args[]) {Singleton s1 = null; // 声明对象Singleton s2 = null; // 声明对象Singleton s3 = null; // 声明对象s1 = Singleton.getInstance(); // 取得实例化对象s2 = Singleton.getInstance(); // 取得实例化对象s3 = Singleton.getInstance(); // 取得实例化对象s1.print(); // 调⽤⽅法s2.print(); // 调⽤⽅法s3.print(); // 调⽤⽅法}} ⼀、单例模式的介绍Singleton是⼀种创建型模式，指某个类采⽤Singleton模式，则在这个类被创建后，只可能产⽣⼀个实例供外部访问，并且提供⼀个全局的访问点⼆、单例模式的实现实现的⽅式有如下四种：/**** 单例模式的实现：饿汉式,线程安全但效率⽐较低*/public class SingletonTest {private SingletonTest() {}private static final SingletonTest instance = new SingletonTest();public static SingletonTest getInstancei() {return instance;}}/*** 单例模式的实现：饱汉式,⾮线程安全**/public class SingletonTest {private SingletonTest() {}private static SingletonTest instance;public static SingletonTest getInstance() {if (instance == null)instance = new SingletonTest();return instance;}}/*** 线程安全，但是效率⾮常低* @author vanceinfo**/public class SingletonTest {private SingletonTest() {}private static SingletonTest instance;public static synchronized SingletonTest getInstance() {if (instance == null)instance = new SingletonTest();return instance;}}/*** 线程安全并且效率⾼**/public class SingletonTest {private static SingletonTest instance;private SingletonTest() {}public static SingletonTest getIstance() {if (instance == null) {synchronized (SingletonTest.class) {if (instance == null) {instance = new SingletonTest();}}}return instance;}}2.⼯⼚设计模式程序在接⼝和⼦类之间加⼊了⼀个过渡端，通过此过渡端可以动态取得实现了共同接⼝的⼦类实例化对象。
Java设计模式常用设计模式及其应用场景
Java设计模式常用设计模式及其应用场景设计模式是软件工程中常用的一种解决问题的方案，它提供了一套被广泛接受和验证的解决方案，用于解决在软件设计过程中遇到的各种问题。
Java作为一种广泛应用的编程语言，有许多常用的设计模式可以应用到Java开发中。
本文将介绍几种常用的Java设计模式以及它们的应用场景。
一、单例模式单例模式是一种在整个应用程序中只允许创建一个实例的设计模式。
它主要解决的问题是对资源的共享访问以及避免重复创建对象。
在Java中，单例模式的应用场景非常多，比如用于创建数据库连接池、线程池等资源池。
使用单例模式可以保证这些资源的唯一性，避免资源的浪费。
二、工厂模式工厂模式是一种通过创建工厂类来实例化对象的设计模式。
它主要解决的问题是创建对象的过程复杂，需要通过工厂类来封装这个复杂的过程。
在Java中，工厂模式常用于创建对象时需要根据条件来判断具体需要创建哪种类型的对象的情况。
比如，根据用户的输入来创建不同类型的图形对象，可以使用工厂模式。
三、观察者模式观察者模式是一种对象间的一对多依赖关系，当一个对象的状态发生变化时，它的所有依赖对象都会收到通知并自动更新。
在Java中，观察者模式被广泛应用于事件监听和消息传递。
比如，一个网站上的用户注册功能，当用户成功注册后，可以通过观察者模式通知其他相关的模块进行相应的操作。
四、策略模式策略模式是一种将算法封装起来并使其可以互相替换的设计模式。
它主要解决的问题是为同一种问题提供多种解决方案，并且使这些解决方案可以相互替换，互不影响。
在Java中，策略模式可以用于实现不同的排序算法、不同的计算方式等。
比如，一个商场的折扣活动可以采用策略模式，根据不同的折扣策略计算折扣后的价格。
五、装饰者模式装饰者模式是一种通过为对象添加新的功能来扩展其功能的设计模式，它不改变对象的结构。
在Java中，装饰者模式常用于对已有的类进行功能扩展或者改造。
比如，对一个已有的文件读写类进行包装，增加加密、压缩等额外功能，而不改变原有类的结构和接口。
java设计模式面试题
java设计模式面试题Java 设计模式面试题设计模式是软件开发中常用的解决问题的方法论，它通过提供经过验证的解决方案来应对各种软件设计问题。
在面试中，设计模式也是经常被问到的内容之一。
本文将介绍一些常见的Java 设计模式面试题，并给出对应的解答。
一、单例模式（Singleton Pattern）单例模式是一种创建型设计模式，其目的是保证一个类只有一个实例，并提供一个全局访问点。
常见的实现方式有懒汉式和饿汉式。
1. 懒汉式实现单例模式的代码示例：```javapublic class Singleton {private static Singleton instance;private Singleton() {}public static Singleton getInstance() {if (instance == null) {instance = new Singleton();}return instance;}2. 饿汉式实现单例模式的代码示例：```javapublic class Singleton {private static Singleton instance = new Singleton();private Singleton() {}public static Singleton getInstance() {return instance;}}```二、工厂模式（Factory Pattern）工厂模式是一种创建型设计模式，其通过提供一个公共接口来创建对象，而不需要暴露对象的创建逻辑。
1. 简单工厂模式的代码示例：```javapublic interface Shape {void draw();public class Circle implements Shape {@Overridepublic void draw() {System.out.println("Draw a circle.");}}public class Rectangle implements Shape {@Overridepublic void draw() {System.out.println("Draw a rectangle.");}}public class ShapeFactory {public Shape createShape(String shapeType) {if (shapeType.equalsIgnoreCase("circle")) {return new Circle();} else if (shapeType.equalsIgnoreCase("rectangle")) { return new Rectangle();}return null;}}```2. 抽象工厂模式的代码示例：```javapublic interface Shape {void draw();}public interface Color {void fill();}public class Circle implements Shape { @Overridepublic void draw() {System.out.println("Draw a circle."); }}public class Rectangle implements Shape {@Overridepublic void draw() {System.out.println("Draw a rectangle."); }}public class Red implements Color {@Overridepublic void fill() {System.out.println("Fill with red color."); }}public class Blue implements Color {@Overridepublic void fill() {System.out.println("Fill with blue color."); }}public abstract class AbstractFactory {public abstract Shape createShape(String shapeType); public abstract Color createColor(String colorType);}public class ShapeFactory extends AbstractFactory {@Overridepublic Shape createShape(String shapeType) {if (shapeType.equalsIgnoreCase("circle")) {return new Circle();} else if (shapeType.equalsIgnoreCase("rectangle")) { return new Rectangle();}return null;}@Overridepublic Color createColor(String colorType) {return null;}}public class ColorFactory extends AbstractFactory {@Overridepublic Shape createShape(String shapeType) {return null;}@Overridepublic Color createColor(String colorType) {if (colorType.equalsIgnoreCase("red")) {return new Red();} else if (colorType.equalsIgnoreCase("blue")) {return new Blue();}return null;}}```三、观察者模式（Observer Pattern）观察者模式是一种行为型设计模式，其定义了对象之间的一对多依赖关系，使得当一个对象改变状态时，它的所有依赖者都会收到通知并自动更新。
系统设计常见的设计模式及其实际应用案例
系统设计常见的设计模式及其实际应用案例在软件开发领域，设计模式是一组被广泛应用于解决常见问题的可重复利用的解决方案。
设计模式可以提高代码的可读性、可维护性和可扩展性，使系统更加灵活和可靠。
本文将介绍一些常见的系统设计模式，并提供相应的实际应用案例。
一、单例模式单例模式是一种创建型模式，它保证一个类只有一个实例，并提供一个全局访问点。
单例模式常被用于数据库连接、日志记录器等资源共享的场景。
实际应用案例：Java中的Runtime类就是一个典型的单例模式。
通过调用`Runtime.getRuntime()`方法，可以获取到全局唯一的Runtime实例，从而实现对系统运行时环境的访问。
二、工厂模式工厂模式是一种创建型模式，它定义了一个用于创建对象的接口，但具体的对象创建逻辑由具体的工厂类来实现。
工厂模式能够将对象的创建与使用分离，降低了耦合性。
实际应用案例：在Java中，Calendar类就是通过工厂模式来创建日期对象的。
通过调用`Calendar.getInstance()`方法，可以根据当前系统的时区和语言环境，返回一个具体实现的Calendar对象。
三、观察者模式观察者模式是一种行为型模式，它定义了一种一对多的依赖关系，使得当一个对象状态发生变化时，其依赖对象能够自动收到通知并进行相应的更新。
实际应用案例：Android中的广播机制就是观察者模式的实际应用。
当一个广播消息被发送时，所有注册了相应广播接收器的组件都能够接收到并做出响应。
四、策略模式策略模式是一种行为型模式，它定义了一系列可相互替换的算法，并将每个算法封装在独立的类中。
通过切换不同的策略对象，可以在运行时改变系统的行为。
实际应用案例：在电商系统中，用户下单时可以选择不同的支付方式，比如支付宝、微信、银行卡等。
这些不同的支付方式就可以使用策略模式来实现。
五、装饰者模式装饰者模式是一种结构型模式，它允许动态地为对象添加额外的功能，同时又不改变其原有的结构。
java常用的设计模式及应用场景
java常用的设计模式及应用场景一、单例模式（Singleton）单例模式是一种对象创建型模式，它指的是设计一个类，使其只能生成一个实例。
它只提供一个类实例，保证只有一个实例存在。
有时候，只需要一个类的实例来控制整个系统，例如实现一个全局的缓存，或是建立一个共享的日志记录器，单例模式可以很好的实现这个目的。
应用场景：1、对于需要频繁创建和销毁的对象，可以考虑使用单例模式，以避免过多地重复创建和销毁造成系统开销。
2、对于某些资源比较宝贵的对象，例如数据库连接，则可以用单例模式进行封装，保证全局应用程序只有一个，从而避免重复创建，浪费资源。
二、工厂模式（Factory）工厂模式是一种类创建型模式，它把类的实例化推迟到子类来完成。
它用于隔离客户类和实例化对象，通过声明抽象类类来定义构造过程，将不同的定义转移到不同的子类中去，从而使用户不需要关心实例化过程。
1、在有大量不同对象需要创建和管理的情况下，可以利用工厂模式封装类的实例化和存储，将池中不同对象来进行统一管理。
2、在使用设计模式的情况下，复杂的类结构已经不适合用一个实例来创建，可以采用工厂模式实现多个类的实例化，让用户不用关心对象实例的创建过程。
抽象工厂模式是一种工厂模式的拓展，它把简单工厂模式的单一职责拆分为多个类，从而实现一个系列相关的或相互依赖的工厂，以满足比较复杂的对象创建需求。
1、在需要创建复杂对象，而复杂对象又由多个部件组成的情况下，例如计算机，单一工厂模式已经不能满足需求，那么可以通过抽象工厂模式来实现。
2、在需要产生大量不同类型的对象，或者存在一系列相互依赖的产品族，这种情况下可以使用抽象工厂模式，将工厂定义为不同维度组成的一个系列。
四、建造者模式（Builder）建造者模式是一种设计模式，它也叫构造子模式，通过使用建造者模式，客户端可以不必担心具体的生产过程，只需要给出具体的请求，由建造者来负责构造出请求的产品对象。
1、在有复杂的产品对象的时候，例如需要对多个部件进行拼装，以构造出复杂的对象，可以采用建造者模式将复杂的拼装过程进行封装，避免复杂的拼装过程变得混乱。
java设计模式及应用场景
Java设计模式及应用场景1. 概述设计模式是一种通用的解决问题的模板或蓝图，它提供了解决常见软件设计问题的经验。
在软件开发过程中，设计模式可以提高软件的可维护性、可扩展性和重用性。
Java语言是一种面向对象的编程语言，提供了一些常见的设计模式，并且在Java开发领域有广泛的应用。
本文将对Java中的一些常见设计模式及其应用场景进行深入探讨。
2. 创建型设计模式创建型设计模式主要关注对象实例化的方式，目标是提供一种灵活、可扩展的对象创建机制。
2.1 工厂方法模式（Factory Method Pattern）工厂方法模式是一种常见的创建型设计模式，它定义了一个用于创建对象的接口，但将具体的对象创建操作延迟到子类。
工厂方法模式可以隐藏对象的具体创建方式，使得客户端代码与具体对象解耦。
应用场景•当需要创建的对象有共同的接口或基类，并且需要根据具体情况选择其中一个对象时，可以使用工厂方法模式。
•当对象的创建过程比较复杂或需要根据不同的条件创建不同的对象时，可以使用工厂方法模式。
示例代码// 定义产品接口interface Product {void doSomething();}// 具体产品类1class ConcreteProduct1 implements Product {public void doSomething() {// 具体产品1的实现}}// 具体产品类2class ConcreteProduct2 implements Product { public void doSomething() {// 具体产品2的实现}}// 定义工厂接口interface Factory {Product createProduct();}// 具体工厂类1class ConcreteFactory1 implements Factory { public Product createProduct() {return new ConcreteProduct1();}}// 具体工厂类2class ConcreteFactory2 implements Factory { public Product createProduct() {return new ConcreteProduct2();}}// 客户端代码public class Client {public static void main(String[] args) {Factory factory = new ConcreteFactory1(); Product product = factory.createProduct(); product.doSomething();}}2.2 抽象工厂模式（Abstract Factory Pattern）抽象工厂模式是一种创建型设计模式，它提供了一个创建一系列相关或相互依赖对象的接口，而无需指定具体的类。
23种设计模式的代码实现
23种设计模式的代码实现一、单例模式单例模式（Singleton Pattern）是指一个类只允许创建一个实例，并且提供全局访问点。
在Java应用中，单例模式最常见的用途是一些全局变量或者全局配置信息，它们需要被访问和使用，但又需要被控制当只有一个对象时只被实例化一次。
下面的代码实现了一个单例模式的类，这个类负责创建唯一的对象，并提供一个getInstance方法，允许外界访问这个唯一的对象。
public class Singleton//静态变量存放唯一的单例对象private static Singleton instance;//私有构造方法，禁止外部创建对象private Singleton({};//外界访问唯一实例的公有方法public static Singleton getInstanceif (instance == null)instance = new Singleton(;}return instance;}//其它方法，用于操作唯一的实例public void doSomething//do something}二、工厂模式工厂模式（Factory Pattern）是指定义一个创建对象的接口，而且让子类决定要实例化的类。
下面是一个使用工厂模式的示例，该示例定义了一个接口Product和两个实现类ProductA和ProductB，它们分别用于创建A和B类型的产品。
接口Product定义了产品的公共接口，实现类ProductA和ProductB分别实现其接口，同时，定义一个工厂类ProductFactory，它根据传入的参数来创建不同类型的产品。
interface Productpublic void doSomething(;class ProductA implements Productpublic void doSomethinSystem.out.println("ProductA doSomething");}class ProductB implements Productpublic void doSomethinSystem.out.println("ProductB doSomething");}class ProductFactorypublic static Product createProduct(String type) Product product = null;if (type.equals("A"))。
java状态机设计模式及应用
java状态机设计模式及应用Java状态机设计模式及应用案例什么是状态机设计模式？状态机设计模式基于状态模式，在软件设计中常用于表示对象在不同状态下的行为变化。
状态机模式将对象在不同状态下的行为封装在不同的状态类中，并通过状态之间的转换来实现对象的不同行为。
应用案例以下是一些常见的应用场景，展示了Java状态机设计模式在不同应用领域的应用：1. 订单生命周期管理•描述：在电商平台中，订单的状态通常包括待付款、待发货、已发货、已完成等多个状态。
订单对象通过状态机设计模式，根据订单当前的状态调用不同的方法处理。
•实现：创建一个Order类，定义不同的订单状态类（例如PendingPaymentState、PendingShipmentState等），在Order类中维护一个当前状态的引用，并提供方法用于状态之间的转换。
2. 电梯控制系统•描述：在一个多层楼的建筑中，电梯的状态通常包括停止、上升、下降等多个状态。
电梯控制系统可以使用状态机设计模式来管理电梯的状态转换和行为。
•实现：创建一个Elevator类，定义不同的电梯状态类（例如StoppedState、UpwardState、DownwardState等），在Elevator类中维护一个当前状态的引用，并提供方法用于状态之间的转换。
3. 游戏角色行为管理•描述：在游戏开发中，游戏角色通常会根据不同的状态执行不同的行为，例如站立、跑动、攻击、防御等。
状态机设计模式可以用于管理游戏角色的状态和行为之间的转换。
•实现：创建一个GameCharacter类，定义不同的角色状态类（例如StandingState、RunningState、AttackingState等），在GameCharacter类中维护一个当前状态的引用，并提供方法用于状态之间的转换。
4. 工作流程管理•描述：在企业内部，工作流程通常包括多个步骤和状态，例如请假申请流程的审批、通过、拒绝等状态。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
java设计模式示例创建模式1.工厂方法模式（Factory Method）将程序中创建对象的操作，单独出来处理，创建一个产品的工厂接口，把实际的工作转移到具体的子类。
大大提高了系统扩展的柔性，接口的抽象化处理给相互依赖的对象创建提供了最好的抽象模式。
[java]view plaincopy1.public class TestFactoryMethod {2.3.public static void main(String[] args) {4.5.AnimalFactory af=new DogFactory();6.7.Animal1 a=af.getAnimal();8.9.}10.11.}12.13.abstract class Animal1{}14.15.class Dog1 extends Animal1{}16.17.class Cat1 extends Animal1{}18.19.20.21.abstract class AnimalFactory{22.23.public abstract Animal1 getAnimal();24.25.}26.27.class DogFactory extends AnimalFactory{28.29.public Animal1 getAnimal(){30.31.System.out.println("Dog");32.33.return new Dog1();34.35.}36.37.}38.39.class CatFactory extends AnimalFactory{40.41.public Animal1 getAnimal(){42.43.System.out.println("Cat");44.45.return new Cat1();46.47.}48.49.}2.抽象工厂模式（Abstract Factory）针对多个产品等级的情况，而工厂方法模式针对单一产品等级的情况。
[java]view plaincopy1.import java.awt.*;2.3.import javax.swing.*;4.5.import java.awt.event.*;6.7.public class TestAbstractFactory {8.9.public static void main(String[] args) {10.11.GUIFactory fact=new SwingFactory();12.13.Frame f=fact.getFrame();14.ponent c1=fact.getButton();16.ponent c2=fact.getTextField();18.19.20.21.f.setSize(500,300);22.23.f.setLayout(new FlowLayout());24.25.f.add(c1);26.27.f.add(c2);28.29.f.setVisible(true);30.31.32.33.f.addWindowListener(new WindowAdapter(){34.35.public void windowClosing(WindowEvent e){36.37.System.exit(0);38.39.}40.41.});42.43.}44.45.}46.47.abstract class GUIFactory{48.49.public abstract Component getButton();50.51.public abstract Component getTextField();52.53.public abstract Frame getFrame();54.55.}56.57.class AWTFactory extends GUIFactory{58.59.public Component getButton() {60.61.return new Button("AWT Button");62.63.}64.65.public Frame getFrame() {66.67.return new Frame("AWT Frame");68.69.}70.71.public Component getTextField() {72.73.return new TextField(20);74.75.}76.77.78.79.}80.81.class SwingFactory extends GUIFactory{82.83.public Component getButton() {84.85.return new JButton("Swing Button");86.87.}88.89.public Frame getFrame() {90.91.return new JFrame("Swing Frame");92.93.}94.95.public Component getTextField() {96.97.return new JTextField(20);98.99.}100.101.}3.单例模式（Singleton）改善全局变量和命名空间的冲突，可以说是一种改良了的全局变量。
这种一个类只有一个实例，且提供一个访问全局点的方式，更加灵活的保证了实例的创建和访问约束。
系统中只有一个实例，因此构造方法应该为私有饿汉式：类加载时直接创建静态实例懒汉式：第一次需要时才创建一个实例，那么newInstance方法要加同步饿汉式比懒汉式要好，尽管资源利用率要差。
但是不用同步。
1.public class TestSingleton {2.3.public static void main(String[] args) {4.5.6.7.}8.9.}10.11.class ClassA{ //饿汉式12.13.private static ClassA i=new ClassA();14.15.public static ClassA newInstance(){16.17.return i;18.19.}20.21.private ClassA(){}22.23.}24.25.class ClassB{ //懒汉式26.27.private static ClassB i=null;28.29.public static synchronized ClassB newInstance(){30.31.if (i==null) i=new ClassB();32.33.return i;34.35.}36.37.private ClassB(){}38.39.}4.建造模式（Builder）将一个对象的内部表象和建造过程分割，一个建造过程可以造出不同表象的对象。
可简化为模版方法模式.1.public class TestBuilder {2.3.public static void main(String[] args) {4.5.Builder b=new BuilderImpl1();6.7.Director d=new Director(b);8.9.Product p=d.createProduct();10.11.}12.13.14.15.}16.17.interface Builder{18.19.void buildPart1();20.21.void buildPart2();22.23.void buildPart3();24.25.Product getProduct();26.27.}28.29.class BuilderImpl1 implements Builder{30.31.32.33.public void buildPart1() {34.35.System.out.println("create part1");36.37. }38.39.40.41.public void buildPart2() {42.43.System.out.println("create part2");45.}46.47.48.49.public void buildPart3() {50.51.System.out.println("create part3");52.53.}54.55.56.57.public Product getProduct() {58.59.return new Product();60.61.}62.63.64.65.}66.67.68.69.class Director{70.71.Builder b;72.73.public Director(Builder b){74.75.this.b=b;76.77.}78.79.public Product createProduct(){80.81.b.buildPart1(); b.buildPart2();82.83.b.buildPart3();84.85.return b.getProduct();86.87.}89. }90.91.class Product{}5.原型模式（ProtoType）通过一个原型对象来创建一个新对象（克隆）。
Java中要给出Clonable接口的实现，具体类要实现这个接口，并给出clone()方法的实现细节，这就是简单原型模式的应用。
⎫浅拷贝：只拷贝简单属性的值和对象属性的地址⎫深拷贝：拷贝本对象引用的对象，有可能会出现循环引用的情况。
可以用串行化解决深拷贝。
写到流里再读出来，这时会是一个对象的深拷贝结果。
[java]view plaincopy1.import java.io.*;2.3.public class TestClonealbe {4.5.public static void main(String[] args) throws Exception {6.7.Father f=new Father();8.9.10.er u1=new User("123456",f);12.er u2=(User)u1.clone();14.15.System.out.println(u1==u2);16.17.System.out.println(u1.f==u2.f);18.19.}20.21.}22.23.class User implements Cloneable,Serializable{24.25.String password;26.27.Father f;28.29.public User(String password,Father f){30.31.this.password=password;32.33.this.f=f;34.35.}36.37.public Object clone() throws CloneNotSupportedException {38.39.//return super.clone();40.41.ObjectOutputStream out=null;42.43.ObjectInputStream in=null;44.45.try {46.47.ByteArrayOutputStream bo=new ByteArrayOutputStream();48.49.out = new ObjectOutputStream(bo);50.51.out.writeObject(this);52.53.out.flush();54.55.byte[] bs=bo.toByteArray();56.57.58.59.ByteArrayInputStream bi=new ByteArrayInputStream(bs);60.61.in = new ObjectInputStream(bi);62.63.Object o=in.readObject();64.65.66.67.return o;68.69.} catch (IOException e) {70.71.e.printStackTrace();72.73.return null;74.75.} catch (ClassNotFoundException e) {76.77.e.printStackTrace();78.79.return null;80.81.}82.83.finally{84.85.try {86.87.out.close();88.89.in.close();90.91.} catch (IOException e) {92.93.e.printStackTrace();94.95.}96.97.}98.99.}100.101.}102.103.class Father implements Serializable{}结构模式如何把简单的类根据某种结构组装为大的系统6.适配器模式（Adapter）在原类型不做任何改变的情况下，用一个适配器类把一个接口转成另一个接口，扩展了新的接口，灵活且多样的适配一切旧俗。