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




























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






    

  • C语言演示多线程编程条件下自旋锁和屏障的使用
嫦娥妹妹等等我
开发语言c语言开源

    主线故事:有4个人玩游戏输了,惩罚:1分别使用4台不同的ATM机给我存钱2必须一块一块的存3存完还得在ATM上看一下我的余额设计模式:1每个人使用一条单独的线程,再准备一个计时线程用来输出时间2存钱涉及到对共享资源的读写,是原子操作需要用锁保护这里使用自旋锁3都存完钱后需要等待在各自的ATM上回显余额这里使用屏障技术4如果在主线程中回显对应他们给我打电话告诉我存完了我自己看一下则不需要使用屏障因为
    

    • 

  • 【二】【设计模式】建造者模式
妖精七七_
设计模式设计模式建造者模式

    建造者模式的引入//C10_1.cpp#include#include"SystemConfig.h"intmain(){SystemConfigconfig("mysql://127.0.0.1/","xiaomu","xiaomumemeda","redis://127.0.0.1/","xiaomuredis","xiaomuredispw","kafka://127.0.0.1","xia
    

    • 

  • 大话设计模式之工厂模式
码农客栈
设计模式开发语言

    工厂模式（FactoryPattern）是一种创建型设计模式，它提供了一种创建对象的最佳方式，而无需指定将要创建的对象的确切类。通过使用工厂模式，我们可以将对象的创建和使用分离，从而使代码更具灵活性和可维护性。在工厂模式中，通常会有三种角色：工厂接口（FactoryInterface）：声明了一个用于创建对象的接口，这样所有具体工厂类都必须实现该接口。具体工厂（ConcreteFactory）：实
    

    • 

  • 《外观模式（极简c++）》
Bovinitwo
设计模式（极简c++版）c++开发语言

    本文章属于专栏-概述-《设计模式（极简c++版）》-CSDN博客模式说明方案：外观模式提供了一个统一的接口，简化了一组复杂子系统的访问方式。优点：将客户端与子系统解耦，降低了复杂性。提高了代码的灵活性和可维护性。缺点：可能导致外观类过于庞大，承担了过多的责任。增加了系统的抽象层，有时会影响性能。本质思想：外观模式的本质思想是为一组复杂的子系统提供一个简单的接口，隐藏其复杂性，使得客户端可以更轻松地
    

    • 

  • 大话设计模式之代理模式
码农客栈
设计模式代理模式

    代理模式（ProxyPattern）是一种结构型设计模式，它允许通过代理对象控制对另一个对象的访问。代理对象充当客户端和实际对象之间的中介，客户端通过代理对象间接访问实际对象，从而可以在访问控制、缓存、延迟加载等方面提供额外的功能。在代理模式中，通常会有三种角色：Subject（抽象主题）：声明了真实对象和代理对象的共同接口，这样在任何使用真实对象的地方都可以使用代理对象。RealSubject（
    

    • 

  • C#学习笔记
2301_79022588
学习笔记

    一、事件派发器在C#中，事件派发器通常是指事件委托和事件处理程序的组合，用于实现一种观察者设计模式。它允许对象在状态发生变化时通知其他对象，从而实现对象之间的解耦。事件派发器的基本组成部分：事件委托（EventDelegate）：事件委托是一种特殊的委托，用于封装可以被调用的方法。它定义了事件的签名，即指定了事件处理程序方法的参数和返回类型。通常，事件委托声明在事件派发器类的外部，并且使用dele
    

    • 

  • 【设计模式】Java 设计模式之桥接模式（Bridge）
新手村长
Java设计模式设计模式java桥接模式

    桥接模式（BridgePattern）是结构型设计模式的一种，它主要解决的是抽象部分与实现部分的解耦问题，使得两者可以独立变化。这种类型的设计模式属于结构型模式，因为该模式涉及如何组合接口和它们的实现。将抽象部分与实现部分分离，使它们都可以独立地变化。一、桥接模式概述桥接模式的主要思想是将抽象与实现进行解耦，使得二者可以独立进行变化。在桥接模式中，抽象部分和实现部分被分离出来，抽象部分定义了一个抽
    

    • 

  • C++面试题
虾仁A
面试c++

    目录一、堆和栈的区别二、C++中new、delte和malloc的区别三、什么是源对象四、C++有哪些设计模式五，你使用过C++哪些类型的指针一、堆和栈的区别特性堆栈申请方式由程序员显式申请和释放由系统自动分配和释放分配方式动态分配自动分配分配效率相对较慢，需要遍历内存链表寻找合适空间相对较快，系统直接分配内存地址不连续的内存区域连续的内存区域大小限制大小灵活，上限取决于虚拟内存大小固定，通常较小
    

    • 

  • 面试九 设计模式
余生有烟火
面试职场和发展c++linux设计模式

    单例模式通常被归类为创建型设计模式，因为它主要关注如何创建对象的实例，以及如何确保在整个应用程序生命周期中只有一个实例存在。1.为什么日志模块和数据库连接池需要单例模式使用单例模式来实现数据库连接池主要有以下几个原因：全局唯一性：数据库连接池在应用程序中通常是一个全局资源，多个部分都需要共享同一个连接池。使用单例模式可以确保整个应用程序中只存在一个数据库连接池的实例，避免了资源浪费和连接冲突。统一
    

    • 

  • 【设计模式】单例模式详解
略知java的景初
JAVA设计模式java设计模式

    单例模式：定义：确保一个类在任何情况下都绝对只有一个实例，并提供一个全局访问点。为了防止出现重复的创建。单例模式是JAVA中最简单的设计模式之一。属于创建型设计模式，它提供了一种创建对象的最佳方式。这种模式涉及到一个单一的类，该类负责创建自己的对象，同时确保只有一个对象被创建。这个类提供了访问唯一对象的方法，可以直接访问，不需要new。饿汉式：程序起始就初始化对象。publicclassHungr
    

    • 

  • 【设计模式】Java 设计模式之状态模式（State）
新手村长
Java设计模式设计模式java状态模式

    深入理解状态模式（State）一、概述状态模式是一种行为设计模式，它允许一个对象在其内部状态改变时改变它的行为。对象看起来好像修改了它的类。状态模式把所有的与一个特定的状态相关的行为放到一个类中，并且将请求委托给当前状态对象来执行。在状态模式中，我们创建表示各种状态的对象和一个行为随状态对象改变而改变的Context对象。二、模式结构状态模式主要包含三个角色：Context（环境类）角色：定义客户
    

    • 

  • 设计模式:单例模式
lucky_goose
设计模式单例模式设计模式

    单例模式应用场景懒汉模式饿汉模式单例模式应用场景当类的实例只能有一个时，使用单例模式懒汉模式懒汉模式指在第一次获取实例时，才对实例进行初始化//线程不安全的懒汉模式classSingleTon{private://静态成员变量，类内声明，类外初始化staticSingleTon*instance;//构造函数私有化SingleTon(){}SingleTon(constSingleTon&tmp)
    

    • 

  • JS的设计模式（23种）
是个车迷
JavaScriptjavascript设计模式开发语言

    JavaScript设计模式是指在JavaScript编程中普遍应用的一系列经过验证的最佳实践和可重用的解决方案模板，它们用来解决在软件设计中频繁出现的问题，如对象的创建、职责分配、对象间通信以及系统架构等。设计模式并不特指某个具体的代码片段，而是一种描述在特定上下文中如何组织程序结构和对象交互的通用指导原则。JavaScript设计模式涵盖了创建型模式（处理对象创建的方式）、结构型模式（关注对象
    

    • 

  • 设计模式（建造型设计模式——抽象工厂模式）
Rookie！
设计模式之建造型设计模式设计模式抽象工厂模式java

    设计模式（建造型设计模式——抽象工厂模式）抽象工厂模式定义抽象工厂模式提供一个接口，用户创建相关或者依赖对象的家族，而不需要明确指定具体类。抽象工厂允许客户端使用抽象的接口来创建一组相关的产品，而不需要关系实际产出的具体产品是什么，这样一来客户可以从具体的产品关系中解耦。模式结构AbstractFactory：抽象工厂。抽象工厂定义了一个接口，所有的具体工厂都必须实现此接口，这个接口包含了一组方法
    

    • 

  • Android 观察者模式
Pengzi@USC
android观察者模式

    在Android中，观察者模式（ObserverPattern）是一种常用的设计模式，用于在对象之间建立一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都会得到通知并自动更新。在Android开发中，这种模式通常用于处理UI组件与数据模型之间的交互。在Android中使用观察者模式，可以按照以下步骤进行：1.定义主题（Subject）：主题通常包含一个观察者列表，以及注册、注销和通
    

    • 

  • 《适配器模式（极简c++）》
Bovinitwo
设计模式（极简c++版）c++设计模式适配器模式

    本文章属于专栏-概述-《设计模式（极简c++版）》-CSDN博客本章简要说明适配器模式。本文分为模式说明、本质思想、实践建议、代码示例四个部分。模式说明方案：适配器模式，允许接口不兼容的类能够相互合作。它充当两个不兼容接口之间的桥梁。优点：解耦性增强：允许不兼容的接口之间进行通信，降低系统组件间的耦合度。复用性增加：可以重复使用现有的类，而不需要修改其原始代码。缺点：过多的适配器类：如果系统中接口
    

    • 

  • 《桥接模式（极简c++）》
Bovinitwo
设计模式（极简c++版）c++设计模式

    本文章属于专栏-概述-《设计模式（极简c++版）》-CSDN博客本章简要说明桥接模式。本文分为模式说明、本质思想、实践建议、代码示例四个部分。模式说明方案：将抽象部分与它的实现部分分离，使多个组合在一起的品类可以独立变化。优点：分离抽象和实现部分，使得它们可以独立地变化，易于扩展。通过对象组合而不是继承的方式实现解耦，提高了代码的灵活性。缺点：增加了系统的复杂度，因为需要多个抽象类和实现类。本质思
    

    • 

  • 什么是设计模式？
工业甲酰苯胺
设计模式数据库

    什么是设计模式如果将代码的设计和编写比喻为搭积木，那就像搭建一座精美的建筑一样。每一块积木代表着代码中的一个组件、类或函数，它们拥有不同的形状、功能和特性。通过巧妙地组合和搭建这些积木，我们可以构建出一个结构良好、稳固可靠的软件系统。在搭积木的过程中，我们需要考虑每一块积木的作用和位置，确保它们能够恰如其分地组合在一起，形成一个完整的整体。高内聚的积木可以使得代码更易于理解和维护，而低耦合的积木则
    

    • 

  • 春招面试高频题目总结
小杰312
面试笔试面试c++职场和发展学习

    面试问题redis可以用于进程间通信吗？Why？How?--->延展一下有哪些进程间通信技术,优劣如何？有大量的插入sql语句，一条条的插入性能很差，如何通过事务进行优化？保证线程安全的策略有哪些？你知道哪些设计模式？有什么理解？单例、工厂方法、责任链、模板方法、策略模式都是基类抽象固定方法。子类提供具体实现。如何实现服务端与客户端的即时通讯？消息队列如何保证这个消息一定执行？不会丢失？持久化消息
    

    • 

  • 设计模式（结构型设计模式——装饰者模式）
Rookie！
设计模式之结构型设计模式设计模式java开发语言装饰器模式

    设计模式（结构型设计模式——装饰者模式）装饰者模式基本定义装饰模式指的是在不必改变原类文件和使用继承(也是与适配器模式不一样的地方)的情况下，动态地扩展一个对象的功能。它是通过创建一个包装对象，也就是装饰来包裹真实的对象。模式结构Component:抽象构件。是定义一个对象接口，可以给这些对象动态地添加职责。ConcreteComponent:具体构件。是定义了一个具体的对象，也可以给这个对象添加
    

    • 

  • 结构型设计模式 — 代理模式
Chase_stars

    把时间用在思考上是最能节省时间的事情。—卡曾斯写在前面本篇讲解代理模式，分静态代理和动态代理两部分，由浅入深更好的理解代理模式。代理模式又被称为委托模式，在现实生活中类似代理模式这种场景有很多，比如请律师打官司，代购，代理上网等。代理模式的定义：为其他对象提供一种代理以控制对这个对象的访问。代理模式.jpg抽象主题类（Subject）：声明真实主题与代理的公共的接口方法。真实主题类（RealSub
    

    • 

  • 设计之魅：高质量面向对象设计的秘密
JAVA新视界
java开发语言算法

    设计模式是在软件设计中用于解决常见问题的经过验证的解决方案。设计模式并不是代码或库，而是一种解决问题的思考方式。在使用设计模式时，需要考虑一些基本的设计原则，这些原则有助于构建灵活、可维护和可扩展的软件系统。以下是一些常见的设计原则：单一职责原则（SingleResponsibilityPrinciple-SRP）:它指导我们确保一个类只有一个责任。类的责任应该是单一的，即一个类应该只有一个引起它
    

    • 

  • 设计模式学习笔记 - 设计原则与思想总结：2.运用学过的设计原则和思想完善之前性能计数器项目
陈建111
设计模式-实战设计原则思想实战

    概述在《设计原则-10.实战：针对非业务的通用框架开发，如何做需求分析和设计及如何实现一个支持各种统计规则的性能计数器》中，我们讲解了如何对一个性能计数器框架进行分析、设计与实现，并且实践了一些设计原则和设计思想。当时提到，小步快跑、逐步迭代式一种非常实用的开发模式。所以，针对这个框架的开发，我们分多个版本来逐步完善。《设计原则-10.实战：针对非业务的通用框架开发，如何做需求分析和设计及如何实现
    

    • 

  • 设计模式学习笔记 - 规范与重构 - 7.实践：通过一段ID生成器代码，学习如何发现代码质量问题
陈建111
设计模式-实战代码质量重构

    前言前面讲了重构相关的知识点。用一句话总结：重构就是发现代码质量问题，并且对其进行优化的过程。今天借助一个ID生成器代码，给你展示以下重构的大致过程。背景介绍在软件开发中，ID常用来表示一些业务信息的唯一标识，比如订单的单号、数据库中的唯一主键。假设你正参与一个后端业务系统的开发，为了方便在请求出错时排查问题，在写代码的时候会在关键路径上打印日志。某个请求出错后，希望能搜索出这个请求对应的所有日志
    

    • 

  • 设计模式学习笔记 - 规范与重构 - 8.实践：程序出错返回啥？NULL、异常、错误吗、空对象？重构ID生成器，处理各函数的异常
陈建111
设计模式-实战程序出错时返回内容

    概述我们可以把函数的运行结果分为两类。一类是预期结果，也就是正常情况下输出的结果。一类是非预期的结果，也就是函数在异常（或出错）情况下输出的结果。在正常情况下，函数返回数据的类型非常明确，但是在异常情况下，函数的返回数据类型确非常灵活，有多种选择，比如异常（Exception）、错误码、NULL值、特殊值（比如-1）、空对象（比如空字符串、空集合）等。在异常情况下，函数到底该返回什么样的数据类型，
    

    • 

  • 揭开访问者模式的神秘面纱-轻松增强对象行为
danci_ww
设计模式设计模式访问者模式软件工程java面试程序人生

    个人主页：danci_系列专栏：《设计模式》制定明确可量化的目标，坚持默默的做事。转载自：探索设计模式的魅力：揭开访问者模式的神秘面纱-轻松增强对象行为探索设计模式的魅力：揭开访问者模式的神秘面纱轻松增强对象行为文章目录一、案例场景1.1经典的运用场景1.2一坨坨代码实现1.3痛点二、解决方案2.1定义2.2案例分析2.3访问者模式结构图及说明2.4使用访问者模式重构示例2.5重构后解决的问题一、
    

    • 

  • java中常见的设计模式以及常见的面试题
山间漫步人生路
java设计模式

    在Java中，常见的设计模式同样包括创建型模式、结构型模式和行为型模式。下面是一些在Java中特别常见的设计模式及其简要描述：创建型模式：单例模式（SingletonPattern）：确保一个类只有一个实例，并提供一个全局访问点。Java中的java.lang.Runtime就是一个单例模式的经典例子。工厂模式（FactoryPattern）：定义一个用于创建对象的接口，让子类决定实例化哪一个类。
    

    • 

  • 面向对象设计之依赖反转原则
流星雨爱编程
#设计模式/架构设计java开发语言设计模式c++

    设计模式专栏：http://t.csdnimg.cn/4Mt4u目录1.引言2.控制反转(loC)3.依赖注入(DI)4.依赖注入框架(DlFramework)5.依赖反转原则(DIP)6.总结1.引言前面讲到，单一职责原则和开闭原则的原理比较简单，但在实践中用好比较难，而本节要讲的依赖反转原则正好相反。依赖反转原则的使用简单，但理解较难。在进行详细介绍之前，读者可以尝试回答下列向题。1)“依赖反
    

    • 

  • 什么是架构？架构设计原则是哪些？什么是设计模式？设计模式有哪些？
代码讲故事
架构师成长之路架构设计模式原则原理设计案例场景

    什么是架构？架构设计原则是哪些？什么是设计模式？设计模式有哪些？架构的本质架构本身是一种抽象的、来自建筑学的体系结构，其在企业及IT系统中被广泛应用。架构的本质是对事物复杂性的管理，是对一个企业、一个公司、一个系统复杂的内部关系进行结构化、体系化的抽象，并把相关的目标和当前现状通过不同的视图进行直观展示，方便相关人员达成共识，指导和驱动数字化项目落地实施。那到底什么是架构？下面我们先来看几个定义。
    

    • 

  • 16-Java命令模式 ( Command Pattern )
一名技术极客
Java设计模式java命令模式设计模式

    Java命令模式摘要实现范例命令模式（CommandPattern）中请求以命令的形式包裹在对象中，并传给调用对象调用对象寻找可以处理该命令的合适的对象，并把该命令传给相应的对象，该对象执行命令命令模式是行为型模式，一种数据驱动的设计模式摘要1.意图将一个请求封装成一个对象，从而使您可以用不同的请求对客户进行参数化2.主要解决在软件系统中，行为请求者与行为实现者通常是一种紧耦合的关系，但某些场合，
    

    • 

  • 矩阵求逆（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到设计文档中，那将会是一件非常痛苦的事情。
    

    •