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());
	}
}

 
  
 
  

                            
                        
                    
                    
                    

                    
                    
                    

                
                

                    
                

            
        
    
    

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

        

            

                
    
                    
  • 【iOS】MVC设计模式
                        Magnetic_h
iosmvc设计模式objective-c学习ui
                        
    MVC前言如何设计一个程序的结构，这是一门专门的学问，叫做"架构模式"（architecturalpattern），属于编程的方法论。MVC模式就是架构模式的一种。它是Apple官方推荐的App开发架构，也是一般开发者最先遇到、最经典的架构。MVC各层controller层Controller/ViewController/VC（控制器）负责协调Model和View，处理大部分逻辑它将数据从Mod
    
                    
    • 
                    
  • 【一起学Rust | 设计模式】习惯语法——使用借用类型作为参数、格式化拼接字符串、构造函数
                        广龙宇
一起学Rust#Rust设计模式rust设计模式开发语言
                        
    提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档文章目录前言一、使用借用类型作为参数二、格式化拼接字符串三、使用构造函数总结前言Rust不是传统的面向对象编程语言，它的所有特性，使其独一无二。因此，学习特定于Rust的设计模式是必要的。本系列文章为作者学习《Rust设计模式》的学习笔记以及自己的见解。因此，本系列文章的结构也与此书的结构相同（后续可能会调成结构），基本上分为三个部分
    
                    
    • 
                    
  • JAVA学习笔记之23种设计模式学习
                        victorfreedom
Java技术设计模式androidjava常用设计模式
                        
    博主最近买了《设计模式》这本书来学习，无奈这本书是以C++语言为基础进行说明，整个学习流程下来效率不是很高，虽然有的设计模式通俗易懂，但感觉还是没有充分的掌握了所有的设计模式。于是博主百度了一番，发现有大神写过了这方面的问题，于是博主迅速拿来学习。一、设计模式的分类总体来说设计模式分为三大类：创建型模式，共五种：工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式。结构型模式，共七种：适配器
    
                    
    • 
                    
  • 设计模式之建造者模式(通俗易懂--代码辅助理解【Java版】）
                        ok!ko
设计模式设计模式建造者模式java
                        
    文章目录设计模式概述1、建造者模式2、建造者模式使用场景3、优点4、缺点5、主要角色6、代码示例：1）实现要求2）UML图3)实现步骤：1）创建一个表示食物条目和食物包装的接口2）创建实现Packing接口的实体类3）创建实现Item接口的抽象类，该类提供了默认的功能4）创建扩展了Burger和ColdDrink的实体类5）创建一个Meal类，带有上面定义的Item对象6）创建一个MealBuil
    
                    
    • 
                    
  • 设计模式 23 访问者模式
                        WineMonk
#设计模式设计模式访问者模式
                        
    设计模式23创建型模式（5）：工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式结构型模式（7）：适配器模式、桥接模式、组合模式、装饰者模式、外观模式、享元模式、代理模式行为型模式（11）：责任链模式、命令模式、解释器模式、迭代器模式、中介者模式、备忘录模式、观察者模式、状态模式、策略模式、模板方法模式、访问者模式文章目录设计模式23访问者模式（VisitorPattern）1定义2结构3
    
                    
    • 
                    
  • 设计模式】Listener模式和Visitor模式的区别
                        不爱洗脚的小滕
设计模式访问者模式javagolang
                        
    文章目录前言一、介绍Listener模式Visitor模式二、代码实现2.1Listener模式的Java实现2.2Listener模式的Go实现2.3Visitor模式的Java实现2.4Visitor模式的Go实现三、总结前言在软件设计中，设计模式是解决特定问题的通用解决方案。Listener模式和Visitor模式是两种常见的行为设计模式，它们在不同的场景下提供了解决问题的有效方法。本文将详
    
                    
    • 
                    
  • 开发游戏的学习规划
                        杰克逊的日记
游戏学习
                        
    第一阶段：●C#语言快速系统地学习一遍（基础的语法、面向对象、基础的数据结构、基础的设计模式）●Unity的2D和3D部分及UI、动画、物理系统●阶段性测验：需要去用前面所学的这些基础知识来完成一个简单的2d或者3d的案例，将通过一个自制的《Flappybird》游戏案例讲解游戏开发的思想及方法，并将《Flappybird》这个游戏进一步改造成一个横版射击类游戏《Crazybird》以巩固并且升华
    
                    
    • 
                    
  • 从单体到微服务：FastAPI ‘挂载’子应用程序的转变
                        黑金IT
fastapi微服务fastapi架构
                        
    在现代Web应用开发中，模块化架构是一种常见的设计模式，它有助于将大型应用程序分解为更小、更易于管理的部分。FastAPI，作为一个高性能的PythonWeb框架，提供了强大的支持来实现这种模块化设计。通过“挂载”子应用程序，我们可以为不同的功能区域（如前端接口、管理员接口和用户中心）创建独立的应用程序，并将它们整合到一个主应用程序中。本文将详细介绍如何在FastAPI中使用“挂载”子应用程序的方
    
                    
    • 
                    
  • [面试高频问题]关于多线程的单例模式
                        朱玥玥要每天学习
java单例模式开发语言
                        
    单例模式什么是设计模式?设计模式可以看做为框架或者是围棋中的”棋谱”,红方当头炮,黑方马来跳.根据一些固定的套路下,能保证局势不会吃亏.在日常的程序设计中,往往有许多业务场景,根据这些场景,大佬们总结出了一些固定的套路.按照这个套路来实现代码,也不会吃亏.什么是单例模式,保证某类在程序中只有一个实例,而不会创建多份实例.单例模式具体的实现方式:可分为”懒汉模式”,”饿汉模式”.饿汉模式类加载的同时
    
                    
    • 
                    
  • 从简单到复杂：三种工厂模式的对比与应用
                        技术拾光者
设计模式java设计模式简单工厂模式抽象工厂模式工厂方法模式
                        
    在软件设计中，创建型设计模式用于处理对象创建的复杂性。本文将对比三种常见的创建型设计模式：简单工厂模式、工厂方法模式和抽象工厂模式。一，简单工厂模式定义：简单工厂模式（SimpleFactoryPattern）定义了一个工厂类，该类可以根据传入的参数决定创建哪一种产品实例。结构：产品（Product）：定义产品的接口。具体产品（ConcreteProduct）：实现具体产品。工厂（Factory）
    
                    
    • 
                    
  • 当前最流行的架构设计模式
                        turingbooks

                        
    《微服务设计（第2版）》最可贵的地方在于，不光具备理论性与系统性，更为注重实践性与可操作性。全书勾勒出一幅从宏观到细节，再到组织落地的微服务架构整体实施蓝图。无论是对关注微服务领域的工程师与架构师，还是对寻求架构升级的管理者与决策者来说，本书都可以作为指导手册。——沈剑，快狗打车CTO《微服务设计（第2版）》萨姆·纽曼|著钟健鑫张沙沙智伟|译软件开发大神MartinFowler如此推荐本书：“微服
    
                    
    • 
                    
  • 互联网 Java 工程师面试题（Java 面试题四）
                        苹果酱0567
面试题汇总与解析java中间件开发语言springboot后端
                        
    下面列出这份Java面试问题列表包含的主题多线程，并发及线程基础数据类型转换的基本原则垃圾回收（GC）Java集合框架数组字符串GOF设计模式SOLID抽象类与接口Java基础，如equals和hashcode泛型与枚举JavaIO与NIO常用网络协议Java中的数据结构和算法正则表达式JVM底层Java最佳实JDBCDate,Time与CalendarJava处理XMLJUnit编程现在是时候给
    
                    
    • 
                    
  • 《Android进阶之光》— Android 书籍
                        王睿丶
Android永无止境《Android进阶之光》Android书籍Androidphoenix移动开发
                        
    文章目录第1章Android新特性1第2章MaterialDesign48第3章View体系与自定义View87第4章多线程编程165第5章网络编程与网络框架204第6章设计模式271第7章事件总线308第8章函数响应式编程333第9章注解与依赖注入框架382第10章应用架构设计422第11章系统架构与MediaPlayer框架460出版年:2017-7简介：《Android进阶之光》是一本And
    
                    
    • 
                    
  • MyBatis 方法重载的陷阱及解决方案
                        molashaonian
mybatis方法重载异常方法名相同
                        
    在使用MyBatis进行开发时，尤其是使用注解模式（如@Select、@Insert等）时，开发者常常会遇到这样一个问题：为什么我的方法重载不能正常工作？即使在Java中允许方法名相同但参数不同的重载，MyBatis在处理注解的SQL方法时却并不支持这种方式。这篇文章将深入探讨MyBatis的这个特性及如何规避相关的坑。问题背景在标准的Java开发中，方法重载是一种常见的设计模式。方法重载允许我们
    
                    
    • 
                    
  • 【设计模式】结构型模式：组合模式
                        KunQAQrz

                        
    意图使用组合模式可以将对象组合成树状结构，并且能像使用独立对象一样使用它们。组合模式结构在这里插入图片描述组件（Component）接口描述了树中简单项目和复杂项目所共有的操作。叶节点（Leaf）是树的基本结构，它不包含子项目。一般情况下，叶节点最终会完成大部分的实际工作，因为它们无法将工作指派给其他部分。容器（Container）又名“组合（Composite）”是包含叶节点或其他容器等子项目的
    
                    
    • 
                    
  • Java高并发编程详解系列-Balking设计模式
                        nihui123
高并发设计模式java编程语言
                        
    导语  在实际操作中当某个线程因为发现其他线程正在进行相同的工作而放弃即将开始的任务，这种情况就被称为是Balking模式，Balking英文的意思是犹豫。在多个线程监控某个共享变量，A线程监控到共享变量发生变化后立即触发某个动作，但是这个这个时候发现了B线程也对该变量开始了行动，这个时候A变量就放弃了准备工作。下面就来详细的讲解一下关于Balking模式什么是Balking模式  在餐厅吃饭的时
    
                    
    • 
                    
  • Java高并发编程详解系列-Future设计模式
                        nihui123
高并发Java高并发Future高并发
                        
    导语  假设，在一个使用场景中有一个任务需要执行比较长的时间，通常需要等待任务执行结束之后或者是中途出错之后才能返回结果。在这个期间调用者只能等待，对于这个结果Future设计模式提供了一种凭据式的解决方案。在日常生活中，这种方案也是存在的。例如去洗衣店洗衣服，当你把衣服放到洗衣店，等他洗完需要一段时间，这个时候洗衣店就会给你一凭证，你可以通过这个凭证到时候去取洗好的衣服。这个例子就是生活中的Fu
    
                    
    • 
                    
  • 字节跳动面试官亲述：Android开发学会了这些技术，你离大厂不远了
                        m0_65322636
程序员架构移动开发android
                        
    HTTPSHTTP是超文本传输协议，明文传输；HTTPS使用SSL协议对HTTP传输数据进行了加密HTTP默认80端口；HTTPS默认443端口优点：安全缺点：费时、SSL证书收费，加密能力还是有限的，但是比HTTP强多了2、Java基础&容器&同步&设计模式StringBuilder、StringBuffer、+、String.concat链接字符串：StringBuffer线程安全，Strin
    
                    
    • 
                    
  • 生产者消费者模式_Labview基础之生产者消费者设计模式（事件）
                        weixin_39532699
生产者消费者模式
                        
    1绪论近期，开了一个QQ群，刚开始的目的也是想多拉写软件相关的大神，有问题的时候也可以交流交流。记得当时有个软件在写的时候遇到了一个棘手的问题，outlook邮箱配置账户密码的问题，到现在也没解决，算了，也不是很迫切。2000人群就留在那里爬虫发单吧！建群以后才发现，原来这一块的小白还挺多，总结起来就一个原因：做这个软件的大多数都不是软件出生，都是因为临时要搭建一个上位机平台，匆匆入门......
    
                    
    • 
                    
  • 案例分析：如何用设计模式优化性能7
                        是小旭啊
fastapi
                        
    设计模式就是对常用开发技巧进行的总结，它使得程序员之间交流问题，有了更专业、便捷的方式。比如，我们在《02|理论分析：性能优化有章可循，谈谈常用的切入点》中提到，I/O模块使用的是装饰器模式，你就能很容易想到I/O模块的代码组织方式。事实上，大多数设计模式并不能增加程序的性能，它只是代码的一种组织方式。本课时，我们将一一举例讲解和性能相关的几个设计模式，包括代理模式、单例模式、享元模式、原型模式等
    
                    
    • 
                    
  • 重修设计模式-结构型-代理模式
                        丶白泽
重修设计模式设计模式代理模式系统安全
                        
    重修设计模式-结构型-代理模式在不改变原始类代码的情况下，通过引入代理类来给原始类附加功能。代理模式通过创建一个代理对象，使得客户端对目标对象的访问都通过代理对象间接进行，从而可以在不修改目标对象的前提下，增加额外的功能操作，如权限控制、日志记录、事务处理等。代理模式又分为静态代理和动态代理。静态代理（StaticProxy）：在程序运行前就已经存在代理类的字节码文件，代理类和委托类的关系在运行前
    
                    
    • 
                    
  • 如何利用命令模式实现一个手游后端架构?
                        隔窗听雨眠
命令模式
                        
    命令模式的原理解读命令模式的英文翻译是CommandDesignPattern。在GoF的《设计模式》一书中，它是这么定义的：Thecommandpatternencapsulatesarequestasanobject,therebylettingusparameterizeotherobjectswithdifferentrequests,queueorlogrequests,andsuppo
    
                    
    • 
                    
  • 单例模式以及反射对单例模式的破坏及防御
                        CodeDunkster
单例模式javajavascript
                        
    单例模式（SingletonPattern）是一种确保类在应用程序生命周期内只存在一个实例的设计模式。它不仅提供了全局访问点，还能节省内存、控制实例的生命周期。但常见的单例模式实现方式如饿汉式、懒汉式、双重校验锁、静态内部类等，虽然设计良好，但都容易被Java的反射机制所破坏。本文将介绍这些单例实现方式的优缺点、反射如何破坏它们的唯一性，以及如何防御这种破坏。1.单例模式的常见实现方式1.1饿汉式
    
                    
    • 
                    
  • Koa2 的洋葱模型是什么？它是如何实现的？
                        极客李华
Koakoa
                        
    Koa2的洋葱模型是什么？它是如何实现的？Koa2的洋葱模型是一种中间件执行流程的设计模式，它允许开发者在请求的处理过程中，按照特定的顺序依次执行一系列中间件函数。洋葱模型的实现基于Koa2框架的特性和原理。下面我将通过一个具体的案例来解释洋葱模型的概念和实现。假设我们有一个简单的Koa2应用，用于处理用户的HTTP请求。首先，我们需要创建一个Koa应用实例：constKoa=require('k
    
                    
    • 
                    
  • 设计模式-单例模式
                        SAO&asuna
设计模式学习设计模式单例模式开发语言
                        
    文章目录1.为什么要学习单例模式2.单例模式的类型2.1饿汉式单例2.2懒汉式单例2.2.1一般实现2.2.2sync.once实现2.2.3sync.Mutex实现2.2.4原子引用2.2.5极致性能优化3单例模式的优缺点1.为什么要学习单例模式单例模式，就是在整个进程的过程中，只会存在一个实例。这样做的好处主要是两个：访问控制：访问控制也就是只有这一个口子可以得到该实例，一般是通过全局变量达到
    
                    
    • 
                    
  • 深入解析C++单例模式：从基础到线程安全的高效实现
                        shuai_258
c++全套攻略c++c++多线程开发语言c++qt
                        
    引言在C++开发中，单例模式（SingletonPattern）是一种常见且重要的设计模式。它确保类的实例在整个程序生命周期中唯一，并提供一个全局访问点。这在日志管理、配置管理等场景中尤为常见。本篇博客将带你深入了解单例模式的实现原理，并介绍如何在多线程环境下实现线程安全的单例模式。什么是单例模式？单例模式是一种设计模式，其核心思想是确保某个类只能有一个实例，并提供一个全局的访问点。其应用场景包括
    
                    
    • 
                    
  • 漫谈设计模式 [17]：状态模式
                        AI让世界更懂你
设计模式状态模式python
                        
    引导性开场菜鸟：老鸟，我最近在写一个项目，遇到一个问题。我们有一个订单系统，不同的订单状态需要执行不同的操作。现在代码里充满了各种if-else语句，维护起来好痛苦。有没有什么好的解决办法？老鸟：你这个问题很常见，很多人都会遇到类似的痛点。你有没有听说过状态模式？菜鸟：状态模式？好像听过，但不太了解。老鸟：没关系，我们可以一步步来。先讲讲你现在的实现方式吧。渐进式介绍概念菜鸟：好的，我现在是这样写
    
                    
    • 
                    
  • Java基础 --- 多线程&JUC，以及一些常用的设计模式总结
                        lzhlizihang
java设计模式
                        
    文章目录一、多线程1、线程和进程的区别2、创建多线程的四种方式3、集合中的线程安全二、设计模式1、单例模式2、装饰者模式（IO流缓冲流）3、适配器模式4、模板模式一、多线程1、线程和进程的区别进程是操作系统资源分配的基本单位，而线程是处理器任务调度和执行的基本单位，一个进程可以运行多个线程多进程：操作系统中同时运行的多个程序多线程：在同一个进程中同时运行的多个任务2、创建多线程的四种方式Runna
    
                    
    • 
                    
  • 【系统架构设计师】解释器模式
                        Evaporator Core
解释器模式python开发语言
                        
    解释器模式（InterpreterPattern）是一种行为型设计模式，它定义了文法的表示，并定义了一个解释器，该解释器使用该表示来解释语言中的句子。在解释器模式中，通常包括一个抽象语法树（AbstractSyntaxTree,AST），用于表示输入的语言文法，以及一系列的解释器类，每个类对应文法中的一个符号或符号的组合。解释器模式主要适用于那些需要将一个语言中的句子解释成程序可以理解的另一种形式
    
                    
    • 
                    
  • 设计模式-分离接口（Separated Interface）
                        workflower
设计方法设计模式课程设计设计规范开发语言软件需求
                        
    在一个包中定义接口，而在另一个包中实现这个接口，两个包是分离的。背景为了减少部件之间的耦合程度改进设计质量，可以将类分组并组织成包，并限定包之间的依赖关系。但有时可能需要调用与包之间一般性依赖关系有冲突的方法，此时可以在一个包中定义接口，在另一个包中实现它。运行机制核心思想利用了：实现类对接口存在依赖关系，反之不然。其他包可以只依赖于接口包，而与实现包没有依赖关系。可以采用独立的包将接口与实现链接
    
                    
    • 
                                
  • 矩阵求逆（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到设计文档中，那将会是一件非常痛苦的事情。
    
                                
    •