设计模式学习一

门面模式

理解：门面模式就是将一些复杂的业务封装起来，对使用者之提供一个简单调用方法，使用者不须要知道方法里面业务细节。

主要包含业务接口、业务实现类、门面类、使用者

业务接口

package com.sean.design.facade;

/**
 * 完成写信过程的类
 * @author Administrator
 *
 */
public interface LetterProcess {

	/**
	 * 写信的内容
	 * @param context
	 */
	public void writeContext(String context);
	
	/**
	 * 写信封
	 * @param address
	 */
	public void fillEnvelope(String address);
	
	/**
	 * 信放到信封里面
	 */
	public void letterIntoEnvelope();
	
	/**
	 * 邮寄
	 */
	public void sendLetter();
}

业务实现类

package com.sean.design.facade;

public class LetterProcessImpl implements LetterProcess {

	@Override
	public void writeContext(String context) {
		System.out.println("写信的内容:"+context);
	}

	@Override
	public void fillEnvelope(String address) {
		System.out.println("写信封:"+address);
	}

	@Override
	public void letterIntoEnvelope() {
		System.out.println("将信装入到信封里面!");
	}

	@Override
	public void sendLetter() {
		System.out.println("将信邮寄出去！");
	}

}

门面类

package com.sean.design.facade;

public class ModenPostOffice {

	
	private LetterProcess letterProcess = new LetterProcessImpl();
	
	/**
	 * 将写信并邮寄整个过程封装到该方法中
	 * @param context
	 * @param address
	 */
	public void sendLetter(String context,String address){
		//写信的内容
		letterProcess.writeContext(context);
		//写信封
		letterProcess.fillEnvelope(address);
		//将信内容放入到信封中
		letterProcess.letterIntoEnvelope();
		//邮寄
		letterProcess.sendLetter();
	}
}

使用者

package com.sean.design.facade;

public class Client {

	public static void main(String[] args) {
		
		//写信并邮寄
		ModenPostOffice modenPostOffice = new ModenPostOffice();
		
		modenPostOffice.sendLetter("你好这是一封信件！", "邮寄地址");
	}
}

适配器模式

理解：通常理解为有两个类A、B要处理，目前使用者只能够处理A类，若要兼顾处理B类时，就须要增长一个适配器，将B类适配为A类的子类。适配器同时继承A和B类。在适配器内部将B类的处理转化为A类的方法。

主要包含现有能够被处理的类、被适配类、适配器、使用者

现有能够被处理类

package com.sean.design.adapter;

public interface InUser {

	public String getUserName();
}

被适配类接口

package com.sean.design.adapter;

public interface OutUser {

	public String getName();
}

被适配实现类

package com.sean.design.adapter;

public class OutUserImpl implements OutUser {

	@Override
	public String getName() {
		return "out-name";
	}

}

适配器：同时继承现有能够被处理类和被适配的类接口

package com.sean.design.adapter;

public class OutUserAdapter extends OutUserImpl implements InUser {

	@Override
	public String getUserName() {
		return super.getName();
	}

}

使用者：OutUser被适配以后能够直接当作InUser使用

package com.sean.design.adapter;

public class Client {

	public static void main(String[] args) {
		InUser myUser = new OutUserAdapter();
		String userName = myUser.getUserName();
		System.out.println(userName);
	}

}

模板方法模式

理解：在抽象类中定义了执行某个业务调用其余方法的顺序或逻辑。在子类中实现其余具体方法。

包含：抽象类中的模板方法、抽象类中未实现的基本方法、子类中实现的具体方法、钩子方法。

抽象类：包含模板方法，定义基本方法调用逻辑和顺序

package com.sean.design.template;

public abstract class HmModel {

	/**
	 * 基本方法
	 */
	protected abstract void start();

	/**
	 * 基本方法
	 */
	protected abstract void alarm();

	/**
	 * 钩子方法
	 * 
	 * @return
	 */
	protected abstract boolean isAlarm();

	/**
	 * 末班方法，在抽象类中实现
	 */
	public void run() {
		start();
		if (isAlarm()) {
			alarm();
		}

	}
}

子类1：具体方法实现

package com.sean.design.template;

public class Hm1Model extends HmModel {

	@Override
	protected void start() {
		System.out.println("这是模板1:start");
	}

	@Override
	protected void alarm() {
		System.out.println("这是模板1:alarm");
	}

	@Override
	protected boolean isAlarm() {
		return false;
	}

}

子类2：具体方法实现

package com.sean.design.template;

public class Hm2Model extends HmModel {

	@Override
	protected void start() {
		System.out.println("这是模板2:start");
	}

	@Override
	protected void alarm() {
		System.out.println("这是模板2:alarm");
	}

	@Override
	protected boolean isAlarm() {
		return true;
	}

}

调用模板方法

package com.sean.design.template;

public class Client {

	public static void main(String[] args) {
		HmModel hm1 = new Hm1Model();
		hm1.run();
		
		HmModel hm2 = new Hm2Model();
		hm2.run();
	}
}

建造者模式

理解：相似于工厂模式，有专门的建造者类负责产生product对象，建造者模式中产生product对象时能够设置一些逻辑。工厂模式产生的对象能够使不一样类型，而一个建造者产生的对象都是相同类型。

包含产品抽象类、产品子类、建造者接口，建造者类、使用者

产品抽象类

package com.sean.design.builder;

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

public abstract class Product {
	
	public List<String> seq = new ArrayList<>();
	
	public abstract void business1();
	
	public abstract void business2();
	
	
	public void run(){
		for (String str : seq) {
			if("business1".equals(str)){
				business1();
			}
			if("business2".equals(str)){
				business2();
			}
		}
	}
	

}

产品子类

package com.sean.design.builder;

public class ProductImpl extends Product {

	@Override
	public void business1() {
		System.out.println("产品1方法:business1");
	}

	@Override
	public void business2() {
		System.out.println("产品1方法:business2");
	}

}

建造者接口

package com.sean.design.builder;

import java.util.List;

public interface ProductBuilder {

	/**
	 * 设置参数
	 * @param seq
	 */
	public void setSeq(List<String> seq);
	
	/**
	 * 建造产品
	 * @return
	 */
	public Product createProduct();
}

建造者实现类

package com.sean.design.builder;

import java.util.List;

public class ProductBuilderImpl implements ProductBuilder {

	Product p = new ProductImpl();
	
	@Override
	public void setSeq(List<String> seq) {
		p.seq = seq;
	}

	@Override
	public Product createProduct() {
		return p;
	}

}

使用者

package com.sean.design.builder;

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

public class Client {

	public static void main(String[] args) {
		//建造者
		ProductBuilder pBuilder = new ProductBuilderImpl();
		List<String> seq = new ArrayList<>();
		seq.add("business2");
		seq.add("business1");
		pBuilder.setSeq(seq);
		
		//经过建造者建立对象
		Product product = pBuilder.createProduct();
		
		product.run();
	}
}