Ucaner

You are what you want to be.

Ucaner

You are what you want to be. - w.b

patterns

Project：Java-Patterns
OfficialWebsite：http://patterns.ucaner.cn
describe：设计模式学习笔记

逻辑结构图

代码结构图

设计模式简述

创建型模式,共五种:工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式.

结构型模式,共七种:适配器模式、装饰器模式、代理模式、外观模式、桥接模式、组合模式、享元模式.

行为型模式,共十一种:策略模式、模板方法模式、观察者模式、迭代子模式、责任链模式、命令模式、备忘录模式、状态模式、访问者模式、中介者模式、解释器模式.

设计模式的六大原则

开闭原则（Open Close Principle）开闭原则就是说对扩展开放，对修改关闭。在程序需要进行拓展的时候，不能去修改原有的代码，实现一个热插拔的效果。所以一句话概括就是：为了使程序的扩展性好，易于维护和升级。想要达到这样的效果，我们需要使用接口和抽象类，后面的具体设计中我们会提到这点。
里氏代换原则（Liskov Substitution Principle）里氏代换原则(Liskov Substitution Principle LSP)面向对象设计的基本原则之一。里氏代换原则中说，任何基类可以出现的地方，子类一定可以出现。 LSP是继承复用的基石，只有当衍生类可以替换掉基类，软件单位的功能不受到影响时，基类才能真正被复用，而衍生类也能够在基类的基础上增加新的行为。里氏代换原则是对“开-闭”原则的补充。实现“开-闭”原则的关键步骤就是抽象化。而基类与子类的继承关系就是抽象化的具体实现，所以里氏代换原则是对实现抽象化的具体步骤的规范。—— From Baidu 百科
依赖倒转原则（Dependence Inversion Principle）这个是开闭原则的基础，具体内容：真对接口编程，依赖于抽象而不依赖于具体。
接口隔离原则（Interface Segregation Principle）这个原则的意思是：使用多个隔离的接口，比使用单个接口要好。还是一个降低类之间的耦合度的意思，从这儿我们看出，其实设计模式就是一个软件的设计思想，从大型软件架构出发，为了升级和维护方便。所以上文中多次出现：降低依赖，降低耦合。
迪米特法则（最少知道原则）（Demeter Principle）为什么叫最少知道原则，就是说：一个实体应当尽量少的与其他实体之间发生相互作用，使得系统功能模块相对独立。
合成复用原则（Composite Reuse Principle）原则是尽量使用合成/聚合的方式，而不是使用继承。

工厂方法模式

工厂模式，属于类创建型模式，工厂父类（接口）负责定义产品对象的公共接口，而子类工厂则负责创建具体的产品对象。
目的：是为了把产品的实例化操作延迟到子类工厂中完成，通过工厂子类来决定究竟应该实例化哪一个产品具体对象。

工厂方法模式包含四个部分：
- 1.抽象产品：产品对象同一的基类，或者是同一的接口
- 2.具体的产品：各个不同的实例对象类
- 3.抽象工厂：所有的子类工厂类的基类，或是同一的接口
- 4.具体的工厂子类：负责每个不同的产品对象的实际创建

packagecn.ucaner.pattern.create.factory.factory;
importcn.ucaner.pattern.create.factory.AbsHumanFactory;
importcn.ucaner.pattern.create.factory.Human;
/*** @Package：cn.ucaner.pattern.create.factory.factory * @ClassName：HumanFactory * @Description： <p> 工厂模式 --- 具体工厂 - human 工厂 extends abs humanFactory </p>* @Author： - * @CreatTime：2017年10月26日 下午5:46:37 * @Modify By： * @ModifyTime： * @Modify marker： * @version V1.0 */publicclassHumanFactoryextendsAbsHumanFactory {
@SuppressWarnings("unchecked")
@Overridepublic <TextendsHuman> TcreateHumen(Class<T> tClass) {
Humanhumen=null;
try {
humen= (T) Class.forName(tClass.getName()).newInstance();
} catch (InstantiationExceptione) {
e.printStackTrace();
} catch (IllegalAccessExceptione) {
e.printStackTrace();
} catch (ClassNotFoundExceptione) {
e.printStackTrace();
}
return (T)humen;
}
}

具体的实现类

//黑种人publicclassBlackHumanimplementsHuman {
@OverridepublicvoidgetColor() {
System.out.println("黑色人种");
}
}
//白种人publicclassWhiteHumanimplementsHuman {
@OverridepublicvoidgetColor() {
System.out.println("白色人种");
}
}
//黄种人publicclassYellowHumanimplementsHuman {
@OverridepublicvoidgetColor() {
System.out.println("黄色人种");
}
}

抽象工厂

packagecn.ucaner.pattern.create.factory;
/*** @Package：cn.ucaner.pattern.create.factory * @ClassName：AbsHumanFactory * @Description： <p> 工厂模式 --- 抽象出来的工厂</p>* @Author： - * @CreatTime：2017年10月26日 下午5:50:00 * @Modify By： * @ModifyTime： * @Modify marker： * @version V1.0 */publicabstractclassAbsHumanFactory {
publicabstract <TextendsHuman> TcreateHumen(Class<T> tClass);
}

/*** 工厂类测试 传入对应的实体 创建对应的对象*/publicclassFactoryMain {
publicstaticvoidmain(String[] args) {
//初始化一个工厂AbsHumanFactoryhumanFactory = newHumanFactory();
//建造一个黄种人HumanyellowHuman = humanFactory.createHumen(YellowHuman.class);
yellowHuman.getColor();
//建造一个黑人HumanblackHuman = humanFactory.createHumen(BlackHuman.class);
blackHuman.getColor();
//建造一个白人HumanwhiteHuman = humanFactory.createHumen(WhiteHuman.class);
whiteHuman.getColor();
}
}

单例模式

Singleton的静态属性instance中，只有instance为null的时候才创建一个实例，构造函数私有，确保每次都只创建一个，避免重复创建

/** * <html> * <body> * <P> Copyright 1994 JsonInternational</p> * <p> All rights reserved.</p> * <p> Created on 19941115</p> * <p> Created by Jason</p> * </body> * </html> */packagecn.ucaner.pattern.create.singleton;
/*** @Package：cn.ucaner.pattern.create.singleton * @ClassName：Singleton * @Description： <p> 双重锁的单例 单例模式</p>* @Author： - * @CreatTime：2017年10月26日 下午5:38:56 * @Modify By： * @ModifyTime： * @Modify marker： * @version V1.0 */publicclassSingleton {
/** * 防止外部创建实例 私有  * Singleton. */privateSingleton() {
}
/** * 唯一实例  * 内存可见性：通俗来说就是，线程A对一个volatile变量的修改，对于其它线程来说是可见的，即线程每次获取volatile变量的值都是最新的。 * https://www.cnblogs.com/chengxiao/p/6528109.html */privatestaticvolatileSingletonmInstance;
publicstaticSingletongetInstance() {
if (mInstance == null) {//第一个锁，如果没有实例/** * 第二个锁，如果没有任何线程创建Singleton实例 对象锁 - 若多个线程拥有同一个MyObject类的对象，则这些方法只能以同步的方式执行 * https://www.cnblogs.com/hapjin/p/5452663.html */synchronized (Singleton.class) { if (mInstance == null) {
mInstance = newSingleton();
}
}
}
returnmInstance;
}
publicstaticvoidmain(String[] args) {
System.out.println(mInstance);
}
}

建造者模式

建造者模式，顾名思义的就是类似建房子，有一个固定的流程。在大话设计模式中，作者举了一个例子大概意思是同一道菜在中国的每一个地方都有不同的味道（LZ印象最深的是鱼香肉丝，来北方最之后印象最深的是宫保鸡丁。哈哈），而肯德基的鸡腿、汉堡在每一个城市都是一样的味道。我觉的这一个例子可以清楚的认识到建造者模式有一个固定的建造过程。建造者模式实现了依赖倒转原则，抽象不应该依赖细节，细节应该依赖与抽象。建造者模式的定义是：将一个复杂对象的构造与它的表示分离，使同样的构建过程可以创建不同的表示，这样的设计模式被称为建造者模式。

建造者模式的角色定义，在建造者模式中存在以下4个角色：
- builder:为创建一个产品对象的各个部件指定抽象接口
- ConcreteBuilder:实现Builder的接口以构造和装配该产品的各个部件，定义并明确它所创建的表示，并提供一个检索产品的接口
- Director:构造一个使用Builder接口的对象
- Product:表示被构造的复杂对象。ConcreteBuilder创建该产品的内部表示并定义它的装配过程，包含定义组成部件的类，包括将这些部件装配成最终产品的接口

publicclassXMan {
privateStringname;
privateIntegerage;
privateStringxFactor;
privateStringlover;
publicStringgetName() {
returnname;
}
publicXMansetName(Stringname) {
this.name = name;
returnthis;
}
publicIntegergetAge() {
returnage;
}
publicXMansetAge(Integerage) {
this.age = age;
returnthis;
}
publicStringgetxFactor() {
returnxFactor;
}
publicXMansetxFactor(StringxFactor) {
this.xFactor = xFactor;
returnthis;
}
publicStringgetLover() {
returnlover;
}
publicXMansetLover(Stringlover) {
this.lover = lover;
returnthis;
}
}

publicclassWolverineDirector {
publicXManconstructWolverine(WolverineBuilderwolverineBuilder) {
returnwolverineBuilder
.buildXFactor()
.buildLover()
.buildName()
.buildAge()
.buildXman();
}
}
publicclassWolverineBuilderimplementsXManBuilder {
XManmXMan;
WolverineBuilder() {
mXMan = newXMan();
}
// need to consider /* @Override public WolverineBuilder buildXFactor() { mXMan.setxFactor("claw"); System.out.println(mXMan.getxFactor()); return this; }*/@OverridepublicXManBuilderbuildXFactor() {
mXMan.setxFactor("claw");
System.out.println(mXMan.getxFactor());
returnthis;
}
@OverridepublicWolverineBuilderbuildLover() {
mXMan.setLover("Jane");
System.out.println(mXMan.getLover());
returnthis;
}
@OverridepublicWolverineBuilderbuildName() {
mXMan.setName("Wali");
System.out.println(mXMan.getName());
returnthis;
}
@OverridepublicWolverineBuilderbuildAge() {
mXMan.setAge(18);
System.out.println(mXMan.getAge());
returnthis;
}
@OverridepublicXManbuildXman() {
System.out.println("Wolverine is successfully built");
returnmXMan;
}
}
publicinterfaceXManBuilder {
XManBuilderbuildXFactor();
XManBuilderbuildLover();
XManBuilderbuildName();
XManBuilderbuildAge();
XManbuildXman();
}

原型模式

博客参考

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

publicclassShallowCopyextendsBaseMessageimplementsCloneable {
@OverrideprotectedObjectclone() throwsCloneNotSupportedException {
ShallowCopyshallowCopy=null;
try {
shallowCopy= (ShallowCopy) super.clone();
}catch (Exceptione){
e.printStackTrace();
}
returnshallowCopy;
}
}
publicclassDeepCopyextendsBaseMessageimplementsCloneable {
@SuppressWarnings("unchecked")
@OverrideprotectedObjectclone() throwsCloneNotSupportedException {
DeepCopydeepCopy=null;
try {
deepCopy= (DeepCopy) super.clone();
this.setImgList((ArrayList<String>) this.getImgList().clone());
}catch (Exceptione){
e.printStackTrace();
}
returndeepCopy;
}
}
publicabstractclassBaseMessage {
/** * 发件人 */privateStringsend;
/** * 收件人 */privateStringreceiver;
/** * 消息 */privateStringmessage;
privateArrayList<String> imgList = newArrayList<>();
publicArrayList<String> getImgList() {
returnimgList;
}
publicvoidsetImgList(ArrayList<String> imgList) {
this.imgList = imgList;
}
publicStringgetSend() {
returnsend;
}
publicvoidsetSend(Stringsend) {
this.send = send;
}
publicStringgetReceiver() {
returnreceiver;
}
publicvoidsetReceiver(Stringreceiver) {
this.receiver = receiver;
}
publicStringgetMessage() {
returnmessage;
}
publicvoidsetMessage(Stringmessage) {
this.message = message;
}
publicvoidaddImage(Stringimage){
getImgList().add(image);
}
/*
* 发送消息publicvoidsendMessage(){
System.out.println(getReceiver()+getMessage()+" 娃娃图片数量"+getImgList().size()+" 发件人"+getSend());
}
}

适配器模式

适配器就是一种适配中间件，它存在于不匹配的二者之间，用于连接二者，将不匹配变得匹配，简单点理解就是平常所见的转接头，转换器之类的存在
适配器模式有两种
- 对象适配器
- 接口适配器

博客参考

接口适配器

/** * @Package：cn.ucaner.pattern.structure.adapter.charge.inf * @ClassName：ThreeInterface * @Description： <p> 三口插头 </p>* <pre>创建一个能够根据所传递对象的不同而具有不同行为的方法被称为[策略设计模式]</pre>* @Author： - Jason * @CreatTime：2018年6月5日 下午8:51:29 * @Modify By： * @ModifyTime： 2018年6月5日* @Modify marker： * @version V1.0*/publicinterfaceThreeInterface {
/** * @Description:三个口的插头有 一 个 功能，能够为三个触角的插头提供电源 * @CreatTime: 2018年9月23日 * @Autor: Jason - jasonandy@hotmail.com */publicvoidOfferPowerForThree();
}

publicinterfaceTwoInterface {
/**	* @Description: 两口的插座	* @CreatTime: 2018年9月23日	* @Autor: Jason - jasonandy@hotmail.com */publicvoidOfferPowerForTwo();
}

publicclassThree2TwoAdapterimplementsThreeInterface{
/** * 2口充电头 - 适配器 */TwoInterfacetwoInterface;
/** * 3口 转两口的插座 - 适配 * @param twoInterface */publicThree2TwoAdapter(TwoInterfacetwoInterface) {
super();
this.twoInterface = twoInterface;
}
/** * 三口的适配器 适用的是俩孔的插座 */@OverridepublicvoidOfferPowerForThree() {
twoInterface.OfferPowerForTwo();
}
}

publicclassThree3TwoAdapterimplementsTwoInterface{
ThreeInterfacethreeInterface;
/** * 2口 转3口的插座 - 适配 * @param twoInterface */publicThree3TwoAdapter(ThreeInterfacethreeInterface) {
super();
this.threeInterface = threeInterface;
}
@OverridepublicvoidOfferPowerForTwo() {
threeInterface.OfferPowerForThree();
}
}

/*** 转换器*/publicclassChinaChargeimplementsTwoInterface{
/** * OfferPowerForTwo 标准的两口插座 */@OverridepublicvoidOfferPowerForTwo() {
System.out.println("I'm China Charge. 220V. - 中国的标准的220V 50HZ 电源.");
}
}

publicclassHongKongChargeimplementsThreeInterface{
/** * 大家好这里是标准的3口插头 */@OverridepublicvoidOfferPowerForThree() {
System.out.println("I'm Three Charge - HK Standard");
}
}

对象适配

/*** @Package：cn.ucaner.pattern.structure.adapter.adapterAbs * @ClassName：IUserInfo * @Description： <p> 适配器模式 - -抽象用户类 </p>* @Author： - * @CreatTime：2017年10月26日 下午6:03:19 * @Modify By： * @ModifyTime： * @Modify marker： * @version V1.0 */publicinterfaceIUserInfo { //user信息StringgetUserName();
StringgetHomeAddress();
StringgetMobileNumber();
StringgetSex();
//job信息StringgetJobPosition();
}

publicinterfaceIOtherInfo {
/** * @Description:获取用户的User信息 * @return: HashMap<String,String> * @CreatTime: 2018年9月23日 * @Autor: Jason - jasonandy@hotmail.com */HashMap<String,String> getUserInfo();
/** * @Description: 获取的是用户的job信息 * @return: HashMap<String,String> * @CreatTime: 2018年9月23日 * @Autor: Jason - jasonandy@hotmail.com */HashMap<String,String> getUserJobInfo();
}

类适配

publicclassMeUserInfoimplementsIUserInfo {
@OverridepublicStringgetUserName() {
System.out.print("员工姓名");
returnnull;
}
@OverridepublicStringgetHomeAddress() {
System.out.print("员工住址");
returnnull;
}
@OverridepublicStringgetMobileNumber() {
System.out.print("员工号码");
returnnull;
}
@OverridepublicStringgetSex() {
System.out.print("员工性别");
returnnull;
}
@OverridepublicStringgetJobPosition() {
System.out.print("员工公司地址");
returnnull;
}
@OverridepublicStringtoString() {
return"MeUserInfo [getUserName()=" + getUserName() + ", getHomeAddress()=" + getHomeAddress()
+ ", getMobileNumber()=" + getMobileNumber() + ", getSex()=" + getSex() + ", getJobPosition()="
+ getJobPosition() + "]";
}
}

publicclassOtherUserInfoimplementsIOtherInfo {
@OverridepublicHashMap<String, String> getUserInfo() {
HashMap<String,String> hashMap=newHashMap<>();
hashMap.put("username","员工名称");
hashMap.put("address","员工住址");
hashMap.put("number","员工号码");
hashMap.put("sex","员工性别");
returnhashMap;
}
@OverridepublicHashMap<String, String> getUserJobInfo() {
HashMap<String,String> hashMap=newHashMap<>();
hashMap.put("jobaddress","员工公司地址");
returnhashMap;
}
@OverridepublicStringtoString() {
return"OtherUserInfo [getUserInfo()=" + getUserInfo() + ", getUserJobInfo()=" + getUserJobInfo() + "]";
}
}

对象适配

publicclassUserAdapterextendsOtherUserInfoimplementsIUserInfo{
@OverridepublicStringgetUserName() {
System.out.println(getUserInfo().get("username"));
returnnull;
}
@OverridepublicStringgetHomeAddress() {
System.out.println(getUserInfo().get("address"));
returnnull;
}
@OverridepublicStringgetMobileNumber() {
System.out.println(getUserInfo().get("number"));
returnnull;
}
@OverridepublicStringgetSex() {
System.out.println(getUserInfo().get("sex"));
returnnull;
}
@OverridepublicStringgetJobPosition() {
System.out.println(getUserJobInfo().get("jobaddress"));
returnnull;
}
@OverridepublicStringtoString() {
return"UserAdapter [getUserName()=" + getUserName() + ", getHomeAddress()=" + getHomeAddress()
+ ", getMobileNumber()=" + getMobileNumber() + ", getSex()=" + getSex() + ", getJobPosition()="
+ getJobPosition() + "]";
}
}

Test-Main

publicclassAdapterMain {
publicstaticvoidmain(String[] args) {
/** * 接口是iuserInfo 实例拿的是 OtherUserInfo */IUserInfoiUserInfo=newUserAdapter();
iUserInfo.getHomeAddress();
System.out.println(iUserInfo.toString());
/** * iuserInfo 实例也是 UserInfo  */IUserInfoiUserInfoMe=newMeUserInfo();
iUserInfoMe.getHomeAddress();
System.out.println(iUserInfoMe.toString());
}
}

代理模式

代理模式是Java常见的设计模式之一。所谓代理模式是指客户端并不直接调用实际的对象，而是通过调用代理，来间接的调用实际的对象
静态代理
动态代理
CGlib代理

代理模式参考静态代理

/*** @Package：cn.ucaner.pattern.structure.proxy.staticProxy * @ClassName：Subject * @Description： <p> static Proxy 代理模式接口类 </p>* @Author： - * @CreatTime：2017年10月26日 下午1:46:44 * @Modify By： * @ModifyTime： * @Modify marker： * @version V1.0 */publicinterfaceSubject {
/** * static Proxy */voidrequest();
}
/*** @Package：cn.ucaner.pattern.structure.proxy.staticProxy * @ClassName：RealSuject * @Description： <p> 代理模式真实类</p>* @Author： - * @CreatTime：2017年10月26日 下午1:47:02 * @Modify By： * @ModifyTime： * @Modify marker： * @version V1.0 */publicclassRealSujectimplementsSubject {
@Overridepublicvoidrequest() {
System.out.println("*** static proxy do request ！By Jason ***");
}
}
/*** @Package：cn.ucaner.pattern.structure.proxy.staticProxy * @ClassName：Proxy * @Description： <p> 代理模式 代理模式代理类,他和装饰器模式的实现有点相近{@link Decorator}</p>* @Author： - * @CreatTime：2017年10月26日 下午1:47:45 * @Modify By： * @ModifyTime： * @Modify marker： * @version V1.0 */publicclassProxyimplementsSubject {
privateSubjectrealSuject;
publicProxy(SubjectrealSuject) {
this.realSuject = realSuject;
}
@Overridepublicvoidrequest() {
if(realSuject!=null){
realSuject.request();
}
}
}

动态代理

publicinterfaceSubject {
/** * dynamicProxy */publicabstractvoidrequest();
}
publicclassRealSujectImplimplementsSubject {
@Overridepublicvoidrequest() {
System.out.println("*** dynamicProxy do request ***");
}
}
/*** @Package：cn.ucaner.pattern.structure.proxy.dynamicProxy * @ClassName：SubjectInvocationHandler * @Description： <p> 动态代理模式 --* 利用java.lang.reflect.Proxy类和java.lang.reflect.InvocationHandler接口定义代理类的实现* </p>* @Author： - * @CreatTime：2017年10月26日 下午5:04:37 * @Modify By： * @ModifyTime： * @Modify marker： * @version V1.0 */publicclassSubjectInvocationHandlerimplementsInvocationHandler {
/** * 目标对象  */privateObjecttarget;
publicSubjectInvocationHandler(Objecttarget) {
this.target = target;
}
/** * 描述: 实现调用  */@OverridepublicObjectinvoke(Objectproxy, Methodmethod, Object[] args) throwsThrowable {
System.out.println("----Dynamic Proxy invoke method Start ----");
Objectresult = method.invoke(target, args);//方法调用 System.out.println("----Dynamic Proxy invoke method End by Jason----");
returnresult;
}
publicObjectgetProxy() {
//获取当前线程的 classloder ClassLoaderloader = Thread.currentThread().getContextClassLoader();
//获取所有的interface Class<?>[] interfaces = target.getClass().getInterfaces();
returnProxy.newProxyInstance(loader, interfaces, this);
}
}

TEST

/*** @Package：cn.ucaner.pattern.structure.proxy * @ClassName：ProxyMain * @Description： <p> 代理模式运行类</p>* @Author： - * @CreatTime：2017年10月26日 下午1:45:08 * @Modify By： * @ModifyTime： * @Modify marker： * @version V1.0 */publicclassProxyMain {
publicstaticvoidmain(String[] args) {
//静态代理staticProxy();
//动态代理dynamicProxy();
}
/** * 静态代理 */privatestaticvoidstaticProxy() {
RealSujectrealSuject = newRealSuject();
Proxyproxy = newProxy(realSuject);
proxy.request();
}
/** * 动态代理 */privatestaticvoiddynamicProxy(){
RealSujectImplrealSubject=newRealSujectImpl();
SubjectInvocationHandlerhandler=newSubjectInvocationHandler(realSubject);
Subjectsubject= (Subject) handler.getProxy();
subject.request();
}
}

cglib

Cglib代理
上面的静态代理和动态代理模式都是要求目标对象是实现一个接口的目标对象,但是有时候目标对象只是一个单独的对象,并没有实现任何的接口,这个时候就可以使用以目标对象子类的方式类实现代理,这种方法就叫做:Cglib代理
Cglib代理,也叫作子类代理,它是在内存中构建一个子类对象从而实现对目标对象功能的扩展.
JDK的动态代理有一个限制,就是使用动态代理的对象必须实现一个或多个接口,如果想代理没有实现接口的类,就可以使用Cglib实现.
Cglib是一个强大的高性能的代码生成包,它可以在运行期扩展java类与实现java接口.它广泛的被许多AOP的框架使用,例如Spring AOP和synaop,为他们提供方法的interception(拦截)
Cglib包的底层是通过使用一个小而块的字节码处理框架ASM来转换字节码并生成新的类.不鼓励直接使用ASM,因为它要求你必须对JVM内部结构包括class文件的格式和指令集都很熟悉.
Cglib子类代理实现方法:
1.需要引入cglib的jar文件,但是Spring的核心包中已经包括了Cglib功能,所以直接引入pring-core-3.2.5.jar即可.
2.引入功能包后,就可以在内存中动态构建子类
3.代理的类不能为final,否则报错
4.目标对象的方法如果为final/static,那么就不会被拦截,即不会执行目标对象额外的业务方法.

外观模式

外观模式（Facade）,他隐藏了系统的复杂性，并向客户端提供了一个可以访问系统的接口。这种类型的设计模式属于结构性模式。
为子系统中的一组接口提供了一个统一的访问接口，这个接口使得子系统更容易被访问或者使用.

packagecn.ucaner.pattern.structure.decorator.decoratorAbs;
/*** @Package：cn.ucaner.pattern.structure.decorator.decoratorAbs * @ClassName：Decorator * @Description： <p> 装饰器模式 - * 抽象装饰器 这种方式看起来和静态代理模式很像 {@link cn.ucaner.pattern.structure.proxy.staticProxy.Proxy }</p>* @Author： - * @CreatTime：2017年10月26日 下午5:16:35 * @Modify By： * @ModifyTime： * @Modify marker： * @version V1.0 */publicabstractclassDecoratorextendsSchoolReport {
/** * 成绩单的抽象类 */privateSchoolReportschoolReport;
/** * Decorator. 将成绩单的属性包装到 Decorator里面去 * @param schoolReport */publicDecorator(SchoolReportschoolReport) {
this.schoolReport = schoolReport;
}
/** * 展示自己的成绩 */publicvoidreport(){
schoolReport.report();
}
@Overridepublicvoidsign(Stringname) {
schoolReport.sign(name);
}
}
packagecn.ucaner.pattern.structure.decorator.decoratorAbs;
/*** @Package：cn.ucaner.pattern.structure.decorator.decoratorAbs * @ClassName：SchoolReport * @Description： <p> 装饰器模式 - 成绩单抽象类</p>* @Author： - * @CreatTime：2017年10月26日 下午5:17:14 * @Modify By： * @ModifyTime： * @Modify marker： * @version V1.0 */publicabstractclassSchoolReport {
/** * 展示自己的成绩 */publicabstractvoidreport();
/** * 家长签名 */publicabstractvoidsign(Stringname);
/** * 建议-给出建议 */publicabstractvoiddiscuss(Stringdiscuss);
}
publicclassFouthGradeSchoolReportextendsSchoolReport {
@Overridepublicvoidreport() {
System.out.print(" 数学60,语文:80,英语:90 ");
}
@Overridepublicvoidsign(Stringname) {
System.out.println(" 家长签名:" + name);
}
@Overridepublicvoiddiscuss(Stringdiscuss) {
System.out.println(" 建议: " + discuss);
}
}
publicclassGoodBoyDecortaorextendsDecorator {
publicGoodBoyDecortaor(SchoolReportschoolReport) {
super(schoolReport);
}
/** * @Description:报告之前 先包装一下数据  * @Autor: Jason */privatevoidgoodBoyDecorator(){
System.out.println("我在学校表现很好,没毛病!");
}
/** * 1.goodBoyDecorator  * 2.成绩报告. */@Overridepublicvoidreport() {
goodBoyDecorator();
super.report();
}
/** * 给出建议 */@Overridepublicvoiddiscuss(Stringdiscuss) {
System.out.println("表现好就可以骄傲了？我骄傲过吗？");
}
}
publicclassRankDecortaorextendsDecorator {
publicRankDecortaor(SchoolReportschoolReport) {
super(schoolReport);
}
privatevoidrankDecortaor(){
System.out.println("在学校排名也很靠前");
}
@Overridepublicvoidreport() {
rankDecortaor();
super.report();
}
@Overridepublicvoiddiscuss(Stringdiscuss) {
System.out.println("学校的排名这么靠前，还需要啥建议？建议低调一点，继续保持!");
}
}
publicclassSuagrFouthGradeSchoolReportextendsFouthGradeSchoolReport {
/** * 先把最高成绩说出去 */privatevoidreportHighSorce(){
System.out.print("我英语得了90分,语文得了80分. ");
}
@Overridepublicvoidreport() {
reportHighSorce();
super.report();
}
}
packagecn.ucaner.pattern.structure.decorator;
importcn.ucaner.pattern.structure.decorator.decoratorAbs.SchoolReport;
importcn.ucaner.pattern.structure.decorator.decoratorIml.FouthGradeSchoolReport;
importcn.ucaner.pattern.structure.decorator.decoratorIml.GoodBoyDecortaor;
importcn.ucaner.pattern.structure.decorator.decoratorIml.RankDecortaor;
importcn.ucaner.pattern.structure.decorator.decoratorIml.SuagrFouthGradeSchoolReport;
/*** @Package：cn.ucaner.pattern.structure.decorator * @ClassName：DecoratorMain * @Description： <p> 装饰器模式 - 装饰器模式运行类 * {@link https://www.cnblogs.com/octobershiner/archive/2011/11/04/2236730.html}* </p>* @Author： - * @CreatTime：2017年10月26日 下午5:15:16 * @Modify By： * @ModifyTime： * @Modify marker： * @version V1.0 */publicclassDecoratorMain {
publicstaticvoidmain(String[] args) {
absDecorator();
extendsDecorator();
normol();
}
/** * @Description: 一般情况下 -- 没有包装的情况下 * @Autor: Jason  */privatestaticvoidnormol(){
System.out.println("****************没有包装成绩的情况下*********************");
//把成绩单领回家SchoolReportschoolReport=newFouthGradeSchoolReport();
//家长看成绩单schoolReport.report();
schoolReport.sign(" 大家好我是校长");
//schoolReport.discuss("我建议你别浪费钱!");//准备挨打System.out.println("********************************************************");
}
/** * @Description:如果用继承装饰 * @Autor: Jason */privatestaticvoidextendsDecorator(){
/** * 这里是被包装了的成绩单 家长看到的只是比较好的成绩 */SchoolReportschoolReport = newSuagrFouthGradeSchoolReport();
/** * 看成绩单 */schoolReport.report();
/** * 签字确认 */schoolReport.sign("马化腾");
/** * 继承方式的弊端,如果以后要有五年级 六年级 七年级的成绩单, * 那么需要你分别对这几个年级的成绩单进行装饰, * 如果需要装饰的条件一旦很多,比如说平时表现啊什么的,就得一一去装饰,带来类的爆炸性增长, **/
}
/** * @Description: 利用抽象装饰 * @Autor: Jason */privatestaticvoidabsDecorator(){
// ******************************** CallMethod Start *****************************************/** * 原始的成绩 -- 没有经过包装的成绩 */SchoolReportschoolReport=newFouthGradeSchoolReport();
/** * 装饰表现 */schoolReport=newGoodBoyDecortaor(schoolReport);
/** * 装饰排名 */schoolReport=newRankDecortaor(schoolReport);
/** * 装饰了几次后 - 开始报告成绩! */schoolReport.report();
/** * 查阅者签名确认 */schoolReport.sign("马云");
schoolReport.discuss("建议好好读书！"); //这里没有打印出来// ******************************** CallMethod End *****************************************
}
}

桥接模式

桥接模式即将抽象部分与它的实现部分分离开来，使他们都可以独立变化
桥接模式将继承关系转化成关联关系，它降低了类与类之间的耦合度，减少了系统中类的数量，也减少了代码量

packagecn.ucaner.pattern.structure.bridge.abs;
/*** @Package：cn.ucaner.pattern.structure.bridge.abs * @ClassName：Abstraction * @Description： <p> 桥接模式 --- 抽象化角色</p>* <pre> 桥接Bridge是用于把 [抽象化与实现化]解耦，使得二者可以独立变化 </pre>* @Author： - * @CreatTime：2017年10月26日 下午5:58:30 * @Modify By： * @ModifyTime： * @Modify marker： * @version V1.0 */publicabstractclassAbstraction{
/** * Implementor 实现器 - 其实就是 抽象化 和 实现化 解耦  */privateImplementorimplementor;
publicAbstraction(Implementorimplementor) {
this.implementor = implementor;
}
publicvoiddoSomethings(){
System.out.println("Abs 开始搞事情!");
implementor.doSomethingA();
implementor.doSomethingB();
System.out.println("Abs 搞事情完毕!");
}
publicImplementorgetImplementor(){
returnimplementor;
}
}
packagecn.ucaner.pattern.structure.bridge.abs;
/*** @Package：cn.ucaner.pattern.structure.bridge.abs * @ClassName：Implementor * @Description： <p> 桥接模式 --- 实现化角色 </p>* @Author： - * @CreatTime：2017年10月26日 下午5:58:48 * @Modify By： * @ModifyTime： * @Modify marker： * @version V1.0 */publicinterfaceImplementor {
/** * @Description: doSomethingA * @Autor: Jason */publicvoiddoSomethingA();
/** * @Description: doSomethingB * @Autor: Jason */publicvoiddoSomethingB();
}
packagecn.ucaner.pattern.structure.bridge;
importcn.ucaner.pattern.structure.bridge.abs.Implementor;
/*** @Package：cn.ucaner.pattern.structure.bridge * @ClassName：ConcreteImplementor * @Description： <p> 桥接模式 -- 具体实现类</p>* @Author： - * @CreatTime：2017年10月26日 下午5:59:37 * @Modify By： * @ModifyTime： * @Modify marker： * @version V1.0 */publicclassConcreteImplementorimplementsImplementor {
@OverridepublicvoiddoSomethingA() {
System.out.println("bridge do something A");
}
@OverridepublicvoiddoSomethingB() {
System.out.println("bridge do something B");
}
}
packagecn.ucaner.pattern.structure.bridge;
importcn.ucaner.pattern.structure.bridge.abs.Implementor;
/*** * @Package：cn.ucaner.pattern.structure.bridge * @ClassName：BridgeMain * @Description： <p> 桥接模式 -- 执行类</p>* @Author： - * @CreatTime：2017年10月26日 下午5:59:16 * @Modify By： * @ModifyTime： * @Modify marker： * @version V1.0 */publicclassBridgeMain {
publicstaticvoidmain(String[] args) {
/** * 实现化角色 */Implementorimplementor = newConcreteImplementor();
/** * 抽象化角色 */RefinedAbstractionrefinedAbstraction = newRefinedAbstraction(implementor);
/** * 抽象化角色搞事情 */refinedAbstraction.doSomethings();
implementor.doSomethingA();
implementor.doSomethingB();
}
}

组合模式

享元模式

String常量池、数据库连接池、缓冲池等等都是享元模式的应用，所以说享元模式是池技术的重要实现方式.

packagecn.ucaner.pattern.structure.flyweight.flyweightAbs;
/** * @Package：cn.ucaner.pattern.structure.flyweight.flyweightAbs * @ClassName：Shape * @Description： <p> Shape </p>* @Author： - Jason * @CreatTime：2018年10月18日 下午2:22:23 * @Modify By： * @ModifyTime： 2018年10月18日* @Modify marker： * @version V1.0*/publicabstractclassShape {
/** * 内部状态 */privateStringintrinsic;
/** * @Description: 假如我们有一个绘图的应用程序，通过它我们可以出绘制各种 * 各样的形状、颜色的图形，那么这里形状和颜色就是内部状态了 * 通过享元模式我们就可以实现该属性的共享了 * @Autor: Jason */publicabstractvoiddraw();
publicStringgetIntrinsic() {
returnintrinsic;
}
publicvoidsetIntrinsic(Stringintrinsic) {
this.intrinsic = intrinsic;
}
}
publicclassCircleextendsShape{
privateStringcolor;
publicCircle(Stringcolor){
this.color = color;
}
@Overridepublicvoiddraw() {
System.out.println("Draw a Circle Which Color is " + color +".");
}
}
publicclassDrawFactory {
/** * 定义一个池容器 - 享元池 */privatestaticHashMap<String,Shape> colorsPool = newHashMap<String,Shape>();
/** * @Description: 获取对象 * @param color * @return Shape * @Autor: Jason */publicstaticShapegetShape(Stringcolor){
/** * 需要返回的对象 */Shapeshape = null;
if(colorsPool.containsKey(color)){
shape = colorsPool.get(color); //外部状态
}else {
shape = newCircle(color); //如果不存在的话创建 放入池子中colorsPool.put(color,shape);
}
returnshape;
}
/** * @Description: 获取池的大小 * @return int 池子大小 * @Autor: Jason */publicstaticintgetPoolSize(){
returncolorsPool.size();
}
}
packagecn.ucaner.pattern.structure.flyweight;
importcn.ucaner.pattern.structure.flyweight.flyweightAbs.Shape;
/** * @Package：cn.ucaner.pattern.structure.flyweight * @ClassName：DrawMain * @Description： <p> DrawMain </p>* @Author： - Jason * @CreatTime：2018年10月18日 下午2:28:01 * @Modify By： * @ModifyTime： 2018年10月18日* @Modify marker： * @version V1.0*/publicclassDrawMain {
publicstaticvoidmain(String[] args) {
Shapeshape1 = DrawFactory.getShape("RED");
Shapeshape2 = DrawFactory.getShape("GREY");
Shapeshape3 = DrawFactory.getShape("GREEN");
Shapeshape4 = DrawFactory.getShape("RED");
Shapeshape5 = DrawFactory.getShape("GREY");
Shapeshape6 = DrawFactory.getShape("GREY");
shape1.draw();
shape2.draw();
shape3.draw();
shape4.draw();
shape5.draw();
shape6.draw();
System.out.println("一共绘制了" + DrawFactory.getPoolSize() + "种颜色的圆形.");
}
}

责任链模式

抽象处理者(Handler)角色：定义出一个处理请求的接口。如果需要，接口可以定义出一个方法以设定和返回对下家的引用。这个角色通常由一个Java抽象类或者Java接口实现。上图中Handler类的聚合关系给出了具体子类对下家的引用，抽象方法handleRequest()规范了子类处理请求的操作。
具体处理者(BossHandler)角色：具体处理者接到请求后，可以选择将请求处理掉，或者将请求传给下家。由于具体处理者持有对下家的引用，因此，如果需要，具体处理者可以访问下家。

publicabstractclassHandler {
/** * 下一个执行者 */privateHandlernextHandler;
/** * @Description: 当前执行者对请求做处理 需要处理的Biz对象 * @param handLeve * @return boolean * @Autor: Jason - jasonandy@hotmail.com */publicfinalbooleanhandlerRequst(inthandLeve){
booleanbReq=false;
/** * 判断自己是否可以审核 - 可以审核的话 直接审核完毕 */if(getLevel()>=handLeve){
System.out.println(getnName()+" :可以审批");
returntrue;
}else {
if(this.nextHandler!=null){
/** * 超过阈值 向上一级提交申请 *///System.out.println(String.format("金额%s超过%s的审核级别 向上一级%s提交申请 ",handLeve,getnName(), nextHandler.getnName()));System.out.println(getnName()+"向"+nextHandler.getnName()+"递交请求");
/** * 向上一级请求 */bReq=nextHandler.handlerRequst(handLeve);
/** * 根据上级的答复做出回应 */if(bReq){
System.out.println(getnName()+" :"+nextHandler.getnName()+"说可以审批");
}else {
System.out.println(getnName()+" :"+nextHandler.getnName()+"说不可以审批");
}
}else {
/** * 到这边已经没有下一个处理者了  */System.out.println(getnName()+" :金额太大了");
}
}
returnbReq;
}
publicvoidsetNextHandler(HandlernextHandler) {
this.nextHandler = nextHandler;
}
/** * @Description: 可以审批的金额 * @return int * @Autor: Jason - jasonandy@hotmail.com */publicabstractintgetLevel();
/** * @Description: 处理者名字 * @return String * @Autor: Jason - jasonandy@hotmail.com */publicabstractStringgetnName();
}
publicclassBossHandlerextendsHandler {
privateintmoneny;
@OverridepublicintgetLevel() {
returnthis.moneny;
}
@OverridepublicStringgetnName() {
return"BOSS";
}
publicintgetMoneny() {
returnmoneny;
}
publicvoidsetMoneny(intmoneny) {
this.moneny = moneny;
}
/** 	* BossHandler. 	* @param moneny 	*/publicBossHandler(intmoneny) {
super();
this.moneny = moneny;
}
}
publicclassChainOfReponsibilityMain {
publicstaticvoidmain(String[] args) {
/** * 我要报销的钱数 */intmoney=10000;
/** * 初始化各个处理者 */Handlermanager = newManagerHandler(200); Handlerfinance = newFinanceHandler(500);
Handlerboss = newBossHandler(1000);
//manager -> finace -> boss/** * 设置链中的顺序 */manager.setNextHandler(finance);
finance.setNextHandler(boss);
//do System.out.println("I want 报销 "+money+" yuan.");
if (manager.handlerRequst(money)) {
System.out.println("报销Success!");
} else {
System.out.println("报销Fail!");
}
}
}

命令模式

将一个请求封装为一个对象，从而让我们可用不同的请求对客户进行参数化；对请求排队或者记录请求日志，以及支持可撤销的操作。命令模式是一种对象行为型模式，其别名为动作(Action)模式或事务(Transaction)模式。
命令模式的定义比较复杂，提到了很多术语，例如“用不同的请求对客户进行参数化”、“对请求排队”，“记录请求日志”、“支持可撤销操作”等，在后面我们将对这些术语进行一一讲解

publicabstractclassCommand {
/** * 项目经理 */protectedProjecterpm = newProjecter();
/** * 产品经理 */protectedProductproduct = newProduct();
/** * UI */protectedUIui = newUI();
/** * 码农实现 */protectedCodecode =newCode();
/* private List<Group> gps;	public List<Group> getGps() { return gps;	}	public void setGps(List<Group> gps) { this.gps = gps;	}*//** * @Description: execute * @Autor: Jason - jasonandy@hotmail.com */publicabstractvoidexecute();
}
publicabstractclassGroup {
/** * @Description: 得到命令 * @Autor: Jason - jasonandy@hotmail.com */publicabstractvoidgetCommand();
/** * @Description: 新增一个功能 * @Autor: Jason - jasonandy@hotmail.com */publicabstractvoiddoAdd();
/** * @Description: 减去一个功能 * @Autor: Jason - jasonandy@hotmail.com */publicabstractvoiddoDel();
/** * @Description: 开始实施 * @Autor: Jason - jasonandy@hotmail.com */publicabstractvoidplan();
}
publicclassCodeextendsGroup {
@OverridepublicvoidgetCommand() {
System.out.println("开发收到命令");
}
@OverridepublicvoiddoAdd() {
System.out.println("开发新写了一个页面");
}
@OverridepublicvoiddoDel() {
System.out.println("开发注释了一个页面");
}
@Overridepublicvoidplan() {
System.out.println("开发变更完毕");
}
}
publicclassCommandMain {
/** * @Description: Just for test * @Autor: Jason- jasonandy@hotmail.com */publicstaticvoidmain(String[] args) {
Invokerinvoker=newInvoker();
invoker.setCommand(newAddPageCommand());
invoker.Call();
}
}
publicclassInvoker {
privateCommandcommand;
publicvoidsetCommand(Commandcommand) {
this.command = command;
}
publicvoidCall() {
this.command.execute();
}
}

观察者模式

在对象之间定义了一对多的依赖，这样一来，当一个对象改变状态，依赖它的对象会收到通知并自动更新
其实就是发布订阅模式，发布者发布信息，订阅者获取信息，订阅了就能收到信息，没订阅就收不到信息

publicinterfaceObserverInf {
/** * @Description: 更新数据 - 数据发生改变的时候通知到其他地方. * @param temp 温度 * @param humidity 湿度 * @param pressure 气压 * @Autor: Jason */publicvoidupdate(floattemperature, floathumidity, floatpressure);
}

publicinterfaceDisplayElement {
/** * @Description: 外观显示方法 - 展示 被观察者 的具体的信息的方法. * @Autor: Jason */publicvoiddisplay();
/** * @Description:开始同步数据. * @Autor: Jason */publicvoidsysnc();
}
publicclassForecastDisplayimplementsObserverInf, DisplayElement{
privatefloatcurrentPressure = 28.82f; // 当前气压privatefloatlastPressure; // 上一次的气压privateSubjectweatherData; // 主题publicForecastDisplay(SubjectweatherData) {
this.weatherData = weatherData;
this.weatherData.registerObserver(this);
}
@Overridepublicvoiddisplay() {
if (currentPressure > lastPressure) {
System.out.println("NO.3: 天气预报：温度正在持续上升！");
} else {
System.out.println("NO.3: 天气预报：注意气温下降了，可能有雨！");
}
}
@Overridepublicvoidupdate(floattemperature, floathumidity, floatpressure) {
lastPressure = currentPressure;
currentPressure = pressure;
display();
}
@Overridepublicvoidsysnc() {
System.out.println("FORECASTDISPLAY - 开始数据同步.");
}
}
publicinterfaceSubject {
/** * @Description: 添加一个观察者 * @param observer observer  * @Autor: Jason - jasonandy@hotmail.com */publicvoidAttach(Observerobserver);
/** * @Description: 删除一个观察者 * @param observer observer * @Autor: Jason - jasonandy@hotmail.com */publicvoidDetach(Observerobserver);
/** * @Description: 通知所有的观察者 * @Autor: Jason - jasonandy@hotmail.com */publicvoidNotify();
}
publicclassWeatherDataimplementsSubject{
/** * 所有的订阅者 都存放到一起. - 维护所有注册的观察者 - 注册到这里  * 链表方便Obj的添加删除操作. */privateLinkedList<ObserverInf> observers;
/** *温度  */privatefloattemperature; /** * 湿度 */privatefloathumidity; /** * 气压 */privatefloatpressure; /** * 构造时 - new出列表对象 * WeatherData. */publicWeatherData(){
observers = newLinkedList<ObserverInf>();
}
/** * @Description: 将观察者注册到列表中  * @param o 观察者 * @Autor: Jason */@OverridepublicvoidregisterObserver(ObserverInfo) {
observers.add(o);
}
/** * @Description: 移除 * @param o 取消订阅的观察者 * @Autor: Jason */@OverridepublicvoidremoveObserver(ObserverInfo) {
inti = observers.indexOf(o); //判断对象是不是在订阅者之中 要是存在的话就移除if (i >= 0){
observers.remove(i);
}else {
System.out.println(o.toString()+"没有订阅过，无法进行退订操作!");
}
}
/** * @Description: 通知订阅列表里的所有的订阅者 * @Autor: Jason */@OverridepublicvoidnotifyObservers() {
for (ObserverInfobserverInf : observers) {
observerInf.update(temperature, humidity, pressure);
}
/* for (int i = 0; i < observers.size(); ++i){ ObserverInf observerInf = (ObserverInf)observers.get(i); observerInf.update(temperature, humidity, pressure); }*/
}
/** * @Description: 当数据发生改变的时候 推送给订阅的人 * @Autor: Jason */publicvoidmeasurementsChanged(){
notifyObservers();
}
publicvoidsetMeasurements(floattemperature, floathumidity, floatpressure){
this.temperature = temperature;
this.humidity = humidity;
this.pressure = pressure;
measurementsChanged(); //发生改变 通知所有的订阅者
}
}
publicinterfaceSubject {
/** * @Description: 用以注册观察者 - 也就是都有谁来关注这个 可以理解为订阅这个消息 * @param o 具体的观察者 * @Autor: Jason */publicvoidregisterObserver(ObserverInfo);
/** * @Description: 用以删除观察者 - 也就会谁会来退订这个所观察的对象 - 可以通俗的理解为退订 * @param o 具体的观察者 * @Autor: Jason */publicvoidremoveObserver(ObserverInfo);
/** * @Description: 来通知这个观察者  * @Autor: Jason */publicvoidnotifyObservers();
}

状态模式

定义对象间的一种一对多的依赖关系,当一个对象的状态发生改变时,所有依赖于它的对象都得到通知并被自动更新。允许一个对象在其内部状态改变时改变它的行为。对象看起来似乎修改了它的类
1.一个对象的行为取决于它的状态,并且它必须在运行时刻根据状态改变它的行为。
2.一个操作中含有庞大的多分支的条件语句，且这些分支依赖于该对象的状态。

publicclassContext {
/** * 定义出所有的电梯状态 用在setState() 枚举状态. */publicstaticfinalOpenopen = newOpen(); //打开状态publicstaticfinalCloseclose = newClose();//关闭状态publicstaticfinalRunrun = newRun();//运行状态publicstaticfinalStopstop = newStop();//停止状态/** * 当前的状态 */privateStatenowState;
publicvoidsetNowState(StatenowState) {
this.nowState = nowState;
/** * this --> context [其实就是nowContext] */this.nowState.setContext(this);
}
publicStategetNowState() {
returnnowState;
}
publicvoidopen(){
nowState.open();
}
publicvoidclose(){
nowState.close();
}
publicvoidrun(){
nowState.run();
}
publicvoidstop(){
nowState.stop();
}
}
publicabstractclassState {
/** * Context - 状态模式的上下文. */protectedContextcontext;
/** * @Description: 设置状态 * @param context  * @Autor: Jason */publicvoidsetContext(Contextcontext) {
this.context = context;
}
/** * @Description: 电梯门开启的动作 * @Autor: Jason */publicabstractvoidopen();
/** * @Description: 电梯门关闭的动作 * @Autor: Jason */publicabstractvoidclose();
/** * @Description:电梯运行起来 * @Autor: Jason */publicabstractvoidrun();
/** * @Description:电梯停下来 * @Autor: Jason */publicabstractvoidstop();
}
publicclassCloseextendsState {
/** * context - state的context  */@Overridepublicvoidopen() {
//状态修改context.setNowState(Context.open); //设置为open状态//委托执行 context.getNowState().open();
}
@Overridepublicvoidclose() {
System.out.print("电梯门关闭");
}
//运行@Overridepublicvoidrun() {
//状态修改context.setNowState(Context.run);
//委托执行context.getNowState().run();
}
//停止@Overridepublicvoidstop() {
//状态修改context.setNowState(Context.stop);
//委托执行context.getNowState().stop();
}
}
publicclassOpenextendsState {
/** * 开启 */@Overridepublicvoidopen() {
System.out.println("OPEN-电梯门Open.");
}
/** * 关闭  */@Overridepublicvoidclose() {
//状态修改context.setNowState(Context.close);
//委托执行context.getNowState().close();
}
/** * 开着门不能跑 */@Overridepublicvoidrun() {
// by JasonSystem.out.println("RUN-开着门不能Run.!");
}
/** * 开着门就是停止的 */@Overridepublicvoidstop() {
//by JasonSystem.out.println("STOP-开着门就是Stop.!");
}
}
publicclassRunextendsState {
/** * 运行状态不能开门 */@Overridepublicvoidopen() {
//状态修改 by JsonSystem.out.println("OPEN-Run状态不能开门!");
}
/** * 运行状态门就是关着的 */@Overridepublicvoidclose() {
//by JasonSystem.out.println("CLOSE-Run状态门就是关着的!");
}
@Overridepublicvoidrun() {
System.out.println("RUN-电梯正在Run.");
}
/** * 停止运行 */@Overridepublicvoidstop() {
context.setNowState(Context.stop); //Run -->Stop context.getNowState().stop();
}
}
publicclassStopextendsState {
/** * 停下来 然后开启电梯. */@Overridepublicvoidopen() {
context.setNowState(Context.open);
context.getNowState().open();
}
@Overridepublicvoidclose() {
System.out.println("Closed. - 电梯Close.");
}
@Overridepublicvoidrun() {
context.setNowState(Context.run);
context.getNowState().run();
}
@Overridepublicvoidstop() {
System.out.println("Stop-电梯停止了");
}
}

访问者模式

访问者模式是对象的行为模式。访问者模式的目的是封装一些施加于某种数据结构元素之上的操作。一旦这些操作需要修改的话，接受这个操作的数据结构则可以保持不变
变量被声明时的类型叫做变量的静态类型(Static Type)，有些人又把静态类型叫做明显类型(Apparent Type)；而变量所引用的对象的真实类型又叫做变量的实际类型(Actual Type)。

//被观察的主体publicinterfaceSubject {
/** * @Description: 用以注册观察者 - 也就是都有谁来关注这个 可以理解为订阅这个消息 * @param o 具体的观察者 * @Autor: Jason */publicvoidregisterObserver(ObserverInfo);
/** * @Description: 用以删除观察者 - 也就会谁会来退订这个所观察的对象 - 可以通俗的理解为退订 * @param o 具体的观察者 * @Autor: Jason */publicvoidremoveObserver(ObserverInfo);
/** * @Description: 来通知这个观察者  * @Autor: Jason */publicvoidnotifyObservers();
}
//观察者接口 - 可以理解为 订阅者接口 publicinterfaceObserverInf {
/** * @Description: 更新数据 - 数据发生改变的时候通知到其他地方. * @param temp 温度 * @param humidity 湿度 * @param pressure 气压 * @Autor: Jason */publicvoidupdate(floattemperature, floathumidity, floatpressure);
}
//消息的发布方式publicclassForecastDisplayimplementsObserverInf, DisplayElement{
privatefloatcurrentPressure = 28.82f; // 当前气压privatefloatlastPressure; // 上一次的气压privateSubjectweatherData; // 主题publicForecastDisplay(SubjectweatherData) {
this.weatherData = weatherData;
this.weatherData.registerObserver(this);
}
@Overridepublicvoiddisplay() {
if (currentPressure > lastPressure) {
System.out.println("3,天气预报：温度正在持续上升！");
} else {
System.out.println("3,天气预报：注意气温下降了，可能有雨！");
}
}
@Overridepublicvoidupdate(floattemperature, floathumidity, floatpressure) {
lastPressure = currentPressure;
currentPressure = pressure;
display();
}
@Overridepublicvoidsysnc() {
System.out.println("FORECASTDISPLAY - 开始数据同步.");
}
}
//发布模式的接口 - 订阅的方式publicinterfaceDisplayElement {
/** * @Description: 外观显示方法 - 展示 被观察者 的具体的信息的方法. * @Autor: Jason */publicvoiddisplay();
/** * @Description:开始同步数据. * @Autor: Jason */publicvoidsysnc();
}

享元模式 🐶

“享”就是分享之意，指一物被众人共享，而这也正是该模式的终旨所在
享元模式有点类似于单例模式，都是只生成一个对象来被共享使用。这里有个问题，那就是对共享对象的修改，为了避免出现这种情况，我们将这些对象的公共部分，或者说是不变化的部分抽取出来形成一个对象。这个对象就可以避免到修改的问题。
享元的目的是为了减少不会要额内存消耗，将多个对同一对象的访问集中起来，不必为每个访问者创建一个单独的对象，以此来降低内存的消耗。

/** * <html> * <body> * <P> Copyright JasonInternational</p> * <p> All rights reserved.</p> * <p> Created on 2018年10月18日 下午2:22:23</p> * <p> Created by Jason </p> * </body> * </html> */packagecn.ucaner.pattern.structure.flyweight.flyweightAbs;
/*** @Package：cn.ucaner.pattern.structure.flyweight.flyweightAbs* @ClassName：Shape* @Description： <p> Shape </p>* @Author： - Jason* @CreatTime：2018年10月18日 下午2:22:23* @Modify By：* @ModifyTime： 2018年10月18日* @Modify marker：* @version V1.0*/publicabstractclassShape {
/** * 内部状态 */privateStringintrinsic;
/** * @Description: 假如我们有一个绘图的应用程序，通过它我们可以出绘制各种 * 各样的形状、颜色的图形，那么这里形状和颜色就是内部状态了 * 通过享元模式我们就可以实现该属性的共享了 * @Autor: Jason */publicabstractvoiddraw();
publicStringgetIntrinsic() {
returnintrinsic;
}
publicvoidsetIntrinsic(Stringintrinsic) {
this.intrinsic = intrinsic;
}
}
/** * <html> * <body> * <P> Copyright JasonInternational</p> * <p> All rights reserved.</p> * <p> Created on 2018年10月18日 下午2:23:26</p> * <p> Created by Jason </p> * </body> * </html> */packagecn.ucaner.pattern.structure.flyweight;
importcn.ucaner.pattern.structure.flyweight.flyweightAbs.Shape;
/*** @Package：cn.ucaner.pattern.structure.flyweight* @ClassName：Circle* @Description： <p> Circle </p>* @Author： - Jason* @CreatTime：2018年10月18日 下午2:23:26* @Modify By：* @ModifyTime： 2018年10月18日* @Modify marker：* @version V1.0*/publicclassCircleextendsShape{
privateStringcolor;
publicCircle(Stringcolor){
this.color = color;
}
@Overridepublicvoiddraw() {
System.out.println("Draw a Circle Which Color is " + color +".");
}
}
/** * <html> * <body> * <P> Copyright JasonInternational</p> * <p> All rights reserved.</p> * <p> Created on 2018年10月18日 下午2:24:40</p> * <p> Created by Jason </p> * </body> * </html> */packagecn.ucaner.pattern.structure.flyweight;
importjava.util.HashMap;
importcn.ucaner.pattern.structure.flyweight.flyweightAbs.Shape;
/*** @Package：cn.ucaner.pattern.structure.flyweight* @ClassName：DrawFactory* @Description： <p> DrawFactory </p>* @Author： - Jason* @CreatTime：2018年10月18日 下午2:24:40* @Modify By：* @ModifyTime： 2018年10月18日* @Modify marker：* @version V1.0*/publicclassDrawFactory {
/** * 定义一个池容器 - 享元池 */privatestaticHashMap<String,Shape> colorsPool = newHashMap<String,Shape>();
/** * @Description: 获取对象 * @param color * @return Shape * @Autor: Jason */publicstaticShapegetShape(Stringcolor){
/** * 需要返回的对象 */Shapeshape = null;
if(colorsPool.containsKey(color)){
shape = colorsPool.get(color); //外部状态
}else {
shape = newCircle(color); //如果不存在的话创建 放入池子中colorsPool.put(color,shape);
}
returnshape;
}
/** * @Description: 获取池的大小 * @return int 池子大小 * @Autor: Jason */publicstaticintgetPoolSize(){
returncolorsPool.size();
}
}
/** * <html> * <body> * <P> Copyright JasonInternational</p> * <p> All rights reserved.</p> * <p> Created on 2018年10月18日 下午2:28:01</p> * <p> Created by Jason </p> * </body> * </html> */packagecn.ucaner.pattern.structure.flyweight;
importcn.ucaner.pattern.structure.flyweight.flyweightAbs.Shape;
/*** @Package：cn.ucaner.pattern.structure.flyweight* @ClassName：DrawMain* @Description： <p> DrawMain </p>* @Author： - Jason* @CreatTime：2018年10月18日 下午2:28:01* @Modify By：* @ModifyTime： 2018年10月18日* @Modify marker：* @version V1.0*/publicclassDrawMain {
publicstaticvoidmain(String[] args) {
Shapeshape1 = DrawFactory.getShape("RED");
Shapeshape2 = DrawFactory.getShape("GREY");
Shapeshape3 = DrawFactory.getShape("GREEN");
Shapeshape4 = DrawFactory.getShape("RED");
Shapeshape5 = DrawFactory.getShape("GREY");
Shapeshape6 = DrawFactory.getShape("GREY");
shape1.draw();
shape2.draw();
shape3.draw();
shape4.draw();
shape5.draw();
shape6.draw();
System.out.println("一共绘制了" + DrawFactory.getPoolSize() + "种颜色的圆形.");
}
}

FAQ

设计模式学习

ENV

JDK 1.8
Intellij IDEA 14
Git
gitHub
gitee

Contact

QQ:603043194
E-Mail: jasonandy@hotmail.com

License

开源协议 Apache License, Version 2.0

Name		Name	Last commit message	Last commit date
Latest commit History 39 Commits
src/cn/ucaner/pattern		src/cn/ucaner/pattern
.gitignore		.gitignore
README.md		README.md
pom.xml		pom.xml

Navigation Menu

Repository files navigation

Ucaner

patterns

逻辑结构图

代码结构图

设计模式简述

设计模式的六大原则

工厂方法模式

单例模式

建造者模式

原型模式

适配器模式

代理模式

外观模式

桥接模式

组合模式

享元模式

责任链模式

命令模式

观察者模式

状态模式

访问者模式

享元模式 🐶

FAQ

ENV

Contact

License

About

Releases

Packages

Used by

Contributors

Languages

Folders and files

Latest commit

History

Repository files navigation

Ucaner

patterns

逻辑结构图

代码结构图

设计模式简述

设计模式的六大原则

工厂方法模式

单例模式

建造者模式

原型模式

适配器模式

代理模式

外观模式

桥接模式

组合模式

享元模式

责任链模式

命令模式

观察者模式

状态模式

访问者模式

享元模式 🐶

FAQ

ENV

Contact

License

About

Topics

Resources

Stars

Watchers

Forks

Releases

Packages

Used by

Contributors

Languages