shaofei_huai
shaofei_huai

行为型设计模式

        行为型设计模式目的是将多个类或对象相互协作，共同完成单个类或对象无法单独完成的任务。行为型设计模式共11种，分别为解释器模式、模板方法模式、责任链模式、命令模式、迭代器模式、中介者模式、备忘录模式、观察者模式、状态模式、策略模式、访问者模式。

一、解释器模式

        解释器模式指预先定义一种语法，然后根据语法对传入数据进行解析。例如java中正则表达式解析就是使用该模式。其优点为扩展性好，容易实现，但执行效率较低，并且每种语法对应一种实现，需要建大量类。在解释器模式中存在抽象解释器（AbstractExpression），终结符表达式（TerminalExpression），非终结符表达式（NonterminalExpression），上下文（Context），客户类（Test）五种角色。以简单的规则定义为例，代码如下

新建抽象表达式Expression

/**
 * 抽象表达式：定义所有终结符表达式和非终结符表达式的解释操作
 * 
 * @author huaisf
 *
 */
public interface Expression {

	public boolean interpret(String value);
}

新建非终结符表达式NonterminalExpression

/**
 * 非终结符表达式：实现非终结操作
 * 
 * @author huaisf
 *
 */
public class NonterminalExpression implements Expression {

	private Expression terminalExpression = null;

	public NonterminalExpression(Expression terminalExpression) {
		this.terminalExpression = terminalExpression;
	}

	public boolean interpret(String value) {
		// 没有非终结符，直接调用终结符表达式
		return terminalExpression.interpret(value);
	}
}

新建终结符表达式TerminalExpression

/**
 * 终结符表达式：实现终结操作
 * 
 * @author huaisf
 *
 */
public class TerminalExpression implements Expression {

	private Map map = new HashMap();

	public TerminalExpression(String rule) {
		int index = rule.indexOf(":");
		String city = rule.substring(0, index);
		String scenery = rule.substring(index + 1, rule.length());
		map.put(city, scenery);

	}

	@Override
	public boolean interpret(String value) {
		int index = value.indexOf(":");
		String city = value.substring(0, index);
		String scenery = value.substring(index + 1, value.length());
		String existScenery = map.get(city);
		if (existScenery != null && existScenery.equals(scenery)) {
			return true;
		}
		return false;
	}

}

新建上下文Context

/**
 * 上下文:完成终结表达式初始化，并对要解释的数据进行中转
 * 
 * @author huaisf
 *
 */
public class Context {

	private Expression nonterminalExpression;

	public Context(String rule) {
		Expression terminalExpression = new TerminalExpression(rule);
		nonterminalExpression = new NonterminalExpression(terminalExpression);
	}

	public void matches(String value) {
		boolean isExist = nonterminalExpression.interpret(value);
		if (isExist) {
			System.out.println("城市与景区对应成功");
			return;
		}
		System.out.println("城市与景区对应失败");
	}
}

新建测试类Test

public class Test {

	public static void main(String[] args) {
		// 定义规则为"杭州:西湖"进行验证
		Context context = new Context("杭州:西湖");
		context.matches("杭州:西湖");
		context.matches("苏州:西湖");
		context.matches("苏州:太湖");
	}
}

二、模板方法模式

        模板方法指在一个方法中定义一个算法的骨架，而将一些步骤延迟到子类中。模板方法使得子类可以在不改变算法结构的情况下，重新定义算法中的某些步骤。使用模板方法可提取公共逻辑进行封装，对于非公共操作交由子类执行，但非公共操作如果有改变，则会影响其所有子类。模板方法中分为抽象模板（AbstractTemplate）与具体实现模板（ConcreteTemplate）两种角色。以生产插排为例，代码如下

新建抽象模板Socket

/**
 * 抽象模板:定义具体操作及抽象操作，抽象操作由子类实现
 * 
 * @author huaisf
 *
 */
public abstract class Socket {

	/**
	 * 封装公共逻辑
	 */
	final void create() {

		// 先购买材料
		buyMaterial();

		// 然后材料组装成插排
		assembly();

		// 印上各厂商logo
		printLogo();

	}

	void buyMaterial() {
		System.out.println("购买材料");
	}

	void assembly() {
		System.out.println("材料组装成插排");
	}

	/**
	 * 印上logo
	 */
	abstract void printLogo();

}

新建具体实现模板BullSocket与TCLSocket

/**
 * 具体实现模板:实现父类定义的抽象方法，重写父类逻辑
 * 
 * @author huaisf
 *
 */
public class BullSocket extends Socket {

	@Override
	void printLogo() {
		System.out.println("图上公牛的logo");

	}

}


/**
 * 具体实现模板:实现父类定义的抽象方法，重写父类逻辑
 * 
 * @author huaisf
 *
 */
public class TCLSocket extends Socket {

	@Override
	void printLogo() {
		System.out.println("图上TCL的logo");

	}

}

新建测试类Test

public class Test {

	public static void main(String[] args) {
		// 生产公牛插排
		BullSocket bullSocket = new BullSocket();
		bullSocket.create();

		// 生成tcl插排
		TCLSocket tclSocket = new TCLSocket();
		tclSocket.create();

	}
}

三、责任链模式

        责任链模式是对某个请求的所有处理构成一条链，如果链上的某一处理者可以处理，则处理后返回。如果不能处理则将请求传递给链上的下一个处理者。责任链模式中存在抽象处理者(Handler)与具体处理者(ConcreteHandler)两种角色。以购买插排为例，代码如下：

新建抽象处理者AbstractSocketHandler

/**
 * 抽象处理者:定义处理请求接口
 * 
 * @author huaisf
 *
 */
public abstract class AbstractSocketHandler {

	private AbstractSocketHandler NextHandler;

	public AbstractSocketHandler getNextHandler() {
		return NextHandler;
	}

	public void setNextHandler(AbstractSocketHandler nextHandler) {
		NextHandler = nextHandler;
	}

	/**
	 * 购买插排
	 * 
	 * @param count
	 */
	abstract void buySocket(Integer count);
}

新建具体处理者OriginalPriceSocketHandler、NineDiscountSocketHandler、EightDiscountSocketHandler

/**
 * 具体处理者:对抽象处理者定义的接口进行实现，如果无法处理则将请求传递给下一个处理者
 * 
 * @author huaisf
 *
 */
public class OriginalPriceSocketHandler extends AbstractSocketHandler {

	@Override
	void buySocket(Integer count) {
		if (count <= 500) {
			System.out.println("原价购买插排");
			return;
		}
		this.getNextHandler().buySocket(count);
	}

}

public class NineDiscountSocketHandler extends AbstractSocketHandler {

	@Override
	void buySocket(Integer count) {
		if (count > 500 && count <= 5000) {
			System.out.println("九折购买插排");
			return;
		}
		this.getNextHandler().buySocket(count);
	}
}

public class EightDiscountSocketHandler extends AbstractSocketHandler {

	@Override
	void buySocket(Integer count) {
		if (count > 5000) {
			System.out.println("八折购买插排");
			return;
		}
		this.getNextHandler().buySocket(count);
	}
}

 新建测试类Test组装调用   

public class Test {

	public static void main(String[] args) {
		// 组装责任链
		OriginalPriceSocketHandler originalPriceSocket = new OriginalPriceSocketHandler();
		NineDiscountSocketHandler nineDiscountSocket = new NineDiscountSocketHandler();
		originalPriceSocket.setNextHandler(nineDiscountSocket);
		nineDiscountSocket.setNextHandler(new EightDiscountSocketHandler());

		originalPriceSocket.buySocket(50000);
	}
}

四、命令模式

        命令模式将请求以命令的形式包裹在对象中，并传给调用对象。调用对象寻找可以处理该命令的合适的对象，并把该命令传给相应的对象，由该对象处理请求。命令模式中包括抽象命令（Command）、具体命令（Concrete Command）、接收者（Receiver）、调用者（Invoker）四种角色。使用命令模式可降低系统耦合度，提高扩展性，但每增加一个命令需要新增具体命令类造成类膨胀。以聊天为例，代码如下：

定义操作枚举ChatTypeEnum

public enum ChatTypeEnum {

	GROUP_CHAT("群聊"), 
	PRIVATE_CHAT("私聊");
	
	private String name;

	ChatTypeEnum(String name) {
		this.name = name;
	}
}

新建抽象命令Command


/**
 * 抽象命令：定义执行命令方法
 * 
 * @author huaisf
 *
 */
public interface Command {

	void execute();
}

新建具体命令GroupChatCommand与PrivateChatCommand

/**
 * 具体命令:对定义的抽象命令实现
 * 
 * @author huaisf
 *
 */
public class GroupChatCommand implements Command {

	private ChatRecord chatRecord;

	public GroupChatCommand() {
		chatRecord = new ChatRecord();
	}

	@Override
	public void execute() {
		System.out.println("群聊消息发送给房间内所有人");
		chatRecord.save();
	}

}


public class PrivateChatCommand implements Command {

	private ChatRecord chatRecord;

	public PrivateChatCommand() {
		chatRecord = new ChatRecord();
	}

	@Override
	public void execute() {
		System.out.println("私聊记录发送到对应人");
		chatRecord.save();
	}

}

 新建接受者ChatRecord

/**
 * 接收者:对真正业务进行处理
 * 
 * @author huaisf
 *
 */
public class ChatRecord {

	public void save() {
		System.out.println("保存聊天记录成功");
	}
}

新建调用者CommandManager

/**
 * 调用者：调用具体命令进行处理
 * 
 * @author huaisf
 *
 */
public class CommandManager {

	public static HashMap map = new HashMap<>();

	static {
		map.put(ChatTypeEnum.GROUP_CHAT.name(), new GroupChatCommand());
		map.put(ChatTypeEnum.PRIVATE_CHAT.name(), new PrivateChatCommand());
	}

	public void saveRecord(ChatTypeEnum chatTypeEnum) {
		Command command = map.get(chatTypeEnum.name());
		command.execute();
	}
}

新建测试类Test

public class Test {

	public static void main(String[] args) {
		CommandManager commandManager = new CommandManager();

		// 群聊消息
		commandManager.saveRecord(ChatTypeEnum.GROUP_CHAT);

		// 私聊消息
		commandManager.saveRecord(ChatTypeEnum.PRIVATE_CHAT);
	}
}

五、迭代器模式

        迭代器模式提供一种方法顺序访问一个聚合对象中的各种元素，而又不暴露该对象的内部表示。在迭代器模式中存在抽象容器（Aggregate）、具体容器（ConcreteAggregate）、抽象迭代器（Iterator）、具体迭代器（ConcreteIterator）。使用迭代器模式可以以不同的方式遍历一个聚合对象，并将遍历算法进行封装。但增加新的聚合类需要新增对应迭代器，提高了系统复杂性。下面以数组及集合两种数据结构遍历为例：

新建抽象迭代器AbstractIterator

/**
 * 抽象迭代器:定义遍历元素所需要的方法
 * 
 * @author huaisf
 *
 */
public interface AbstractIterator {

	/**
	 * 获取下一个元素
	 * 
	 * @return
	 */
	Object next();

	/**
	 * 是否有下一个元素
	 * 
	 * @return
	 */
	boolean hashNext();
}

新建具体迭代器ArrayIterator与ListIterator

/**
 * 具体迭代器:对抽象迭代器定义的方法进行实现，本迭代器为数组迭代器
 * @author huaisf
 *
 */
public class ArrayIterator implements AbstractIterator {

	private int index = 0;
	private Object[] array;

	public ArrayIterator(Object[] array){
		this.array=array;
	}
	@Override
	public Object next() {
		if (index <= array.length) {
			return array[index-1];
		}
		return null;
	}

	@Override
	public boolean hashNext() {
		if (index >= array.length) {
			return false;
		}
		index+=1;
		return true;
	}

}


/**
 * 具体迭代器:对抽象迭代器定义的方法进行实现，本迭代器为集合迭代器
 * @author huaisf
 *
 */
public class ListIterator implements AbstractIterator {

	private int index = 0;
	private List list;

	
	public ListIterator(List list){
		this.list=list;
	}
	@Override
	public Object next() {
		if (index <= list.size()) {
			return list.get(index-1);
		}
		return null;
	}

	@Override
	public boolean hashNext() {
		if (index >= list.size()) {
			return false;
		}
		index+=1;
		return true;
	}

}
 
  
新建抽象容器AbstractContainer
 
  
/**
 * 抽象容器:定义容器所需方法
 * 
 * @author huaisf
 *
 */
public interface AbstractContainer {

	void add(Object object);

	void delete(int index);

	AbstractIterator iterator();
}

 
  
新建具体容器ArrayContainer与ListContainer
 
  
/**
 * 具体容器:抽象容器的实现，对数据进行存储，本容器为数组容器
 * 
 * @author huaisf
 *
 */
public class ArrayContainer implements AbstractContainer {
	
	private static Object[] array = new Object[0];
	
	private int size = 0;

	@Override
	public void add(Object object) {
		Object[] temp = new Object[size + 1];
		System.arraycopy(array, 0, temp, 0, size);
		temp[size] = object;
		array = temp;
		size += 1;
	}

	@Override
	public void delete(int index) {
		Object[] temp = new Object[size - 1];
		System.arraycopy(array, 0, temp, 0, index);
		System.arraycopy(array, index + 1, temp, index, size - index - 1);
		array = temp;
		size -= 1;
	}

	@Override
	public AbstractIterator iterator() {
		return new ArrayIterator(array);
	}

}


/**
 * 具体容器:抽象容器的实现，对数据进行存储，本容器为集合容器
 * 
 * @author huaisf
 *
 */
public class ListContainer implements AbstractContainer {
	
	List list = new ArrayList();

	@Override
	public void add(Object object) {
		list.add(object);
		
	}

	@Override
	public void delete(int index) {
		list.remove(index);
		
	}

	@Override
	public AbstractIterator iterator() {
		return new ListIterator(list);
	}

}
 
  
新建测试类Test
 
  
public class Test {

	public static void main(String[] args) {
		// 使用list迭代器
		ListContainer listContainer = new ListContainer();
		for (int i = 0; i < 5; i++) {
			listContainer.add(i);
		}
		AbstractIterator listIterator = listContainer.iterator();
		while (listIterator.hashNext()) {
			System.out.println(listIterator.next());
		}

		// 使用数组迭代器
		ArrayContainer arrayContainer = new ArrayContainer();
		for (int i = 5; i < 10; i++) {
			arrayContainer.add(i);
		}
		AbstractIterator arrayIterator = arrayContainer.iterator();
		while (arrayIterator.hashNext()) {
			System.out.println(arrayIterator.next());
		}
	}
}

 
  
六、中介者模式
 
  
        中介者模式是用一个中介对象来封装一系列的对象交互。中介者使各个对象不需要显式地相互引用，从而使其耦合松散，而且可以独立地改变它们之间的交互。该模式包括抽象中介者（Mediator）、具体中介者（Concrete Mediator）、抽象同事类（Colleague）、具体同事类（Concrete Colleague）四种角色。以买卖房屋为例，代码如下
 
  
定义操作类型OperationTypeEnum，该类型与设计模式无关
 
  
public enum OperationTypeEnum {

	BUY("买房子"), SELL("卖房子");

	private String name;

	OperationTypeEnum(String name) {
		this.name = name;
	}
}

 
  
新建抽象中介者AbstractMediator
 
  
/**
 * 抽象中介者：定义处理同事信息操作，保存同事对象
 * 
 * @author huaisf
 *
 */
public abstract class AbstractMediator {

	BuyHouseUser buyHouseUser;

	SellHouseUser sellHouseUser;

	/**
	 * 转发消息
	 * 
	 * @param type
	 */
	public abstract void contact(OperationTypeEnum type);

	public BuyHouseUser getBuyHouseUser() {
		return buyHouseUser;
	}

	public void setBuyHouseUser(BuyHouseUser buyHouseUser) {
		this.buyHouseUser = buyHouseUser;
	}

	public SellHouseUser getSellHouseUser() {
		return sellHouseUser;
	}

	public void setSellHouseUser(SellHouseUser sellHouseUser) {
		this.sellHouseUser = sellHouseUser;
	}

}

 
  
新建抽象同事类AbstractUser
 
  
/**
 * 抽象同事类：定义同事操作接口，保存中介者对象。
 * 
 * @author huaisf
 *
 */
public abstract class AbstractUser {

	AbstractMediator abstractMediator;

	public AbstractUser(AbstractMediator abstractMediator) {
		this.abstractMediator = abstractMediator;
	}

	/**
	 * 发送消息
	 */
	abstract void send();

	/**
	 * 接收消息
	 */
	abstract void receive();

}

 
  
新建具体同事类BuyHouseUser与SellHouseUser
 
  
/**
 * 具体同事类：对抽象同事类定义方法实现，本类为购房者同事类
 * 
 * @author huaisf
 *
 */
public class BuyHouseUser extends AbstractUser {

	public BuyHouseUser(AbstractMediator abstractMediator) {
		super(abstractMediator);
	}

	@Override
	void send() {
		System.out.println("发送买房请求");
		super.abstractMediator.contact(OperationTypeEnum.BUY);
	}

	@Override
	void receive() {
		System.out.println("收到卖房响应");

	}

}


/**
 * 具体同事类：对抽象同事类定义方法实现，本类为售房者同事类
 * 
 * @author huaisf
 *
 */
public class SellHouseUser extends AbstractUser {

	public SellHouseUser(AbstractMediator abstractMediator) {
		super(abstractMediator);
	}

	@Override
	void send() {
		System.out.println("发送卖房响应");
		super.abstractMediator.contact(OperationTypeEnum.SELL);
	}

	@Override
	void receive() {
		System.out.println("收到买房请求");

	}
}

 
  
新建具体中介者HouseMediator
 
  
/**
 * 具体中介者：实现抽象中介者定义方法，对同事请求进行处理
 * 
 * @author huaisf
 *
 */
public class HouseMediator extends AbstractMediator {

	@Override
	public void contact(OperationTypeEnum type) {
		if (OperationTypeEnum.BUY == type) {
			super.sellHouseUser.receive();
		} else if (OperationTypeEnum.SELL == type) {
			super.buyHouseUser.receive();
		}

	}

}

 
  
新建测试类Test
 
  
public class Test {

	public static void main(String[] args) {
		AbstractMediator mediator = new HouseMediator();
		BuyHouseUser buyHouseUser = new BuyHouseUser(mediator);
		SellHouseUser sellHouseUser = new SellHouseUser(mediator);
		mediator.setBuyHouseUser(buyHouseUser);
		mediator.setSellHouseUser(sellHouseUser);
		buyHouseUser.send();
		sellHouseUser.send();
	}
}

 
  
七、备忘录模式
 
  
        备忘录模式指在不破坏封装性的前提下，获取到一个对象的内部状态，并在对象之外记录或保存这个状态。在有需要的时候可将该对象恢复到原先保存的状态。使用备忘录模式可以对操作对象提供回滚操作，但对资源消耗过大，每操作一次都需要记录操作前数据。备忘录模式中包括发起人（Originator）、备忘录（Memento）、负责人（Caretaker）三种角色。以文档回滚为例，代码如下：
 
  
新建备忘录Memento
 
  
/**
 * 备忘录：保存发起人数据，在需要时提供数据
 * 
 * @author huaisf
 *
 */
public class Memento {
	
	private String content;

	public String getContent() {
		return content;
	}

	public void setContent(String content) {
		this.content = content;
	}

}

 
  
新建发起人Originator
 
  
/**
 * 发起人：定义哪些属于备份数据，提供保存及恢复方法
 * 
 * @author huaisf
 *
 */
public class Originator {
	
	private String content;

	public Memento save() {
		Memento memento = new Memento();
		memento.setContent(content);
		return memento;
	}

	public void rollback(Memento memento) {
		this.content = memento.getContent();

	}

	public String getContent() {
		return content;
	}

	public void setContent(String content) {
		this.content = content;
	}

}

 
  
新建负责人Caretaker
 
  
/**
 * 负责人：对备忘录角色进行管理暂存、提供备忘录
 * 
 * @author huaisf
 *
 */
public class Caretaker {

	private Memento memento;

	public Memento getMemento() {
		return memento;
	}

	public void setMemento(Memento memento) {
		this.memento = memento;
	}

}

 
  
新建测试类Test
 
  
public class Test {

	public static void main(String[] args) {
		Caretaker caretaker = new Caretaker();
		Originator originator = new Originator();
		originator.setContent("文档1");

		System.out.println("第一次保存后文档内容:" + originator.getContent());

		caretaker.setMemento(originator.save());
		originator.setContent("文档2");

		System.out.println("第一次保存后文档内容:" + originator.getContent());

		originator.rollback(caretaker.getMemento());

		System.out.println("回滚后文档内容:" + originator.getContent());

	}
}

 
  
八、观察者模式
 
  
        观察者模式也称发布-订阅模式，该多个观察者同时监听某一个主题对象。当主题对象变化时，会通知所有的观察者对象，使观察者可以更新自身数据。使用观察者模式可以在观察者与主题对象中建立连接关系，构成抽象耦合。但并未完全解耦，并且观察者越多，主题通知观察者耗费时间越长。在观察者模式中包括抽象主题（Subject）、具体主题（Concrete Subject）、抽象观察者（Observer）、具体观察者（Concrete Observer）四种角色。
 
  
新建抽象观察者AbstractObserver
 
  
/**
 * 抽象观察者：定义主题通知时调用方法
 * @author huaisf
 *
 */
public interface AbstractObserver {

	/**
	 * 更新数据
	 */
	void update();
}

 
  
新建具体观察者ConcreteObserverA与ConcreteObserverB
 
  
/**
 * 具体观察者：实现抽象观察者定义的方法，当收到通知时进行自身业务处理
 * 
 * @author huaisf
 *
 */
public class ConcreteObserverA implements AbstractObserver {

	@Override
	public void update() {
		System.out.println("观察者A收到通知，更新数据");

	}

}


public class ConcreteObserverB implements AbstractObserver {

	@Override
	public void update() {
		System.out.println("观察者B收到通知，更新数据");

	}

}

 
  
新建抽象主题AbstractSubject
 
  
/**
 * 抽象主题：定义操作观察者方法
 * @author huaisf
 *
 */
public interface AbstractSubject {

	/**
	 * 添加观察者
	 * 
	 * @param abstractObserver
	 */
	void addObserver(AbstractObserver abstractObserver);

	/**
	 * 通知观察者
	 */
	void noticeObserver();
}

 
  
新建具体主题ConcreteSubject
 
  
/**
 * 具体主题：对抽象观察者定义进行实现
 * 
 * @author huaisf
 *
 */
public class ConcreteSubject implements AbstractSubject {
	List list = new ArrayList<>();

	@Override
	public void addObserver(AbstractObserver abstractObserver) {
		list.add(abstractObserver);

	}

	@Override
	public void noticeObserver() {

		for (AbstractObserver abstractObserver : list) {
			abstractObserver.update();
		}
	}

}

 
  
新建测试类Test
 
  
public class Test {

	public static void main(String[] args) {
		AbstractObserver observerA = new ConcreteObserverA();
		AbstractObserver observerB = new ConcreteObserverB();
		AbstractSubject subject = new ConcreteSubject();
		// 添加观察者
		subject.addObserver(observerA);
		subject.addObserver(observerB);
		// 对观察者进行通知
		subject.noticeObserver();
	}
}

 
  
九、状态模式
 
  
        状态模式定义为允许一个对象在其内部状态改变时改变它的行为。对象看起来似乎修改了它的类。通俗来说当控制一个对象状态转换的条件表达式过于复杂时，可以使用状态模式将状态的判断逻辑转移到表示不同状态的一系列类中，将复杂的判断逻辑简化。使用状态模式可以将复杂逻辑简化到不同子类中，提高扩展性，但同样会造成类膨胀。在状态模式中存在上下文(Context)、抽象状态(State)、具体状态(ConcreteState)三种角色。以开关门状态转换为例，代码如下：
 
  
新建上下文Context
 
  
/**
 * 上下文：定义外部调用方法，存储当前状态
 * 
 * @author huaisf
 *
 */
public class Context {

	private DoorState doorState;

	public Context(DoorState doorState) {
		this.doorState = doorState;
	}

	public DoorState getDoorState() {
		return doorState;
	}

	public void setDoorState(DoorState doorState) {
		this.doorState = doorState;
	}

	public void switchOperation() {
		doorState.switchOperation(this);
	}
}
 
  
新建抽象状态DoorState
 
  
/**
 * 抽象状态:定义不同状态的操作
 * 
 * @author huaisf
 *
 */
public abstract class DoorState {

	/**
	 * 开关操作
	 */
	public abstract void switchOperation(Context context);

}

 
  
新建具体状态CloseDoorState与OpenDoorState
 
  
/**
 * 具体状态：对抽象状态进行实现，在需要时进行状态切换
 * 
 * @author huaisf
 *
 */
public class CloseDoorState extends DoorState {

	@Override
	public void switchOperation(Context context) {
		
		System.out.println("关门");
		
		// 设置下一次状态为开门
		context.setDoorState(new OpenDoorState());

	}

}


public class OpenDoorState extends DoorState {

	@Override
	public void switchOperation(Context context) {
		
		System.out.println("开门");
		
		// 设置下一次状态为关门
		context.setDoorState(new CloseDoorState());

	}

}

 
  
新建测试类Test
 
  
public class Test {

	public static void main(String[] args) {
		Context context = new Context(new OpenDoorState());
		context.switchOperation();
		context.switchOperation();
		context.switchOperation();
		context.switchOperation();
	}
}

 
  
十、策略模式
 
  
      策略模式定义一系列的算法,把每一个算法封装起来, 并且使它们可相互替换，策略模式使得算法可独立于使用它的客户而变化。使用策略模式可自由切换算法，避免多重条件判断，提升扩展性。但每个策略对应一个类，复用性低。在策略模式中存在上下文（Context）、抽象策略角色（Strategy）、具体策略角色（ConcreteStrategy）三种角色。以打折促销为例，代码如下：
 
  
新建抽象策略DiscountStrategy
 
  
/**
 * 抽象策略：定义策略
 * 
 * @author huaisf
 *
 */
public interface DiscountStrategy {

	void buy();
}

 
  
新建具体策略OriginalPriceStrategy与EightDiscountStrategy
 
  
/**
 * 具体策略：对抽象策略进行实现
 * 
 * @author huaisf
 *
 */
public class OriginalPriceStrategy implements DiscountStrategy {

	@Override
	public void buy() {
		System.out.println("原价购买");
	}

}


public class EightDiscountStrategy implements DiscountStrategy {

	@Override
	public void buy() {
		System.out.println("八折购买");
	}

}

 
  
 新建上下文Context
 
  
/**
 * 上下文：定义外部调用方法
 * 
 * @author huaisf
 *
 */
public class Context {
	private DiscountStrategy discountStrategy;

	public Context(DiscountStrategy discountStrategy) {
		this.discountStrategy = discountStrategy;

	}

	public void buy() {
		discountStrategy.buy();
	}
}
 
  
新建测试类Test
 
  
public class Test {

	public static void main(String[] args) {
		// 没有促销互动，原价购买商品
		Context originalContext = new Context(new OriginalPriceStrategy());
		originalContext.buy();

		// 厂家促销，商品八折
		Context eightContext = new Context(new EightDiscountStrategy());
		eightContext.buy();

	}
}

 
  
十一、访问者模式
 
  
        访问者模式指封装一些作用于某种数据结构中的各元素的操作，它可以在不改变这个数据结构的前提下定义作用于这些元素的新的操作。该模式中存在抽象访问者（Visitor）、具体访问者（ConcreteVisitor）、抽象元素（Element）、具体元素（ConcreteElement）、对象结构（Object Structure）五种角色。当对象结构比较稳定且对一个对象结构中的对象进行很多不同的且不相关的操作时可使用访问者模式。使用该模式后想增加对象操作只需增加具体访问者即可。以查账为例，账本结构固定，税务局查询到的是假账，公司内会计查到的是真账。代码如下：
 
  
新建抽象元素AccountBook
 
  
/**
 * 抽象元素:定义账本接受操作
 * 
 * @author huaisf
 *
 */
public interface AccountBook {

	/**
	 * 接受数据
	 * @param viewer
	 */
	void accept(Viewer viewer);
}

 
  
新建具体元素IncomeAccountBook与SpendingAccountBook
 
  
/**
 * 具体元素:实现账本收入操作
 * 
 * @author huaisf
 *
 */
public class IncomeAccountBook implements AccountBook {

	private int amount = 100000;

	@Override
	public void accept(Viewer viewer) {
		viewer.view(this);

	}

	public int getAmount() {
		return amount;
	}

	public void setAmount(int amount) {
		this.amount = amount;
	}

}

/**
 * 具体元素:实现账本支出操作
 * 
 * @author huaisf
 *
 */
public class SpendingAccountBook implements AccountBook {

	private int amount = 100000;

	@Override
	public void accept(Viewer viewer) {
		viewer.view(this);

	}

	public int getAmount() {
		return amount;
	}

	public void setAmount(int amount) {
		this.amount = amount;
	}

}

 
  
 新建抽象访问者Viewer
 
  
/**
 * 抽象访问者:定义每个具体元素访问方法
 * 
 * @author huaisf
 *
 */
public interface Viewer {

	/**
	 * 查看收入账单
	 * 
	 * @param incomeAccountBook
	 */
	void view(IncomeAccountBook incomeAccountBook);

	/**
	 * 查看支出账单
	 * 
	 * @param spendingAccountBook
	 */
	void view(SpendingAccountBook spendingAccountBook);
}

 
  
新建具体访问者AccountingViewer与RevenueViewer
 
  
/**
 * 具体访问者:对抽象访问者方法进行实现，会计查到的是真账
 * 
 * @author huaisf
 *
 */
public class AccountingViewer implements Viewer {

	@Override
	public void view(IncomeAccountBook incomeAccountBook) {
		System.out.println("财务人员查看收入:" + incomeAccountBook.getAmount());

	}

	@Override
	public void view(SpendingAccountBook spendingAccountBook) {
		System.out.println("财务人员查看支出:" + spendingAccountBook.getAmount());

	}
}


/**
 * 具体访问者:对抽象访问者方法进行实现，税务局查到的是假账
 * 
 * @author huaisf
 *
 */
public class RevenueViewer implements Viewer {

	@Override
	public void view(IncomeAccountBook incomeAccountBook) {
		System.out.println("税务局查看收入:" + incomeAccountBook.getAmount() / 10);

	}

	@Override
	public void view(SpendingAccountBook spendingAccountBook) {
		System.out.println("税务局查看支出:" + spendingAccountBook.getAmount() * 10);

	}

}
 
  
新建对象结构AccountBookStructure
 
  
/**
 * 对象结构:存储元素并提供遍历所有元素的方法供外部调用
 * 
 * @author huaisf
 *
 */
public class AccountBookStructure {
	
	private List accountBooks = new ArrayList();

	public void add(AccountBook accountBook) {
		accountBooks.add(accountBook);
	}

	public void show(Viewer viewer) {
		for (AccountBook accountBook : accountBooks) {
			accountBook.accept(viewer);
		}
	}
}

 
  
新建测试类Test
 
  
public class Test {

	public static void main(String[] args) {
		AccountBookStructure accountBookStructure = new AccountBookStructure();
		accountBookStructure.add(new IncomeAccountBook());
		accountBookStructure.add(new SpendingAccountBook());
		
		// 税务局查账
		accountBookStructure.show(new RevenueViewer());
		
		// 会计查账
		accountBookStructure.show(new AccountingViewer());
	}
}

 
  
 
  

                            
                        
                    
                    
                    

                    
                    
                    

                
                

                    
                

            
        
    
    

        
你可能感兴趣的:(设计模式,设计模式)

        

            

                
    
                    
  • Python 单例模式的 5 种实现方式：深入解析与最佳实践
                        做测试的小薄
测试高阶python单例模式自动化测试测试框架
                        
    单例模式（SingletonPattern）是一种经典的设计模式，其核心思想是确保一个类在整个程序运行期间只有一个实例，并提供一个全局访问点。这种模式在许多场景中非常有用，例如全局配置管理、日志记录器、数据库连接池等。然而，Python的灵活性使得实现单例模式有多种方式，每种方法都有其特点和适用场景。本文将详细介绍Python中实现单例模式的5种常见方法，并深入分析它们的优缺点以及适用场景，帮助您
    
                    
    • 
                    
  • SpringBoot + Facade Pattern : 通过统一接口简化多模块业务
                        Java布道者
springboot外观模式后端
                        
    概述外观设计模式（FacadePattern）是一种常见的结构型设计模式，它的主要目的是简化复杂系统的使用。可以把它想象成一个“控制面板”或者“遥控器”，通过这个控制面板，用户可以轻松操作一个复杂的系统，而不需要关心系统内部是如何运作的。举个生活中的例子，想象一下，你家有一台多功能的家电，比如一台智能电视，它不仅能看电视，还能上网、播放视频、控制智能家居等等。对于电视的操作，你有遥控器，可以通过一
    
                    
    • 
                    
  • 【设计模式】C++ 单例模式总结与最佳实践
                        白码思
c++单例模式开发语言
                        
    1.单例模式简介单例模式（SingletonPattern）是软件开发中常见的设计模式之一，主要用于确保某个类只有一个实例，并提供一个全局访问点。常见的使用场景包括：日志管理：全局唯一的日志记录器。数据库连接池：防止创建多个数据库连接，提高性能。资源管理器：如线程池、驱动管理器等。2.单例模式的实现方式C++中实现单例模式的方式有多种，常见方式如下：2.1普通的单例模式（非线程安全）特点：使用静态
    
                    
    • 
                    
  • Android 使用设计模式：装饰者设计模式，对功能进行封装升级，学会可以让我们的代码更加的简洁。
                        前期后期
设计模式android设计模式
                        
    一、前言我遇到什么问题要使用装饰者设计模式？看源码的时候：我们发现明明ui有一个功能，但是在这个ui类找不到，后来发现，这个ui被当做一个参数传递到了一个类里面，后来才在这个类里找到了这个功能。突然醍醐灌顶，这不就是装饰者设计模式吗？写代码的时候：如果我们想给一个功能增加新的东西，可以借助装饰者设计模式来装饰，如果不需要则可以把这个方法去掉，非常的简洁和优雅，并且新增的功能放到了另外一个类里面，也
    
                    
    • 
                    
  • 45-JavaEE 开发中的动态代理与序列化技术
                        只不过是胆小鬼罢了
WEB安全开发java
                        
    在JavaEE开发领域，动态代理与序列化技术是两个关键知识点，它们在很多场景下发挥着重要作用。以下是对这两部分知识的深入探讨。动态代理代理模式概述代理模式是Java中常用的设计模式之一，其核心思想是代理类与委托类实现相同的接口。代理类的主要职责是为委托类进行预处理、消息过滤、转发消息以及事后处理等操作。这种模式在很多场景下都有应用，比如权限控制、日志记录、事务管理等。JDK动态代理实现步骤创建接口
    
                    
    • 
                    
  • 访问者模式【行为模式C++】
                        GoWjw
设计模式访问者模式
                        
    1.概述访问者模式是一种行为设计模式，它能将算法与其所作用的对象隔离开来。访问者模式主要解决的是数据与算法的耦合问题，尤其是在数据结构比较稳定，而算法多变的情况下。为了不污染数据本身，访问者会将多种算法独立归档，并在访问数据时根据数据类型自动切换到对应的算法，实现数据的自动响应机制，并确保算法的自由扩展。访问者模式在实际开发中使用的非常少，因为它比较难以实现并且应用该模式肯能会导致代码的可读性变差
    
                    
    • 
                    
  • 【重温设计模式】访问者模式及其Java示例
                        万猫学社
重温设计模式及其Java实现设计模式访问者模式java
                        
    访问者模式的基本概念访问者模式，一种行为型设计模式，其基本定义是：允许一个或者多个操作应用到一组对象上，解耦操作和对象的具体类，使得操作的添加可以独立于对象的类结构变化。在面向对象编程中，访问者模式的重要性不言而喻。它将数据操作和数据结构分离，使得在不改变数据结构的前提下，可以添加新的操作，从而增强了系统的灵活性和可扩展性。在访问者模式中，数据结构是稳定的，而操作是易变的。这就像一座博物馆，展品（
    
                    
    • 
                    
  • 【设计模式】外观模式
                        浅慕Antonio
设计模式设计模式
                        
    第8章外观模式8.1配置相关范例核心问题游戏配置项复杂，直接调用业务类导致耦合度高：图形配置类//图形相关类classGraphic{private://单件模式实现Graphic()=default;Graphic(constGraphic&)=delete;Graphic&operator=(constGraphic&)=delete;~Graphic()=default;public:sta
    
                    
    • 
                    
  • 设计模式：创建型、结构型、行为型
                        0319zz
设计模式
                        
    设计模式是一种解决软件设计中常见问题的通用解决方案。根据其目的，设计模式可以分为三大类：创建型模式、结构型模式和行为型模式。创建型模式创建型模式主要用于创建对象，抽象了实例化的过程，使系统独立于对象的创建、组合和表示。创建型模式包括以下几种：工厂方法模式：定义一个创建对象的接口，但由子类决定实例化哪一个类。抽象工厂模式：提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。单例模式：
    
                    
    • 
                    
  • Java基础7（解耦、引入工厂模式、代理设计模式、适配器设计模式、内部类）
                        孤影恋长风
java
                        
    类设计的注意事项：类的设计主要是父类的设计子类最好不要继承一个已经完全实现的类，因为一旦发达向上转型，所调用的方法，一定是被子类覆盖过的方法，所以只会继承抽象类和接口。解耦耦合度是什么？两个对象之间相互依赖的程度，是衡量代码独立性的一个指标。软件开发追求高/低耦合度？软件开发追求低耦合度怎么才能降低代码的耦合度？降低代码的耦合度是一个非常重要的实践，它有助于提高代码的可维护性、可读性和可扩展性。引
    
                    
    • 
                    
  • Java单例模式【懒汉式&&饿汉式】
                        ice-Hamster
Java学习单例模式javaeclipse学习经验分享
                        
    目录一、单例模式的解释二、实现方法2.1饿汉式2.1.1饿汉式的实现代码2.2懒汉式2.2.1懒汉式的实现代码三、单例设计模式的好处3.1单例模式的应用场景一、单例模式的解释所谓类的单例设计模式，就是采用一定的方法保证在整个的软件系统中，对某个类只能存在一个对象实例。并且该类只提供一个取得其对象实例的方法。（简单来说，在整个的软件系统中，对某个类只能存在一个对象实例）二、实现方法单例设计模式的实现
    
                    
    • 
                    
  • 25. 策略模式
                        智想天开
设计模式详解策略模式bash开发语言
                        
    原文地址:策略模式更多内容请关注：智想天开1.策略模式简介策略模式（StrategyPattern）是一种行为型设计模式，它定义了一系列算法，将每一个算法封装起来，并使它们可以相互替换。策略模式让算法的变化独立于使用算法的客户。通过引入策略模式，可以在不修改客户端代码的情况下，动态地更改对象的行为。关键点：算法封装：将不同的算法封装到独立的策略类中。互换性：策略类可以相互替换，客户端可以根据需要选
    
                    
    • 
                    
  • Java单例设计模式（懒汉式和饿汉式）
                        俺是凡人很好
java设计模式开发语言
                        
    一、什么是单例设计模式概念：java中单例模式是一种常见的设计模式，单例模式的写法有好几种，这里主要介绍俩种：懒汉式单例、饿汉式单例。单例模式有以下特点：1、单例类只能有一个实例。2、单例类必须自己创建自己的唯一实例。3、单例类必须给所有其他对象提供这一实例。单例模式确保某个类只有一个实例，而且自行实例化并向整个系统提供这个实例。在计算机系统中，线程池、缓存、日志对象、对话框、打印机、显卡的驱动程
    
                    
    • 
                    
  • 桥接模式 (Bridge Pattern)
                        直隶码农
二十三种设计模式桥接模式c++设计模式
                        
    桥接模式(BridgePattern)是一种结构型设计模式，它将抽象部分与实现部分分离，使它们可以独立变化。一、基础1意图将抽象部分与实现部分分离，使它们可以独立变化。2适用场景当你不希望在抽象和实现部分之间有固定的绑定关系时。当类的抽象以及它的实现都应该可以通过生成子类的方法加以扩充时。当对一个抽象的实现部分的修改应对客户不产生影响时。当你想对客户完全隐藏抽象的实现部分时。当你有许多类要生成的类
    
                    
    • 
                    
  • 原型模式 (Prototype Pattern)
                        直隶码农
二十三种设计模式原型模式c++设计模式
                        
    原型模式(PrototypePattern)是一种创建型设计模式，它通过复制现有对象来创建新对象，而不是通过实例化类。一、基础1意图通过复制现有对象来创建新对象，而不是通过实例化类。2适用场景当一个系统应该独立于它的产品创建、构成和表示时。当要实例化的类是在运行时指定时，例如通过动态装载。为了避免创建一个与产品类层次平行的工厂类层次时。当一个类的实例只能有几个不同状态组合中的一种时，建立相应数目的
    
                    
    • 
                    
  • 适配器模式 (Adapter Pattern)
                        直隶码农
二十三种设计模式适配器模式c++设计模式
                        
    适配器模式(AdapterPattern)是一种结构型设计模式，它将一个类的接口转换成客户希望的另外一个接口，使得原本由于接口不兼容而不能一起工作的类可以一起工作。在现实生活中，适配器的例子随处可见，比如电源适配器，它将不同电压的电流转换为设备所需的电压，确保设备能正常工作。在软件开发中，当我们需要复用一些现有的类，但这些类的接口与我们当前系统的接口不兼容时，适配器模式就派上用场了。一、基础1意图
    
                    
    • 
                    
  • 【go】如何处理可选配置
                        还没入门的大菜狗
gogolang开发语言
                        
    问题背景：在设计API时，如何处理可选配置？1.配置结构体好处：解决兼容性，但问题是0值，和可读性差如何解决0值？——使用指针，将nil和类型0值做区分但是入参包含结构体，可读性差无法解决2.生成器模式生成器模式介绍生成器模式（BuilderPattern）是一种创建型设计模式，用于构建复杂对象。该模式将对象的构造过程与其表示分离，使同样的构建过程可以创建不同的表示。从您提供的代码中，我们可以看到
    
                    
    • 
                    
  • spring MVC 介绍
                        LCY133
spring后端springmvcjava
                        
    SpringMVC是Spring框架中用于构建Web应用的核心模块，基于MVC设计模式（Model-View-Controller）实现。以下是其核心概念的整理：1.MVC设计模式•Model（模型）：封装业务数据和业务逻辑（如POJO对象、Service层）。•View（视图）：负责数据展示（如JSP、Thymeleaf、HTML）。•Controller（控制器）：接收请求，调用业务逻辑，返回
    
                    
    • 
                    
  • 嵌入式系统中的状态机模式
                        boringhex.top
MCU嵌入式设计模式
                        
    在嵌入式系统中，状态机模式是一种常用的设计模式，通过定义系统的不同状态及其转换规则，帮助开发者更好地管理系统的行为和状态变化。本文将详细讲解状态机模式，并结合实例深入分析，帮助读者深入理解这一模式在嵌入式系统中的应用。状态机模式概述状态机模式（StateMachinePattern）是一种行为型设计模式，它允许对象在其内部状态改变时改变其行为。状态机模式通过将状态封装为独立的类，使得对象在不同状态
    
                    
    • 
                    
  • 设计模式之装饰器模式
                        周努力.
设计模式设计模式装饰器模式
                        
    装饰器模式(Decorator)依然是我们设计模式中的结构型模式，其中的构造思想仍然是对多个类进行组合使用，以达成系统调用实现指定功能的设计模式。装饰器模式不论在我们日常开发过程中还是在我们提升技术阅读源码过程中都是比较常见的，但是整体学习这个模式的思路难度不大，接下来我将详细讲解此设计模式。目录1.概念2.代码实现3.应用场景4.装饰器模式与代理模式的区别1.概念我们前期所讲到的适配器模式，是连
    
                    
    • 
                    
  • C# 设计模式之桥接模式
                        鲤籽鲲
C#c#设计模式桥接模式
                        
    总目录前言1基础介绍定义：将抽象部分与实现部分分离，使它们都可以独立地变化。桥模式不能只认为是抽象和实现的分离，它其实并不仅限于此。其实两个都是抽象的部分，更确切的理解，应该是将一个事物中多个维度的变化分离。一个维度可以认为是抽象部分，另一个维度可以认为是实现部分，而这两个维度可以独立扩充和维护。桥接模式中的角色：抽象化角色(Abstraction)：定义抽象类的接口，一般为抽象类，规范Refin
    
                    
    • 
                    
  • 设计模式之桥接模式
                        周努力.
设计模式设计模式桥接模式java
                        
    目录1.概念2.代码实现3.应用场景桥接模式(BridgePattern)也是我们结构型设计模式的一种，桥接模式整体来说对于开发者需要深刻理解好抽象类这个概念，而且比较考验在开发前就要设计好桥接点来进行开发，所以整体的理解难度我认为是比较高，接下来我将从概念和一个示例来演示该模式。1.概念桥接模式就是将抽象与实现解藕，使两者都可以独立变化。在现实生活中，某些类具有两个或多个维度的变化，如图形既可按
    
                    
    • 
                    
  • 简单工厂模式：思考与解读
                        智想天开
理解设计模式#初级简单工厂模式
                        
    原文地址：简单工厂模式：思考与解读更多内容请关注：深入思考与解读设计模式引言你是否遇到过这样的问题：在一个系统中，你需要创建不同类型的对象，而这些对象之间有很多相似之处，唯一的区别可能是某些细节或行为？如果每次都手动创建对象，会导致代码重复，并且难以扩展。如何才能有效地管理这些对象的创建？你是否想过，是否有一种机制可以在不暴露对象创建过程的情况下，提供统一的接口来生成对象？这就是简单工厂模式能够帮
    
                    
    • 
                    
  • 设计模式-抽象工厂模式(Abstract Factory)
                        树懒_Zz
设计模式抽象工厂模式设计模式
                        
    抽象工厂模式是一种创建型设计模式，它能创建一系列相关的对象，而无需指定其具体类。譬如你正在开发一款家具组装系统。代码中包括一些产品：椅子（chair）,沙发（sofa）和咖啡桌（CoffeeTable）然后基于这些产品形成一些列组合套餐装饰风艺术(ArtDeco)、维多利亚（Victorian）和现代（Mdern）。你需要设法单独生成每件家具对象，这样才能确保其风格一致。如果顾客收到的家具风格不一
    
                    
    • 
                    
  • 【架构设计】前置知识
                        GIS程序媛—椰子
架构设计架构设计
                        
    架构设计是软件开发的进阶技能，需要结合理论知识和实践经验。以下是掌握架构设计所需的前置知识及其重要性，以及学习路径建议：一、基础编程能力1.编程语言与核心概念掌握至少一门主流语言（如Java、Python、C#、Go等），理解其语法、特性及生态。核心概念：面向对象（OOP）、函数式编程（FP）、并发/异步、内存管理等。示例：通过Java理解接口、多态、设计模式。通过Go学习并发模型（Gorouti
    
                    
    • 
                    
  • Java设计模式——装饰模式
                        爱吃土豆的程序员
Java设计模式java装饰器模式设计模式
                        
    目录模式动机模式定义模式结构类图代码分析示例：动态添加功能的流组件接口具体组件装饰抽象类具体装饰类客户端模式分析核心思想动态扩展功能组合优于继承优点动态扩展功能组合优于继承代码复用性高符合开闭原则缺点增加系统的复杂性类的膨胀复杂的调试适用环境动态扩展功能避免继承带来的类爆炸性增长高度可定制化的需求模式应用输入输出流GUI组件日志记录模式扩展多层次装饰结合其他设计模式总结模式动机一般有两种方式可以实
    
                    
    • 
                    
  • 设计模式—装饰者模式
                        BlackTurn
设计模式设计模式
                        
    一、什么是装饰者模式装饰者模式是一种结构型设计模式，它允许你动态地向对象添加新的行为而不影响其原有的行为。它在运行时给对象动态地添加一些额外的职责，通常是在原有的行为基础上，通过装饰器进行一些修饰，实现了更加灵活的代码复用和扩充。给对象添加一些职责，但是又不想改变其原有的接口和实现。在不使用继承的情况下（避免出现由于继承关系带来的类很多问题）动态地为一个对象添加一些额外的功能。需要在程序运行时动态
    
                    
    • 
                    
  • 设计模式-抽象工厂模式（Abstract Factory Pattern）结构|原理|优缺点|场景|示例
                        TsengOnce
设计模式抽象工厂模式java
                        
    设计模式（分类）设计模式（六大原则）创建型（5种）工厂方法抽象工厂模式单例模式建造者模式原型模式结构型（7种）适配器模式装饰器模式代理模式外观模式桥接模式组合模式享元模式行为型（11种）策略模式模板方法模式观察者模式迭代器模式责任链模式命令模式备忘录模式状态模式访问者模式中介者模式抽象工厂模式（AbstractFactoryPattern）是一种创建型设计模式，它提供了一个创建一系列相关或相互依赖
    
                    
    • 
                    
  • 23种设计模式-抽象工厂(Abstract Factory)设计模式
                        程序员汉升
#设计模式设计模式java抽象工厂模式
                        
    抽象工厂设计模式什么是抽象工厂设计模式？抽象工厂模式的特点抽象工厂模式的结构抽象工厂模式的优缺点抽象工厂方法的Java实现代码总结总结什么是抽象工厂设计模式？抽象工厂模式（AbstractFactoryDesignPattern）是一种创建型设计模式，它提供了一种方式来创建一系列相关或相互依赖的对象，而无需指定它们的具体类。与工厂方法模式的区别在于，抽象工厂模式通常用于处理产品族的创建，确保创建的
    
                    
    • 
                    
  • 策略模式详解：实现灵活多样的支付方式
                        Dong雨
策略模式java
                        
    多支付方式的实现：策略模式详解策略模式（StrategyPattern）是一种行为设计模式，它定义了一系列算法，并将每个算法封装起来，使它们可以互换使用。策略模式使得算法可以独立于使用它的客户端变化。本文将通过一个具体的业务场景来介绍策略模式，并给出相应的代码实现。业务场景我们以一个电商平台为例，该平台支持多种支付方式，包括信用卡支付、PayPal支付和比特币支付。我们希望在不修改客户端代码的情况
    
                    
    • 
                                
  • 矩阵求逆（JAVA）初等行变换
                                    qiuwanchi
矩阵求逆（JAVA）
                                    
    package gaodai.matrix;

import gaodai.determinant.DeterminantCalculation;

import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;

/**
 * 矩阵求逆(初等行变换)
 * @author 邱万迟
 *
    
                                
    • 
                                
  • JDK timer
                                    antlove
javajdkschedulecodetimer
                                    
    1.java.util.Timer.schedule(TimerTask task, long delay)：多长时间（毫秒）后执行任务 
2.java.util.Timer.schedule(TimerTask task, Date time)：设定某个时间执行任务 
3.java.util.Timer.schedule(TimerTask task, long delay,longperiod
    
                                
    • 
                                
  • JVM调优总结 -Xms -Xmx -Xmn -Xss
                                    coder_xpf
jvm应用服务器
                                    
    堆大小设置JVM 中最大堆大小有三方面限制：相关操作系统的数据模型（32-bt还是64-bit）限制；系统的可用虚拟内存限制；系统的可用物理内存限制。32位系统下，一般限制在1.5G~2G；64为操作系统对内存无限制。我在Windows Server 2003 系统，3.5G物理内存，JDK5.0下测试，最大可设置为1478m。 
 
典型设置：   
 
  
   
    java -Xmx
    
                                
    • 
                                
  • JDBC连接数据库
                                    Array_06
jdbc
                                    
    package Util; 
 
import java.sql.Connection; 
import java.sql.DriverManager; 
import java.sql.ResultSet; 
import java.sql.SQLException; 
import java.sql.Statement; 
 
 
public class JDBCUtil { 
 
 //完
    
                                
    • 
                                
  • Unsupported major.minor version 51.0（jdk版本错误）
                                    oloz
java
                                    
    java.lang.UnsupportedClassVersionError: cn/support/cache/CacheType : Unsupported major.minor version 51.0 (unable to load class cn.support.cache.CacheType) 
 at org.apache.catalina.loader.WebappClassL
    
                                
    • 
                                
  • 用多个线程处理1个List集合
                                    362217990
多线程threadlist集合
                                    
      昨天发了一个提问，启动5个线程将一个List中的内容，然后将5个线程的内容拼接起来，由于时间比较急迫，自己就写了一个Demo，希望对菜鸟有参考意义。。 
 
 


import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.CountDownLatch;

public c
    
                                
    • 
                                
  • JSP简单访问数据库
                                    香水浓
sqlmysqljsp
                                    
    学习使用javaBean，代码很烂，仅为留个脚印 
 
 

public class DBHelper {

	private String driverName;
	private String url;
	private String user;
	private String password;
	private Connection connection;
	privat
    
                                
    • 
                                
  • Flex4中使用组件添加柱状图、饼状图等图表
                                    AdyZhang
Flex
                                    
    1.添加一个最简单的柱状图       
?       1   2   3   4   5   6   7   8   9   10   11   12   13   14   15   16   17   18   19   20   21   22   23   24   25   26   27   28      
<?xml version= 
"1.0"&n
    
                                
    • 
                                
  • Android 5.0 - ProgressBar 进度条无法展示到按钮的前面
                                    aijuans
android
                                    
    在低于SDK < 21 的版本中，ProgressBar 可以展示到按钮前面，并且为之在按钮的中间，但是切换到android 5.0后进度条ProgressBar 展示顺序变化了，按钮再前面，ProgressBar 在后面了我的xml配置文件如下： 
     
[html]  
view plain 
copy       
 
 <RelativeLa
    
                                
    • 
                                
  • 查询汇总的sql
                                    baalwolf
sql
                                    
    select   list.listname, list.createtime,listcount from dream_list as list ,   (select listid,count(listid) as listcount  from dream_list_user  group by listid  order by count(
    
                                
    • 
                                
  • Linux du命令和df命令区别
                                    BigBird2012
linux
                                    
            1，两者区别      
       du，disk usage,是通过搜索文件来计算每个文件的大小然后累加，du能看到的文件只是一些当前存在的，没有被删除的。他计算的大小就是当前他认为存在的所有文件大小的累加和。 
       
    
                                
    • 
                                
  • AngularJS中的$apply，用还是不用？
                                    bijian1013
JavaScriptAngularJS$apply
                                    
            在AngularJS开发中，何时应该调用$scope.$apply()，何时不应该调用。下面我们透彻地解释这个问题。 
        但是首先，让我们把$apply转换成一种简化的形式。 
        scope.$apply就像一个懒惰的工人。它需要按照命
    
                                
    • 
                                
  • [Zookeeper学习笔记十]Zookeeper源代码分析之ClientCnxn数据序列化和反序列化
                                    bit1129
zookeeper
                                    
    ClientCnxn是Zookeeper客户端和Zookeeper服务器端进行通信和事件通知处理的主要类，它内部包含两个类，1. SendThread 2. EventThread， SendThread负责客户端和服务器端的数据通信，也包括事件信息的传输，EventThread主要在客户端回调注册的Watchers进行通知处理 
  
ClientCnxn构造方法 
  
&
    
                                
    • 
                                
  • 【Java命令一】jmap
                                    bit1129
Java命令
                                    
    jmap命令的用法： 
  
[hadoop@hadoop sbin]$ jmap
Usage:
    jmap [option] <pid>
        (to connect to running process)
    jmap [option] <executable <core>
        (to connect to a 
    
                                
    • 
                                
  • Apache 服务器安全防护及实战
                                    ronin47

                                    
    此文转自IBM. 
Apache 服务简介 
Web 服务器也称为 WWW 服务器或 HTTP 服务器 (HTTP Server)，它是 Internet 上最常见也是使用最频繁的服务器之一，Web 服务器能够为用户提供网页浏览、论坛访问等等服务。 
由于用户在通过 Web 浏览器访问信息资源的过程中，无须再关心一些技术性的细节，而且界面非常友好，因而 Web 在 Internet 上一推出就得到
    
                                
    • 
                                
  • unity 3d实例化位置出现布置？
                                    brotherlamp
unity教程unityunity资料unity视频unity自学
                                    
    问：unity 3d实例化位置出现布置？ 
答：实例化的同时就可以指定被实例化的物体的位置,即 position   
Instantiate (original : Object, position : Vector3, rotation : Quaternion) : Object 
这样你不需要再用Transform.Position了, 
  
如果你省略了第二个参数(
    
                                
    • 
                                
  • 《重构，改善现有代码的设计》第八章 Duplicate Observed Data
                                    bylijinnan
java重构
                                    
    
import java.awt.Color;
import java.awt.Container;
import java.awt.FlowLayout;
import java.awt.Label;
import java.awt.TextField;
import java.awt.event.FocusAdapter;
import java.awt.event.FocusE
    
                                
    • 
                                
  • struts2更改struts.xml配置目录
                                    chiangfai
struts.xml
                                    
    struts2默认是读取classes目录下的配置文件，要更改配置文件目录，比如放在WEB-INF下，路径应该写成../struts.xml(非/WEB-INF/struts.xml) 
web.xml文件修改如下： 
  
<filter>
<filter-name>struts2</filter-name>
<filter-class&g
    
                                
    • 
                                
  • redis做缓存时的一点优化
                                    chenchao051
redishadooppipeline
                                    
      
      最近集群上有个job，其中需要短时间内频繁访问缓存，大概7亿多次。我这边的缓存是使用redis来做的，问题就来了。 
      首先，redis中存的是普通kv，没有考虑使用hash等解结构，那么以为着这个job需要访问7亿多次redis，导致效率低，且出现很多redi
    
                                
    • 
                                
  • mysql导出数据不输出标题行
                                    daizj
mysql数据导出去掉第一行去掉标题
                                    
    当想使用数据库中的某些数据，想将其导入到文件中，而想去掉第一行的标题是可以加上-N参数 
 
如通过下面命令导出数据： 
mysql -uuserName -ppasswd -hhost -Pport -Ddatabase -e " select * from tableName"  > exportResult.txt 
 
结果为： 
 
studentid
    
                                
    • 
                                
  • phpexcel导出excel表简单入门示例
                                    dcj3sjt126com
PHPExcelphpexcel
                                    
    先下载PHPEXCEL类文件，放在class目录下面，然后新建一个index.php文件，内容如下 
<?php 
error_reporting(E_ALL); 
ini_set('display_errors', TRUE); 
ini_set('display_startup_errors', TRUE); 
  
if (PHP_SAPI == 'cli') 
 die('
    
                                
    • 
                                
  • 爱情格言
                                    dcj3sjt126com
格言
                                    
     1) I love you not because of who you are, but because of who I am when I am with you. 　　 我爱你，不是因为你是一个怎样的人，而是因为我喜欢与你在一起时的感觉。 　　2) No man or woman is worth your tears, and the one who is, won‘t
    
                                
    • 
                                
  • 转 Activity 详解——Activity文档翻译
                                    e200702084
androidUIsqlite配置管理网络应用
                                    
    activity 展现在用户面前的经常是全屏窗口，你也可以将 activity 作为浮动窗口来使用（使用设置了 windowIsFloating 的主题），或者嵌入到其他的 activity （使用 ActivityGroup ）中。 当用户离开 activity 时你可以在 onPause() 进行相应的操作 。更重要的是，用户做的任何改变都应该在该点上提交 ( 经常提交到 ContentPro
    
                                
    • 
                                
  • win7安装MongoDB服务
                                    geeksun
mongodb
                                    
    1.  下载MongoDB的windows版本：mongodb-win32-x86_64-2008plus-ssl-3.0.4.zip，Linux版本也在这里下载，下载地址： http://www.mongodb.org/downloads 
  
2.  解压MongoDB在D:\server\mongodb, 在D:\server\mongodb下创建d
    
                                
    • 
                                
  • Javascript魔法方法:__defineGetter__,__defineSetter__
                                    hongtoushizi
js
                                    
    转载自： http://www.blackglory.me/javascript-magic-method-definegetter-definesetter/ 
在javascript的类中,可以用defineGetter和defineSetter_控制成员变量的Get和Set行为 
例如,在一个图书类中,我们自动为Book加上书名符号: 
function Book(name){  
    
                                
    • 
                                
  • 错误的日期格式可能导致走nginx proxy cache时不能进行304响应
                                    jinnianshilongnian
cache
                                    
    昨天在整合某些系统的nginx配置时，出现了当使用nginx cache时无法返回304响应的情况，出问题的响应头：    Content-Type:text/html; charset=gb2312   Date:Mon, 05 Jan 2015 01:58:05 GMT   Expires:Mon , 05 Jan 15 02:03:00 GMT   Last-Modified:Mon, 05
    
                                
    • 
                                
  • 数据源架构模式之行数据入口
                                    home198979
PHP架构行数据入口
                                    
    注：看不懂的请勿踩，此文章非针对java，java爱好者可直接略过。 
  
一、概念 
行数据入口（Row Data Gateway）：充当数据源中单条记录入口的对象，每行一个实例。 
  
二、简单实现行数据入口 
为了方便理解，还是先简单实现： 
<?php
/**
 * 行数据入口类
 */
class OrderGateway {
    /*定义元数
    
                                
    • 
                                
  • Linux各个目录的作用及内容
                                    pda158
linux脚本
                                    
    1）根目录“/”   　　根目录位于目录结构的最顶层，用斜线（/）表示，类似于 
Windows 
操作系统的“C:\“，包含Fedora操作系统中所有的目录和文件。   　　2）/bin   　　/bin   　　目录又称为二进制目录，包含了那些供系统管理员和普通用户使用的重要 
linux命令的二进制映像。该目录存放的内容包括各种可执行文件，还有某些可执行文件的符号连接。常用的命令有：cp、d
    
                                
    • 
                                
  • ubuntu12.04上编译openjdk7
                                    ol_beta
HotSpotjvmjdkOpenJDK
                                    
    获取源码  
 从openjdk代码仓库获取(比较慢) 
 
 安装mercurial Mercurial是一个版本管理工具。   sudo apt-get install mercurial    
 将以下内容添加到$HOME/.hgrc文件中，如果没有则自己创建一个： [extensions] forest=/home/lichengwu/hgforest-crew/forest.py fe
    
                                
    • 
                                
  • 将数据库字段转换成设计文档所需的字段
                                    vipbooks
设计模式工作正则表达式
                                    
            哈哈，出差这么久终于回来了，回家的感觉真好！ 
        PowerDesigner的物理数据库一出来，设计文档中要改的字段就多得不计其数，如果要把PowerDesigner中的字段一个个Copy到设计文档中，那将会是一件非常痛苦的事情。
    
                                
    •