- 浏览: 49734 次
- 性别:
- 来自: 北京
文章分类
最新评论
设计模式-创建型总结实例
创建型
单例模式
Singleton,单例模式:保证一个类只有一个实例,并提供一个访问它的全局访问点
java中单例模式是一种常见的设计模式,单例模式分三种:懒汉式单例、饿汉式单例、登记式单例三种。
单例模式有一下特点:
1、单例类只能有一个实例。
2、单例类必须自己自己创建自己的唯一实例。
3、单例类必须给所有其他对象提供这一实例。
单例模式确保某个类只有一个实例,而且自行实例化并向整个系统提供这个实例。在计算机系统中,线程池、缓存、日志对象、对话框、打印机、显卡的驱动程序对象常被设计成单例。这些应用都或多或少具有资源管理器的功能。
实例一:懒汉式
package com.ruishenh.designPatter.creational.singleton; /** * 懒汉式,在第一次调用的时候实例化 * @author hcr * */ public class LazySingleton { private static LazySingleton uniqueInstance = null; /** * 私有的构造函数 */ private LazySingleton() { // Exists only to defeat instantiation. } /** * 公有的访问模式 * * @return */ public synchronized static LazySingleton getInstance() { // 对象保持一个 if (uniqueInstance == null) { uniqueInstance = new LazySingleton(); } return uniqueInstance; } }
实例二:饿汉式
package com.ruishenh.designPatter.creational.singleton; /** * 饿汉式单例类.在类初始化时,已经自行实例化 * * @author hcr * */ public class SampleSingleton { /** * 私有的构造 */ private SampleSingleton() { } /** * 初始化对象有实例 */ private static final SampleSingleton single = new SampleSingleton(); /** * 静态工厂方法直接返回单例对象 */ public static SampleSingleton getInstance() { return single; } }
实例三:登记式
package com.ruishenh.designPatter.creational.singleton; import java.util.HashMap; import java.util.Map; /** * 登记式单例类. 类似Spring里面的方法,将类名注册,下次从里面直接获取。 * * @author hcr * */ public class RegisterSingleton { /** * 默认容器 */ private static Map<String, RegisterSingleton> map = new HashMap<String, RegisterSingleton>(); static { RegisterSingleton single = new RegisterSingleton(); map.put(single.getClass().getName(), single); } /** * 保护的默认构造器 */ protected RegisterSingleton() { } /** * 静态工厂方法,返还此类惟一的实例 * * @param name * @return */ public static RegisterSingleton getInstance(String name) { if (name == null) { name = RegisterSingleton.class.getName(); System.out.println("name == null"+"--->name="+name); } if (map.get(name) == null) { try { map.put(name, (RegisterSingleton) Class.forName(name) .newInstance()); } catch (InstantiationException e) { e.printStackTrace(); } catch (IllegalAccessException e) { e.printStackTrace(); } catch (ClassNotFoundException e) { e.printStackTrace(); } } return map.get(name); } public String about() { return "Hello, I am RegSingleton."; } public static void main(String[] args) { RegisterSingleton single = RegisterSingleton.getInstance("com.ruishenh.designPatter.creational.singleton.RegisterSingleton"); System.out.println(single.about()); } }
参考:http://www.cnblogs.com/whgw/archive/2011/10/05/2199535.html
工厂模式
工厂模式主要是为创建对象提供过渡接口,以便将创建对象的具体过程屏蔽隔离起来,达到提高灵活性的目的.
简单工厂
简单工厂模式又叫静态工厂模式,顾名思义,它是用来实例化目标类的静态类。
package com.ruishenh.designPatter.creational.factory.simpleFactory; /** * 静态工厂 * @author hcr * */ public class SimpleFactory { //静态直接产生指定对象 static TVFactory getTV(){ return new Haier(); } public static void main(String[] args) { //客户端调用静态直接生成创建对象 TVFactory tv=SimpleFactory.getTV(); System.out.println(tv.about()); } } interface TVFactory{ String about(); } class Haier implements TVFactory{ @Override public String about() { return "Haier高清彩电"; } } class Hisense implements TVFactory{ @Override public String about() { return "Hisense高清彩电"; } }
简单工厂核心任务就是简单的返回对应的生产的产品,客户端不用去管怎么创建的,直接调用对应的工厂静态方法返回实体即可。
工厂方法
工厂方法:定义一个用于创建对象的接口,让子类决定实例化哪一个类,Factory Method使一个类的实例化延迟到了子类。
package com.ruishenh.designPatter.creational.factory.factoryMethod; public class FactoryMethod { public static void main(String[] args) { //客户端调用 TVFactory tv=new HaierFactory(); //工厂生成实例 System.out.println(tv.createFPTV().about()); } } //工厂 interface TVFactory{ /* * 工厂方法 */ FPTVProduct createFPTV(); } //产品接口 interface FPTVProduct{ String about(); } class HaierFactory implements TVFactory{ @Override public FPTVProduct createFPTV() { //创建Haier的平板电视 return new FPTVProduct() { @Override public String about() { return "Haier高清平板电视"; } }; } } class HisenseFactory implements TVFactory{ @Override public FPTVProduct createFPTV() { //创建Hisense的平板电视 return new FPTVProduct() { @Override public String about() { return "Hisense高清平板电视"; } }; } }
工厂方法的核心任务就是通过工厂中的方法返回对应的子工厂来创建一个对象返回给客户端。
抽象工厂
Abstract Factory,抽象工厂:提供一个创建一系列相关或相互依赖对象的接口,而无须指定它们的具体类。
package com.ruishenh.designPatter.creational.factory.abstractFactory; public class AbstractFactory { public static void main(String[] args) { TVFactory factory=new HaierFactory(); System.out.println(factory.createDTV().about()); System.out.println(factory.createFPTV().about()); // TVFactory factory2=new HisenseFactory(); System.out.println(factory2.createDTV().about()); System.out.println(factory2.createFPTV().about()); } } interface TVFactory{ FPTVProduct createFPTV(); DTVProduct createDTV(); } interface FPTVProduct{ String about(); } interface DTVProduct{ String about(); } class HaierFactory implements TVFactory{ @Override public FPTVProduct createFPTV() { //创建Haier的平板电视 return new FPTVProduct() { @Override public String about() { return "Haier高清平板电视,我的尺寸特别小"; } }; } @Override public DTVProduct createDTV() { return new DTVProduct() { @Override public String about() { return "Haier高清数字电视,我有X个频道"; } }; } } class HisenseFactory implements TVFactory{ @Override public FPTVProduct createFPTV() { //创建Hisense的平板电视 return new FPTVProduct() { @Override public String about() { return "Hisense高清平板电视,我的尺寸特别小"; } }; } @Override public DTVProduct createDTV() { return new DTVProduct() { @Override public String about() { return "Hisense高清数字电视,我有N个频道"; } }; } }
抽象工厂的核心任务就是通过工厂中的方法返回对应的子工厂中的多个工厂中的一个,让后这个工厂可以返回多个产品的一个产品。
建造模式
将一个复杂对象的构建与他的表示相分离,使得同样的构建过程可以创建不同的表示。
package com.ruishenh.designPatter.creational.builder; public class Builder { public static void main(String[] args) { //找到小明给组装电脑 BuilderComputer builderComputer=new buildWorker(); //小明是新手,要老师指导组装 Director director =new Director(builderComputer); //小明装电脑 director.construct(); //组装完毕 builderComputer.getComputer(); } } //组装步骤 interface BuilderComputer{ //组装电源 void builderPower(); //组装机箱 void builderCrate(); //组装显示器 void builderDisplay(); //返回组装的整个电脑 Computer getComputer(); } //组装工人 class buildWorker implements BuilderComputer{ HPComputer computer =new HPComputer(); @Override public void builderPower() { computer.setPower("德玛牌电源"); System.out.println("组装好了电源"); } @Override public void builderCrate() { computer.setCrate("剑圣牌机箱"); System.out.println("组装好了机箱"); } @Override public void builderDisplay() { computer.setCrate("剑姬牌显示器"); System.out.println("组装好了显示器"); } @Override public Computer getComputer() { System.out.println("组装好了一台全新的英雄联盟牌电脑"); return computer; } } //实例产品 class HPComputer implements Computer{ String power; String crate; String display; @Override public String getPower() { return power; } @Override public void setPower(String power) { this.power=power; } @Override public String getCrate() { return crate; } @Override public void setCrate(String crate) { this.crate=crate; } @Override public String getDisplay() { return display; } @Override public void setDisplay(String display) { this.display=display; } } //产品概念 interface Computer{ public String getPower(); public void setPower(String power); public String getCrate(); public void setCrate(String crate); public String getDisplay(); public void setDisplay(String display); } //指导构建者 class Director{ BuilderComputer builderComputer; public Director(BuilderComputer builderComputer){ this.builderComputer=builderComputer; } public void construct() { builderComputer.builderPower(); builderComputer.builderCrate(); builderComputer.builderDisplay(); } }
建造者模式的核心任务就是把组装成一个(多种)复杂的对象产品放到对应的各个部分,然后用一个外壳(指导者)来把整体连接完成构建产品。最后返回一个产品(使得同样的构建过程可以创建不同的产品)
原型模式
用原型实例指定创建对象的种类,并且通过拷贝这些原型来创建新的对象。
package com.ruishenh.designPatter.creational.prototype; import java.util.ArrayList; import java.util.HashMap; import java.util.List; import java.util.Map; public class Prototype { public static void main(String[] args) throws CloneNotSupportedException { ConcretePrototype cp = new ConcretePrototype(); cp.setName("test-1"); List list = new ArrayList(); list.add(1); cp.setList(list); Map<String, Object> map = new HashMap<String, Object>(); map.put("test-2", "test-2-value"); cp.setMaps(map); ConcretePrototype cp2 = new ConcretePrototype(); cp2.setName("test-3"); cp.setConcretePrototype(cp2); ConcretePrototype clonecp = (ConcretePrototype) cp.clone(); clonecp.setName("test-1-1"); Map<String, Object> maps = clonecp.getMaps(); maps.put("test-2", "test-2-value-2"); ConcretePrototype cp4 = clonecp.getConcretePrototype(); cp4.setName("test-3-3"); List l=clonecp.getList(); l.clear(); //确认基本类型不在是一个引用 System.out.println(cp.getName() + "<==>" + clonecp.getName()); //确认map不在是一个引用 System.out.println(cp.getMaps() + "<==>" + clonecp.getMaps()); //确认getConcretePrototype不在是一个引用 System.out.println(cp.getConcretePrototype().getName() + "<==>" + clonecp.getConcretePrototype().getName()); //确认list不在是一个引用 System.out.println("test-6-" + cp.getList() + "<==>" + "test-6-"+ clonecp.getList()); } } class BasePrototype implements Cloneable { @Override protected BasePrototype clone() throws CloneNotSupportedException { return (BasePrototype) super.clone(); } } class ConcretePrototype extends BasePrototype { private String name; private List list; private Map<String, Object> maps; private ConcretePrototype concretePrototype; public ConcretePrototype getConcretePrototype() { return concretePrototype; } public void setConcretePrototype(ConcretePrototype concretePrototype) { this.concretePrototype = concretePrototype; } public List getList() { return list; } public Map<String, Object> getMaps() { return maps; } public void setMaps(Map<String, Object> maps) { this.maps = maps; } public void setList(List list) { this.list = list; } public String getName() { return name; } public void setName(String name) { this.name = name; } @Override public String toString() { return super.toString(); } @Override protected ConcretePrototype clone() throws CloneNotSupportedException { ConcretePrototype cpBasePrototype = (ConcretePrototype) super.clone(); cpBasePrototype.list = this.list==null?null:(List) ((ArrayList)this.list).clone(); cpBasePrototype.maps = (Map<String, Object>) (this.maps == null ? null:((HashMap) this.maps).clone()); cpBasePrototype.concretePrototype = this.concretePrototype == null ? null:this.concretePrototype.clone(); return cpBasePrototype; } }
原型模式可以很好的copy对象而不用去new一个对象。对于复杂的数据类型资源上来讲其实是很方便的。
它的核心任务就是节省开支,方便操作返回一个同样的对象。还有好多的结识比如深度和浅度的问题。在上边的实例完全做了一个深度的clone操作。
相关推荐
设计模式03-创建型模式 设计模式04-创建型模式2 设计模式05-建造者、原型模式 设计模式06-适配器、桥接、组合模式 设计模式07-组合模式、装饰模式 设计模式09-外观模式、享元模式 设计模式10-代理模式、结构型模式大...
行为型模式+结构型模式+创建型模式:三大设计模式实例剖析与深入解读 行为型模式 备忘录模式 +结构型模式 创建型模式总结 +创建型模式
3.2 Builder(生成器)—对象创建型模式 633.3 Factory Method(工厂方法)—对象创建型模式 70 3.4 Prototype(原型)—对象创建型模式 87 3.5 Singleton(单件)—对象创建型模式 84 3.6 创建型模式的讨论 89 第 4...
总体来说设计模式分为三大类: 创建型模式,共五种:工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式。 结构型模式,共七种:适配器模式、装饰器模式、代理模式、外观模式、桥接模式、组合模式、享元...
全书共9章,内容包括设计模式基础、创建型设计模式(共5种)、结构型设计模式(共7种)、行为型设计模式(共11种)、设计模式实验指导。每章包括教学目标、重点内容、模式的定义与特点、模式的结构与实现、模式的...
C#中简单工厂模式实例(设计模式-创建型模式)
1.2 Smalltalk MVC中的设计模式 1.3 描述设计模式 1.4 设计模式的编目 1.5 组织编目 1.6 设计模式怎样解决设计问题 1.7 怎样选择设计模式 1.8 怎样使用设计模式 第二章 实例研究:设计一个文档编辑器 2.1 设计问题...
通过对设计模式的学习和了解,以C#语言实践了设计模式的简单应用。 本次代码只提供了创建型模式的应用代码和说明,包括:Singleton 单件,Abstract Factory 抽象工厂,Builder 生成器,Factory Method 工厂方法...
创建型模式 : 通常和对象的创建有关,涉及到对象实例化的方式(共5种模式) ;结构型模式: 描述的是如何组合类和对象以获得更大的结构(共7种模式);行为型模式: 用来对类或对象怎样交互和怎样分配职责进行描述(共11...
内容简介:本书设计实例从面向对象的设计中精选出23个设计模式,总结了面向对象设计中最有价值的经验,并且用简洁可复用的形式表达出来。 本书分类描述了一组设计良好,表达清楚的软件设计模式,这些模式在实用环境...
JAVA的23种设计模式实例,如三大类创建型模式、结构型模式、行为型模式,细分为23种具体模式1. 设计模式 3 1.1 创建型模式 4 1.1.1 工厂方法 4 1.1.2 抽象工厂 6 1.1.3 建造者模式 10 1.1.4 单态模式 13 1.1.5 原型...
创建型模式,共五种:工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式。 结构型模式,共七种:适配器模式、装饰器模式、代理模式、外观模式、桥接模式、组合模式、享元模式。 行为型模式,共十一种:...
具体地, 研究了源码中设计模式抽取的静态结构分析过程, 为了进一步提高设计模式实例抽取的准确率, 对结构分析得到的创建型模式候选, 使用创建对象的多重性分析方法进行验证, 对结构分析得到的行为型模式候选, 使用...
例如,容易实现协议的设计。 Java EJB中有、无状态SessionBean的两个例子 两个例子,无状态SessionBean可会话Bean必须实现SessionBean,获取系统属性,初始化JNDI,取得Home对象的引用,创建EJB对象,计算利息等;...
本书设计实例从面向对象的设计中精选出23个设计模式,总结了面向对象设计中最有价值的经验,并且用简洁可复用的形式表达出来。本书分类描述了一组设计良好,表达清楚的软件设计模式,这些模式在实用环境下有特别有用...
Java经典设计模式(1)五大创建型模式(附实例和详解)Java开发Java经验技巧共13页.pdf.zip
2. 使学生了解23种设计模式,归纳总结创建型模式、行为型模式和结构型模式的应用情景、所需角色。并根据分类各举一例详细说明要析 3. 使学生掌握如何使用面向对象的方法,采用设计模式设计可扩展、高可重用的软件。 ...
本例是一个抽象工厂的实例程序,纯粹的个人完全原创,里面有完整的注释及说明。非常适合于新手及对设计模式有困惑的。实例简单但清晰的阐述了抽象工厂模式的妙处。
内容简介:本书设计实例从面向对象的设计中精选出23个设计模式,总结了面向对象设计中最有价值的经验,并且用简洁可复用的形式表达出来。本书分类描述了一组设计良好,表达清楚的软件设计模式,这些模式在实用环境下...
本书结合设计实例从面向对象的设计中精选出23个设计模式,总结了面向对象设计中最有价值的经验,并且用简洁可复用的形式表达出来。本书分类描述了一组设计良好、表达清楚的软件设计模式,这些模式在实用环境下特别...