设计模式

1.单例模式 ：

package com.ben.design;
/**
 * 单例模式
 * 场合：一个应用只需要一个，配置文件。工具类，线程池。日志对象
 * 类型：饿汉、懒汉模式
 * 
 * 1.将构造方法私有话，不允许外部直接创建
 * 2.创建类的唯一实例
 * 3.返回唯一实例对象方法
 * 下面是懒汉模式，
 */
public class Singleton {
	//饿汉模式
//	private static Singleton instance = new Singleton();
	//懒汉模式
	private static Singleton instance;
	private Singleton(){
		
	}
	public  static synchronized Singleton getInstance(){
		if (instance == null){
			instance = new Singleton();
		}
		return instance;				
	}	
}

2.简单工厂模式：

 简单工厂模式：

            1.生产接口

package com.ben.design;

public interface HairInterface {
	public void draw();
}

            2.具体生产车间

package com.ben.design;

public class LeftHair implements HairInterface {
	//实现了左偏分发型
	public void draw() {
		System.out.println("----左偏分----");
	}

}

package com.ben.design;

public class RightHair implements HairInterface {
	//实现了右偏分发型
	public void draw() {
		System.out.println("----右偏分----");
	}

}

            3.工厂类，调用具体的车间去生产

package com.ben.design;

import java.util.Map;

/**
 * 发型工厂
 * @author qweqwe
 *
 */
public class HairFactory {
	/**
	 * 根据类型创建对象
	 * 要是有多个实现类，则代码太冗余
	 * @return
	 */
	public HairInterface getHair(String key){
		if("left".equals(key)){
			return new LeftHair();
		}else if("right".equals(key)){
			return new RightHair();
		}else{
			return null;
		}			
	}
	/**
	 * 利用 反射，根据类的名称生产对象
	 * 不用再一个个if else new创建了
	 * spring BeanFactory就是使用这种方式
	 * @return
	 */
	public HairInterface getHairByClass(String className) {
		try {
			HairInterface hair = (HairInterface) Class.forName(className)
					.newInstance();
			return hair;
		} catch (InstantiationException e) {			
			e.printStackTrace();
		} catch (IllegalAccessException e) {
			e.printStackTrace();
		} catch (ClassNotFoundException e) {
			e.printStackTrace();
		}
		return null;
	}
	/**
	 * 上面方法的升级
	 * @param className
	 * @return
	 */
	public HairInterface getHairBykey(String key) {
		try {
			Map<String,String> map = new PropertiesReader().getProperties();
			HairInterface hair = (HairInterface) Class.forName(map.get(key))
					.newInstance();
			return hair;
		} catch (InstantiationException e) {			
			e.printStackTrace();
		} catch (IllegalAccessException e) {
			e.printStackTrace();
		} catch (ClassNotFoundException e) {
			e.printStackTrace();
		}
		return null;
	}
}

            4.配置文件读取类

package com.ben.design;

import java.io.IOException;
import java.io.InputStream;
import java.util.Enumeration;
import java.util.HashMap;
import java.util.Map;
import java.util.Properties;

/**
 * properties文件的读取类
 * @author qweqwe
 *
 */
public class PropertiesReader {
	
	public Map<String,String> getProperties(){
		Properties props = new Properties();
		Map<String,String> map = new HashMap<String,String>();
		try {
			InputStream in = getClass().getResourceAsStream("type.properties");
			props.load(in);
			Enumeration<?> en = props.propertyNames();
			while(en.hasMoreElements()){
				String key = (String) en.nextElement();
				String property = props.getProperty(key);
				map.put(key, property);
			}
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	
		return map;
	}
}

            5.测试类

package com.ben.design;

/**
 * 用来测试
 * 
 * @author qweqwe
 * 
 */
public class Test {
	public static void main(String[] args) {
		//1原始的生产方法， 太冗余
		// HairInterface left = new LeftHair();
		// left.draw();
		// HairInterface right = new RightHair();
		// right.draw();

		HairFactory factory = new HairFactory();
		//2
		// HairInterface left = factory.getHair("left");
		//3
//		HairInterface left = factory.getHairByClass("com.ben.design.LeftHair");
		//4
		HairInterface right = factory.getHairBykey("right");
		if (right != null)
			right.draw();
	}
}

    抽象工厂模式：一个工厂生产男装和女装，又分夏季和春季。这样就需要2个实际工厂，分别对应夏季和春季，同样，夏冬男装和女装要继承男女装接口。调用不同季节的工厂，生产不同季节的男女装

    实际就是将工厂再抽象一个抽象工厂，生产实际的工厂