设计模式随笔一

六个原则（Solid）

Single Responsibility Principle：单一职责原则--接口职责单一，类的设计尽量只有一个原因引起变化。

Open Closed Principle：开闭原则--一个软件实体如类（抽象）、模块、方法应该对扩展开放，对修改关闭。

Liskov Substitution Principle：里氏替换原则--父类能出现的地方，子类就可以替换父类。

Law of Demeter：迪米特法则--一个对象应该对其他对象有最少的了解（合理的公开public方法，尽量最少）。

Interface Segregation Principle：接口隔离原则--建立单一接口，不要建立臃肿庞大的接口（为模块提供单一接口）。

Dependence Inversion Principle：依赖倒置原则--面向接口（抽象类）编程。

设计模式

1.单例模式

确保某一个类只有一个实例，而且自行实例化并向整个系统提供这个实例。

public final  class Singleton {

	private static final Singleton INSTANCE = new Singleton();
	
	private Singleton(){}
	
	public static Singleton getInstance() {
		return INSTANCE;
	}
	
	public static void otherMethod(){
		
	}
}

//多线程版本<pre class="java" name="code">public static Singleton getInstance(){      
    if (instance == null)      
        synchronized(instance){      
            if(instance == null)      
                instance = new Singleton();      
        }      
    return instance;       
}

//按需加载

public class Singleton{      
    private Singleton(){      
        …      
    }      
    private static class SingletonContainer{      
        private static Singleton instance = new Singleton();      
    }      
    public static Singleton getInstance(){      
        return SingletonContainer.instance;      
    }      
}

Note:在并发编程中，需要考虑同步处理。

2.工厂方法模式

定义一个用于创建对象的接口，让子类决定实例化哪一个类。

在工厂方法模式中，抽象产品类Product负责定义产品的共性，实现对事物最抽象的定义。产品就是对象，就是要创建的对象。

一个通用的例子

	// 抽象产品：对象
	public abstract class Product {
		// 公共方法
		public void pubMethod() {
			// 具体逻辑实现
		}

		// 抽象方法
		public abstract void absMethod();
	}

	// 具体产品
	public class ConcreteProduct extends Product {
		private ConcreteProduct(){}
		@Override
		public void absMethod() {
			// 具体实现
		}
	}

	// 抽象工厂
	public abstract class Factory {
		// 创建产品，更加参数创建
		public abstract <T extends Product> T create(Class<T> clazz);
	}

	// 具体工厂
	public class ConcreteFactory extends Factory {
		@SuppressWarnings("unchecked")
		@Override
		public <T extends Product> T create(Class<T> clazz) {
			try {
				Product product = null;
				product = (Product) Class.forName(clazz.getName())
						.newInstance();
				return (T) product;
			} catch (Exception e) {
				e.printStackTrace();
			}
			return null;
		}

	}

	public static void main(String[] args) {
		Factory fac = new ConcreteFactory();
		Product pro = fac.create(ConcreteProduct.class);
	}

在单一场景中，修改为简单工厂模式

// 简单工厂
	public class SimpleFactory  { 
		@SuppressWarnings("unchecked")
		public <T extends Product> T create(Class<T> clazz) {
			try {
				Product product = null;
				product = (Product) Class.forName(clazz.getName())
						.newInstance();
				return (T) product;
			} catch (Exception e) {
				e.printStackTrace();
			}
			return null;
		}
	}

延迟初始化中应用工厂模式

public final class MapFactory {
	private static final Map<String, Product> map = new HashMap<>();

	public static synchronized Product create(String name) {
		Product p = null;
		if (map.containsKey(name)) {
			p = map.get(name);
		} else {
			p = new ConcreteProduct();
			map.put(name, p);
		}
		return p;
	}
}