Java Design Pattern

1.工厂模式

工厂模式（Factory Pattern）是 Java 中最经常使用的设计模式之一。这种类型的设计模式属于建立型模式，它提供了一种建立对象的最佳方式。

在工厂模式中，咱们在建立对象时不会对客户端暴露建立逻辑，而且是经过使用一个共同的接口来指向新建立的对象。

介绍

意图：定义一个建立对象的接口，让其子类本身决定实例化哪个工厂类，工厂模式使其建立过程延迟到子类进行。

主要解决：主要解决接口选择的问题。

什么时候使用：咱们明确地计划不一样条件下建立不一样实例时。

如何解决：让其子类实现工厂接口，返回的也是一个抽象的产品。

关键代码：建立过程在其子类执行。

应用实例： 一、您须要一辆汽车，能够直接从工厂里面提货，而不用去管这辆汽车是怎么作出来的，以及这个汽车里面的具体实现。 二、Hibernate 换数据库只需换方言和驱动就能够。

优势： 一、一个调用者想建立一个对象，只要知道其名称就能够了。 二、扩展性高，若是想增长一个产品，只要扩展一个工厂类就能够。 三、屏蔽产品的具体实现，调用者只关心产品的接口。

缺点：每次增长一个产品时，都须要增长一个具体类和对象实现工厂，使得系统中类的个数成倍增长，在必定程度上增长了系统的复杂度，同时也增长了系统具体类的依赖。这并非什么好事。

使用场景： 一、日志记录器：记录可能记录到本地硬盘、系统事件、远程服务器等，用户能够选择记录日志到什么地方。 二、数据库访问，当用户不知道最后系统采用哪一类数据库，以及数据库可能有变化时。 三、设计一个链接服务器的框架，须要三个协议，"POP3"、"IMAP"、"HTTP"，能够把这三个做为产品类，共同实现一个接口。

注意事项：做为一种建立类模式，在任何须要生成复杂对象的地方，均可以使用工厂方法模式。有一点须要注意的地方就是复杂对象适合使用工厂模式，而简单对象，特别是只须要经过 new 就能够完成建立的对象，无需使用工厂模式。若是使用工厂模式，就须要引入一个工厂类，会增长系统的复杂度。

 

实现

咱们将建立一个 Shape 接口和实现 Shape 接口的实体类。下一步是定义工厂类 ShapeFactory。

FactoryPatternDemo，咱们的演示类使用 ShapeFactory 来获取 Shape 对象。它将向 ShapeFactory 传递信息（CIRCLE / RECTANGLE / SQUARE），以便获取它所需对象的类型。

步骤 1

建立一个接口:

Shape.java

public interface Shape { void draw(); }

步骤 2

建立实现接口的实体类。

Rectangle.java

public class Rectangle implements Shape { @Override public void draw() { System.out.println("Inside Rectangle::draw() method."); } }

Square.java

public class Square implements Shape { @Override public void draw() { System.out.println("Inside Square::draw() method."); } }

Circle.java

public class Circle implements Shape { @Override public void draw() { System.out.println("Inside Circle::draw() method."); } }

步骤 3

建立一个工厂，生成基于给定信息的实体类的对象。

ShapeFactory.java

public class ShapeFactory { //使用 getShape 方法获取形状类型的对象 public Shape getShape(String shapeType){ if(shapeType == null){ return null; } if(shapeType.equalsIgnoreCase("CIRCLE")){ return new Circle(); } else if(shapeType.equalsIgnoreCase("RECTANGLE")){ return new Rectangle(); } else if(shapeType.equalsIgnoreCase("SQUARE")){ return new Square(); } return null; } }

步骤 4

使用该工厂，经过传递类型信息来获取实体类的对象。

FactoryPatternDemo.java

public class FactoryPatternDemo { public static void main(String[] args) { ShapeFactory shapeFactory = new ShapeFactory(); //获取 Circle 的对象，并调用它的 draw 方法 Shape shape1 = shapeFactory.getShape("CIRCLE"); //调用 Circle 的 draw 方法 shape1.draw(); //获取 Rectangle 的对象，并调用它的 draw 方法 Shape shape2 = shapeFactory.getShape("RECTANGLE"); //调用 Rectangle 的 draw 方法 shape2.draw(); //获取 Square 的对象，并调用它的 draw 方法 Shape shape3 = shapeFactory.getShape("SQUARE"); //调用 Square 的 draw 方法 shape3.draw(); } }

步骤 5

执行程序，输出结果：

Inside Circle::draw() method. Inside Rectangle::draw() method. Inside Square::draw() method.

 

 

 

 

 

 

2.单例模式

单例模式（Singleton Pattern）是 Java 中最简单的设计模式之一。这种类型的设计模式属于建立型模式，它提供了一种建立对象的最佳方式。

这种模式涉及到一个单一的类，该类负责建立本身的对象，同时确保只有单个对象被建立。这个类提供了一种访问其惟一的对象的方式，能够直接访问，不须要实例化该类的对象。

注意：

• 一、单例类只能有一个实例。
• 二、单例类必须本身建立本身的惟一实例。
• 三、单例类必须给全部其余对象提供这一实例。

 

介绍

意图：保证一个类仅有一个实例，并提供一个访问它的全局访问点。

主要解决：一个全局使用的类频繁地建立与销毁。

什么时候使用：当您想控制实例数目，节省系统资源的时候。

如何解决：判断系统是否已经有这个单例，若是有则返回，若是没有则建立。

关键代码：构造函数是私有的。

应用实例：

• 一、一个班级只有一个班主任。
• 二、Windows 是多进程多线程的，在操做一个文件的时候，就不可避免地出现多个进程或线程同时操做一个文件的现象，因此全部文件的处理必须经过惟一的实例来进行。
• 三、一些设备管理器经常设计为单例模式，好比一个电脑有两台打印机，在输出的时候就要处理不能两台打印机打印同一个文件。

优势：

• 一、在内存里只有一个实例，减小了内存的开销，尤为是频繁的建立和销毁实例（好比管理学院首页页面缓存）。
• 二、避免对资源的多重占用（好比写文件操做）。

缺点：没有接口，不能继承，与单一职责原则冲突，一个类应该只关心内部逻辑，而不关心外面怎么样来实例化。

使用场景：

• 一、要求生产惟一序列号。
• 二、WEB 中的计数器，不用每次刷新都在数据库里加一次，用单例先缓存起来。
• 三、建立的一个对象须要消耗的资源过多，好比 I/O 与数据库的链接等。

注意事项：getInstance() 方法中须要使用同步锁 synchronized (Singleton.class) 防止多线程同时进入形成 instance 被屡次实例化。

 

实现

咱们将建立一个 SingleObject 类。SingleObject 类有它的私有构造函数和自己的一个静态实例。

SingleObject 类提供了一个静态方法，供外界获取它的静态实例。SingletonPatternDemo，咱们的演示类使用 SingleObject 类来获取 SingleObject对象。

步骤 1

建立一个 Singleton 类。

SingleObject.java

public class SingleObject { //建立 SingleObject 的一个对象 private static SingleObject instance = new SingleObject(); //让构造函数为 private，这样该类就不会被实例化 private SingleObject(){} //获取惟一可用的对象 public static SingleObject getInstance(){ return instance; } public void showMessage(){ System.out.println("Hello World!"); } }

步骤 2

从 singleton 类获取惟一的对象。

SingletonPatternDemo.java

public class SingletonPatternDemo { public static void main(String[] args) { //不合法的构造函数 //编译时错误：构造函数 SingleObject() 是不可见的 //SingleObject object = new SingleObject(); //获取惟一可用的对象 SingleObject object = SingleObject.getInstance(); //显示消息 object.showMessage(); } }

步骤 3

执行程序，输出结果：

Hello World!

 

 

 

 

 

 

3.原型模式

原型模式（Prototype Pattern）是用于建立重复的对象，同时又能保证性能。这种类型的设计模式属于建立型模式，它提供了一种建立对象的最佳方式。

这种模式是实现了一个原型接口，该接口用于建立当前对象的克隆。当直接建立对象的代价比较大时，则采用这种模式。例如，一个对象须要在一个高代价的数据库操做以后被建立。咱们能够缓存该对象，在下一个请求时返回它的克隆，在须要的时候更新数据库，以此来减小数据库调用。

介绍

意图：用原型实例指定建立对象的种类，而且经过拷贝这些原型建立新的对象。

主要解决：在运行期创建和删除原型。

什么时候使用： 一、当一个系统应该独立于它的产品建立，构成和表示时。 二、当要实例化的类是在运行时刻指定时，例如，经过动态装载。 三、为了不建立一个与产品类层次平行的工厂类层次时。 四、当一个类的实例只能有几个不一样状态组合中的一种时。创建相应数目的原型并克隆它们可能比每次用合适的状态手工实例化该类更方便一些。

如何解决：利用已有的一个原型对象，快速地生成和原型对象同样的实例。

关键代码： 一、实现克隆操做，在 JAVA 继承 Cloneable，重写 clone()，在 .NET 中可使用 Object 类的 MemberwiseClone() 方法来实现对象的浅拷贝或经过序列化的方式来实现深拷贝。 二、原型模式一样用于隔离类对象的使用者和具体类型（易变类）之间的耦合关系，它一样要求这些"易变类"拥有稳定的接口。

应用实例： 一、细胞分裂。 二、JAVA 中的 Object clone() 方法。

优势： 一、性能提升。 二、逃避构造函数的约束。

缺点： 一、配备克隆方法须要对类的功能进行通盘考虑，这对于全新的类不是很难，但对于已有的类不必定很容易，特别当一个类引用不支持串行化的间接对象，或者引用含有循环结构的时候。 二、必须实现 Cloneable 接口。

使用场景： 一、资源优化场景。 二、类初始化须要消化很是多的资源，这个资源包括数据、硬件资源等。 三、性能和安全要求的场景。 四、经过 new 产生一个对象须要很是繁琐的数据准备或访问权限，则可使用原型模式。 五、一个对象多个修改者的场景。 六、一个对象须要提供给其余对象访问，并且各个调用者可能都须要修改其值时，能够考虑使用原型模式拷贝多个对象供调用者使用。 七、在实际项目中，原型模式不多单独出现，通常是和工厂方法模式一块儿出现，经过 clone 的方法建立一个对象，而后由工厂方法提供给调用者。原型模式已经与 Java 融为浑然一体，你们能够随手拿来使用。

注意事项：与经过对一个类进行实例化来构造新对象不一样的是，原型模式是经过拷贝一个现有对象生成新对象的。浅拷贝实现 Cloneable，重写，深拷贝是经过实现 Serializable 读取二进制流。

 

实现

咱们将建立一个抽象类 Shape 和扩展了 Shape 类的实体类。下一步是定义类 ShapeCache，该类把 shape 对象存储在一个 Hashtable 中，并在请求的时候返回它们的克隆。

PrototypePatternDemo，咱们的演示类使用 ShapeCache 类来获取 Shape 对象。

步骤 1

建立一个实现了 Cloneable 接口的抽象类。

Shape.java

public abstract class Shape implements Cloneable { private String id; protected String type; abstract void draw(); public String getType(){ return type; } public String getId() { return id; } public void setId(String id) { this.id = id; } public Object clone() { Object clone = null; try { clone = super.clone(); } catch (CloneNotSupportedException e) { e.printStackTrace(); } return clone; } }

步骤 2

建立扩展了上面抽象类的实体类。

Rectangle.java

public class Rectangle extends Shape { public Rectangle(){ type = "Rectangle"; } @Override public void draw() { System.out.println("Inside Rectangle::draw() method."); } }

Square.java

public class Square extends Shape { public Square(){ type = "Square"; } @Override public void draw() { System.out.println("Inside Square::draw() method."); } }

Circle.java

public class Circle extends Shape { public Circle(){ type = "Circle"; } @Override public void draw() { System.out.println("Inside Circle::draw() method."); } }

步骤 3

建立一个类，从数据库获取实体类，并把它们存储在一个 Hashtable 中。

ShapeCache.java

import java.util.Hashtable; public class ShapeCache { private static Hashtable<String, Shape> shapeMap = new Hashtable<String, Shape>(); public static Shape getShape(String shapeId) { Shape cachedShape = shapeMap.get(shapeId); return (Shape) cachedShape.clone(); } // 对每种形状都运行数据库查询，并建立该形状 // shapeMap.put(shapeKey, shape); // 例如，咱们要添加三种形状 public static void loadCache() { Circle circle = new Circle(); circle.setId("1"); shapeMap.put(circle.getId(),circle); Square square = new Square(); square.setId("2"); shapeMap.put(square.getId(),square); Rectangle rectangle = new Rectangle(); rectangle.setId("3"); shapeMap.put(rectangle.getId(),rectangle); } }

步骤 4

PrototypePatternDemo 使用 ShapeCache 类来获取存储在 Hashtable 中的形状的克隆。

PrototypePatternDemo.java

public class PrototypePatternDemo { public static void main(String[] args) { ShapeCache.loadCache(); Shape clonedShape = (Shape) ShapeCache.getShape("1"); System.out.println("Shape : " + clonedShape.getType()); Shape clonedShape2 = (Shape) ShapeCache.getShape("2"); System.out.println("Shape : " + clonedShape2.getType()); Shape clonedShape3 = (Shape) ShapeCache.getShape("3"); System.out.println("Shape : " + clonedShape3.getType()); } }

步骤 5

执行程序，输出结果：

Shape : Circle Shape : Square Shape : Rectangle

 

 

 

4.代理模式

在代理模式（Proxy Pattern）中，一个类表明另外一个类的功能。这种类型的设计模式属于结构型模式。

在代理模式中，咱们建立具备现有对象的对象，以便向外界提供功能接口。

介绍

意图：为其余对象提供一种代理以控制对这个对象的访问。

主要解决：在直接访问对象时带来的问题，好比说：要访问的对象在远程的机器上。在面向对象系统中，有些对象因为某些缘由（好比对象建立开销很大，或者某些操做须要安全控制，或者须要进程外的访问），直接访问会给使用者或者系统结构带来不少麻烦，咱们能够在访问此对象时加上一个对此对象的访问层。

什么时候使用：想在访问一个类时作一些控制。

如何解决：增长中间层。

关键代码：实现与被代理类组合。

应用实例： 一、Windows 里面的快捷方式。 二、猪八戒去找高翠兰结果是孙悟空变的，能够这样理解：把高翠兰的外貌抽象出来，高翠兰本人和孙悟空都实现了这个接口，猪八戒访问高翠兰的时候看不出来这个是孙悟空，因此说孙悟空是高翠兰代理类。 三、买火车票不必定在火车站买，也能够去代售点。 四、一张支票或银行存单是帐户中资金的代理。支票在市场交易中用来代替现金，并提供对签发人帐号上资金的控制。 五、spring aop。

优势： 一、职责清晰。 二、高扩展性。 三、智能化。

缺点： 一、因为在客户端和真实主题之间增长了代理对象，所以有些类型的代理模式可能会形成请求的处理速度变慢。 二、实现代理模式须要额外的工做，有些代理模式的实现很是复杂。

使用场景：按职责来划分，一般有如下使用场景： 一、远程代理。 二、虚拟代理。 三、Copy-on-Write 代理。 四、保护（Protect or Access）代理。 五、Cache代理。 六、防火墙（Firewall）代理。 七、同步化（Synchronization）代理。 八、智能引用（Smart Reference）代理。

注意事项： 一、和适配器模式的区别：适配器模式主要改变所考虑对象的接口，而代理模式不能改变所代理类的接口。 二、和装饰器模式的区别：装饰器模式为了加强功能，而代理模式是为了加以控制。

 

 

实现

咱们将建立一个 Image 接口和实现了 Image 接口的实体类。ProxyImage 是一个代理类，减小 RealImage 对象加载的内存占用。

ProxyPatternDemo，咱们的演示类使用 ProxyImage 来获取要加载的 Image 对象，并按照需求进行显示。

步骤 1

建立一个接口。

Image.java

public interface Image { void display(); }

步骤 2

建立实现接口的实体类。

RealImage.java

public class RealImage implements Image { private String fileName; public RealImage(String fileName){ this.fileName = fileName; loadFromDisk(fileName); } @Override public void display() { System.out.println("Displaying " + fileName); } private void loadFromDisk(String fileName){ System.out.println("Loading " + fileName); } }

ProxyImage.java

public class ProxyImage implements Image{ private RealImage realImage; private String fileName; public ProxyImage(String fileName){ this.fileName = fileName; } @Override public void display() { if(realImage == null){ realImage = new RealImage(fileName); } realImage.display(); } }

步骤 3

当被请求时，使用 ProxyImage 来获取 RealImage 类的对象。

ProxyPatternDemo.java

public class ProxyPatternDemo { public static void main(String[] args) { Image image = new ProxyImage("test_10mb.jpg"); // 图像将从磁盘加载 image.display(); System.out.println(""); // 图像不须要从磁盘加载 image.display(); } }

步骤 4

执行程序，输出结果：

Loading test_10mb.jpg Displaying test_10mb.jpg Displaying test_10mb.jpg

 

本文摘抄：http://www.runoob.com/design-pattern/design-pattern-tutorial.html若有违规，请联系我。我当即删除