<?xml version="1.0" encoding="utf-8" ?><rss version="2.0"><channel><title><![CDATA[jonlee123的专栏]]></title><description><![CDATA[]]></description><link>https://blog.youkuaiyun.com/jonlee123</link><language>zh-cn</language><generator>https://blog.youkuaiyun.com/</generator><copyright><![CDATA[Copyright &copy; jonlee123]]></copyright><item><title><![CDATA[备忘录模式]]></title><link>https://blog.youkuaiyun.com/jonlee123/article/details/84608094</link><guid>https://blog.youkuaiyun.com/jonlee123/article/details/84608094</guid><author>jonlee123</author><pubDate>Thu, 19 Jun 2014 13:58:24 +0800</pubDate><description><![CDATA[
备忘录模式：保存对象的某一时刻的状态，进行存储
优点：实现对象的回滚，可以对数据进行恢复和保存
 
标准类图：
 主体类：
public class Originator {
	
	private String state;

	public String getState() {
		return state;
	}

	public void setState(S...]]></description><category></category></item><item><title><![CDATA[访问者模式]]></title><link>https://blog.youkuaiyun.com/jonlee123/article/details/84608093</link><guid>https://blog.youkuaiyun.com/jonlee123/article/details/84608093</guid><author>jonlee123</author><pubDate>Thu, 19 Jun 2014 13:58:14 +0800</pubDate><description><![CDATA[
访问者模式：将对象的变化（共享）和不变部分（不共享）进行分离，将变化部分交由具体的访问者执行，访问者可以根据具体的类进行动作
优点：封装不变部分，扩展变化部分，一般是在循环抽象对象时候，由访问者来对不同的具体对象进行操作
 
标准类图：
 抽象元素：
public interface Element {
	
	public void accept(Visitor visitor)...]]></description><category></category></item><item><title><![CDATA[状态模式]]></title><link>https://blog.youkuaiyun.com/jonlee123/article/details/84608091</link><guid>https://blog.youkuaiyun.com/jonlee123/article/details/84608091</guid><author>jonlee123</author><pubDate>Thu, 19 Jun 2014 13:58:01 +0800</pubDate><description><![CDATA[
状态模式：一个对象的内部状态发生改变会引起行为的改变，此种变化会引起类的变化
优点：避免过多的if-else语句，扩展性良好，有很强的封装性
 
标注类图： 
 模拟电梯状态行为：
电梯类：
public class Lift {
	public static final LiftOpenState OPEN_STATE = new LiftOpenState();
	publ...]]></description><category></category></item><item><title><![CDATA[享元模式]]></title><link>https://blog.youkuaiyun.com/jonlee123/article/details/84608090</link><guid>https://blog.youkuaiyun.com/jonlee123/article/details/84608090</guid><author>jonlee123</author><pubDate>Thu, 19 Jun 2014 13:57:49 +0800</pubDate><description><![CDATA[
享元模式：通过池技术，对细粒度对象提供共享支持
优点：节省对象创建时间，减少内存开支，降低性能消耗
 
标准类图：
 抽象享元：
public abstract class FlyWeight {
	
	protected String externalAttribute;//external attribute
	
	public FlyWeight(String exte...]]></description><category></category></item><item><title><![CDATA[空对象模式]]></title><link>https://blog.youkuaiyun.com/jonlee123/article/details/84608089</link><guid>https://blog.youkuaiyun.com/jonlee123/article/details/84608089</guid><author>jonlee123</author><pubDate>Thu, 19 Jun 2014 13:57:38 +0800</pubDate><description><![CDATA[
空对象模式：使用对象继承来实现程序中的空判断
优点：增加程序可读性
空对象接口：
public interface NullObject {
	
	boolean isNull();
	
}
 原对象：
public class Subject implements NullObject{

	private String name;

	public String ...]]></description><category></category></item><item><title><![CDATA[门面模式]]></title><link>https://blog.youkuaiyun.com/jonlee123/article/details/84607656</link><guid>https://blog.youkuaiyun.com/jonlee123/article/details/84607656</guid><author>jonlee123</author><pubDate>Wed, 18 Jun 2014 07:52:19 +0800</pubDate><description><![CDATA[
门面模式：建立一个统一的对象对来提供子系统外部和内部的通讯方式，子系统外部只能通过此对象对子系统内部进行访问
优点：细节隐藏，高层调用不用关心底层实现，避免产生高度的耦合关系
 
标准类图：
 子系统中的类：
public class Class1 {
	
	public void foo4(){
		System.out.println(&quot;foo4&quot;);
	}
	
	p...]]></description><category></category></item><item><title><![CDATA[适配器模式]]></title><link>https://blog.youkuaiyun.com/jonlee123/article/details/84607655</link><guid>https://blog.youkuaiyun.com/jonlee123/article/details/84607655</guid><author>jonlee123</author><pubDate>Wed, 18 Jun 2014 07:52:03 +0800</pubDate><description><![CDATA[
适配器模式：改变遗留对象的抽象（接口），以匹配当前的环境，使得其能够正常的工作
优点：可以让两个没有任何关联的对象匹配在一起运行，而对用调用者来说是透明的，适配器是一种补救措施，在设计阶段一般不考虑。
 
标准类图：
 目标接口：
public interface TargetInterface {
	
	void targetMethod();
	
}
 目标实现：
p...]]></description><category></category></item><item><title><![CDATA[观察者模式]]></title><link>https://blog.youkuaiyun.com/jonlee123/article/details/84607654</link><guid>https://blog.youkuaiyun.com/jonlee123/article/details/84607654</guid><author>jonlee123</author><pubDate>Wed, 18 Jun 2014 07:51:48 +0800</pubDate><description><![CDATA[
观察者模式：定义对象的一对多依赖关系，使得每当一个对象状态更改都会通知关联对象进行自动更新
优点：建立触发机制，观察者和被观察者分离，调用者不用关心具体的观察者行为
 
标准类图：
 抽象主题：
public abstract class Subject {
	
	private List&amp;lt;Observer&amp;gt; observers = new ArrayList&amp;lt;...]]></description><category></category></item><item><title><![CDATA[策略模式]]></title><link>https://blog.youkuaiyun.com/jonlee123/article/details/84607653</link><guid>https://blog.youkuaiyun.com/jonlee123/article/details/84607653</guid><author>jonlee123</author><pubDate>Wed, 18 Jun 2014 07:51:35 +0800</pubDate><description><![CDATA[
策略模式：抽象一个算法，并封装不同的算法，使得不同算法之间可以相互切换。
优点：扩展性良好，不同算法之间可以自由切换，不需要冗余的if-else语句
 
标准类图：
 抽象算法：
 
public interface Strategy {
	
	void algorithm();
	
}
 具体算法：
 
 
public class ConcreteStrateg...]]></description><category></category></item><item><title><![CDATA[中介者模式]]></title><link>https://blog.youkuaiyun.com/jonlee123/article/details/84607652</link><guid>https://blog.youkuaiyun.com/jonlee123/article/details/84607652</guid><author>jonlee123</author><pubDate>Wed, 18 Jun 2014 07:51:21 +0800</pubDate><description><![CDATA[
中介者模式：使用一个中介对象封装对象与其他对象之间的操作行为，使得原本产生交叉蜘蛛网状的对象关系变成星型关系
优点：降低对象与对象之间的耦合，满足迪米特法则
 
标准类图：
  抽象中介者：
public abstract class Mediator {

	protected ConcreteColleague1 concreteColleague1;
	protected...]]></description><category></category></item><item><title><![CDATA[责任链模式]]></title><link>https://blog.youkuaiyun.com/jonlee123/article/details/84605768</link><guid>https://blog.youkuaiyun.com/jonlee123/article/details/84605768</guid><author>jonlee123</author><pubDate>Thu, 12 Jun 2014 08:51:27 +0800</pubDate><description><![CDATA[
责任链模式：将请求封装成一个对象，使得多个对象都有机会对该对象进行处理，这些对象组成一条链状结构，请求延着链条进行传递。
优点：去除冗余的if-else语句，对请求的发出者和请求的接收者进行解耦，通过类间继承关系进行扩展
 
标准类图：
  抽象处理者：
public abstract class Handler {

	private Handler handler;
	
...]]></description><category></category></item><item><title><![CDATA[命令模式]]></title><link>https://blog.youkuaiyun.com/jonlee123/article/details/84605764</link><guid>https://blog.youkuaiyun.com/jonlee123/article/details/84605764</guid><author>jonlee123</author><pubDate>Thu, 12 Jun 2014 08:18:56 +0800</pubDate><description><![CDATA[
命令模式：将请求封装成一个命令，使用命令对象将请求的调用者和接收者进行分离，从而降低耦合性
优点：类间解耦，具有良好的扩展性
 
标准类图：
 抽象接收者：
 
public interface Receiver {
	
	void doSomething();
	
}
 具体接受者：
 
 
public class ConcreteReceiver impleme...]]></description><category></category></item><item><title><![CDATA[装饰模式]]></title><link>https://blog.youkuaiyun.com/jonlee123/article/details/84605762</link><guid>https://blog.youkuaiyun.com/jonlee123/article/details/84605762</guid><author>jonlee123</author><pubDate>Thu, 12 Jun 2014 08:13:04 +0800</pubDate><description><![CDATA[
装饰模式：动态的给一个对象添加额外的职责
优点：以调用者透明的方式，动态的改变对象的行为
使得装饰对象和主题对象独立，降低耦合性
 
装饰模式跟静态代理模式方式非常类似，而关注点不同，装饰模式关注点是对对象行为的增强和减弱，可能会改变主题对象的默认行为，而静态代理模式只是对主题对象的访问控制，不会干预对象的默认行为。
 
标准类图：
 
 
...]]></description><category></category></item><item><title><![CDATA[代理模式]]></title><link>https://blog.youkuaiyun.com/jonlee123/article/details/84605761</link><guid>https://blog.youkuaiyun.com/jonlee123/article/details/84605761</guid><author>jonlee123</author><pubDate>Thu, 12 Jun 2014 08:12:54 +0800</pubDate><description><![CDATA[
代理模式：使用代理对象对源对象进行访问控制
优点： 
1.以调用者透明的方式，动态的改变对象的行为
2.主题对象不会改变，高扩展性，需要产生新的行为通过建立代理对象进行
3.职责明确，不同的代理类进行不同职责的代理，又跟主题对象进行了严格的区别
 
标准类图：
 静态代理：
 抽象主题类：
public interface Subject {
	
	public void...]]></description><category></category></item><item><title><![CDATA[模板方法模式]]></title><link>https://blog.youkuaiyun.com/jonlee123/article/details/84605760</link><guid>https://blog.youkuaiyun.com/jonlee123/article/details/84605760</guid><author>jonlee123</author><pubDate>Thu, 12 Jun 2014 08:12:41 +0800</pubDate><description><![CDATA[
模板方式模式：由父类定义一个算法的骨架，而让具体某些步骤延迟到子类进行实现
模板方法优点：
1.封装不变的部分，扩展变化的部分
2.提取公共部分代码，便于维护
3.行为由父类控制，子类实现
 
标准类图：
 定义抽象类（抽象类中定义模板方法和基础方法，基础方式由子类进行实现）:
public abstract class Hummer {
	
	protected abst...]]></description><category></category></item><item><title><![CDATA[建造者模式]]></title><link>https://blog.youkuaiyun.com/jonlee123/article/details/84605279</link><guid>https://blog.youkuaiyun.com/jonlee123/article/details/84605279</guid><author>jonlee123</author><pubDate>Tue, 10 Jun 2014 12:21:16 +0800</pubDate><description><![CDATA[
建造者模式：将一个复杂对象的创建和它的表示相互分离，使得同样的构建过程可以有不同的表示
建造者模式的优点：
具有很强的封装性，高层调用者不用关心具体对象的组装过程，实现高层调用和对象组装过程的解耦，对象的组装过程也是相互独立的，易于扩展
 
标准类图：
 使用建造者模式构建汽车：
汽车抽象接口：
 
package org.robbie.hibernate.generate.bu...]]></description><category></category></item><item><title><![CDATA[原型模式]]></title><link>https://blog.youkuaiyun.com/jonlee123/article/details/84605256</link><guid>https://blog.youkuaiyun.com/jonlee123/article/details/84605256</guid><author>jonlee123</author><pubDate>Tue, 10 Jun 2014 11:13:18 +0800</pubDate><description><![CDATA[
原型模式：通过克隆对象来进行创建对象
原型模式的优点：
1.原型模式的拷贝属于二进制的拷贝，比new的创建性能更好
2.克隆对象不会调用类的构造函数，可以进行逃避
3.多线程操作同一个对象时，可以通过克隆的方式复制到不同的线程中，避免了线程不安全
 
标准类图只需要实现Cloneable即可
 
public class MyClass implements Cloneable...]]></description><category></category></item><item><title><![CDATA[抽象工厂模式]]></title><link>https://blog.youkuaiyun.com/jonlee123/article/details/84605248</link><guid>https://blog.youkuaiyun.com/jonlee123/article/details/84605248</guid><author>jonlee123</author><pubDate>Tue, 10 Jun 2014 10:57:07 +0800</pubDate><description><![CDATA[
抽象工厂模式跟工厂方式模式类似，不同的是工厂方式模式生产的是一个抽象的产品，而抽象工厂模式生产的是多个抽象的产品。
 
标准类图
 抽象工厂模式：
顶层抽象产品类：
public interface Product {

	String getInfo();
	
}
 第二层抽象产品（抽象出两个不同的产品）
public interface Phone extends Pr...]]></description><category></category></item><item><title><![CDATA[工厂方法模式]]></title><link>https://blog.youkuaiyun.com/jonlee123/article/details/84605234</link><guid>https://blog.youkuaiyun.com/jonlee123/article/details/84605234</guid><author>jonlee123</author><pubDate>Tue, 10 Jun 2014 10:28:19 +0800</pubDate><description><![CDATA[
工厂方法模式：定义一个创建对象的接口，让子类决定实例化哪一个类
工厂模式有点：
1.将对象的创建进行封装，实现细节的隐藏，高层调用者不用关心创建的具体的产品类，只了解产品类的抽象，具体产品类的创建是由工厂进行决定。使调用者和产品的创建进行解耦。
 
标准类图：
一、 简单工厂模式（不需要抽象工厂）
产品抽象类：
public interface Product {

	Stri...]]></description><category></category></item><item><title><![CDATA[单例模式]]></title><link>https://blog.youkuaiyun.com/jonlee123/article/details/84605208</link><guid>https://blog.youkuaiyun.com/jonlee123/article/details/84605208</guid><author>jonlee123</author><pubDate>Tue, 10 Jun 2014 09:36:38 +0800</pubDate><description><![CDATA[
      确保一个类只有一个实例的模式成为单例模式。
单例模式的优点：
1.减少内存开支，降低系统性能消耗
2.避免对资源的多重操作，确保只有一个类实例进行动作
缺点：
1. 没有抽象，没有接口，无法被扩展
2. 并行开发，测试不方便，只有能单例模式开发完毕才能对类进行测试
 
标准类图：
 
 
一、标准的单例模式(预先实例化，项目当推荐使用此模式)
public ...]]></description><category></category></item></channel></rss>