设计模式

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个实际工厂，分别对应夏季和春季，同样，夏冬男装和女装要继承男女装接口。调用不同季节的工厂，生产不同季节的男女装
实际就是将工厂再抽象一个抽象工厂，生产实际的工厂