设计模式遵循原则 Java单例模式 代理模式

设计模式遵循的原则 

1、开闭原则（Open Close Principle）对扩展开放，对修改关闭。

2、里氏代换原则（Liskov Substitution Principle）只有当衍生类可以替换掉基类，软件单位的功能不受到影响时，基类才能真正被复用，而衍生类也能够在基类的基础上增加新的行为。

3、依赖倒转原则（Dependence Inversion Principle）这个是开闭原则的基础，对接口编程，依赖于抽象而不依赖于具体。

4、接口隔离原则（Interface Segregation Principle）使用多个隔离的借口来降低耦合度。

5、迪米特法则（最少知道原则）（Demeter Principle）一个实体应当尽量少的与其他实体之间发生相互作用，使得系统功能模块相对独立。

6、合成复用原则（Composite Reuse Principle）尽量使用合成/聚合的方式，而不是使用继承。继承实际上破坏了类的封装性，超类的方法可能会被子类修改。

单例模式

//not thread safe
class Singleton1 {
	private static Singleton1 instance = null;

	private Singleton1() {

	}

	public static Singleton1 getInstance() {
		if (instance == null) {
			instance = new Singleton1();
		}
		return instance;
	}
}

// thread safe
class Singleton2 {
	private static Singleton2 instance = null;

	private Singleton2() {

	}

	public static synchronized Singleton2 getInstance() {
		if (instance == null) {
			instance = new Singleton2();
		}
		return instance;
	}
}

// thread safe 
class Singleton3 {
	private static Singleton3 instance = null;

	private Singleton3() {

	}

	public static Singleton3 getInstance() {
		if (instance == null) {
			synchronized (Singleton3.class) {
				if (instance == null) {
					instance = new Singleton3();
				}
			}
		}
		return instance;
	}
}

// thread safe  use memory
class Singleton4 {
	private static Singleton4 instance = new Singleton4();
	private Singleton4(){
	        
	}
	public static Singleton4 getInstance() {
		return instance;
	}
}

//thread safe inner class
class Singleton5{
	 private Singleton5(){
	        
	 }
     private static class SingletonHolder{
        private final static Singleton5 instance=new Singleton5();
     }
	 public static Singleton5 getInstance(){
	    return SingletonHolder.instance;
	 }
}
//enum is singleton object
enum Singleton6{
	Instance;
}

代理模式

// use proxy mode  Expansion class
public interface Proxy{
	void doit();
}

class A implements Proxy {

	@Override
	public void doit() {
		System.out.println("A do it");
	}
 
}

class B implements Proxy{
    A a = new A();
	@Override
	public void doit() {
		a.doit();
	}
	
}

工厂模式

public class Factory {
    interface Shape{
    	void draw();
    }
    
    class Rectangle implements Shape{
		@Override
		public void draw() {
			System.out.println("rectangle");
		}
    }
    
    class Square implements Shape{
		@Override
		public void draw() {
			System.out.println("square");
		}
    }
    class Circle implements Shape{
		@Override
		public void draw() {
			System.out.println("circle");
			
		}
    }
    
    class ShapeFactory{
    	public Shape getShape(String shapeType) {
    		if(shapeType==null) {
    			return null;
    		}else if(shapeType.equals("circle")) {
    			return new Circle();
    		}else if(shapeType.equals("rectangle")) {
    			return new Rectangle();
    		}else if(shapeType.equals("square")) {
    			return new Square();
    		}
    		return null;
    	}
    }
    
}

策略模式

public class Strategy {
    public static void main(String[] args) {
    	Context context = new Context(new OperationAdd());
    	System.out.println(context.executeStrategy(1, 2));
    	context = new Context(new OperationSubstract());
    	System.out.println(context.executeStrategy(1, 2));
    	context = new Context(new OperationMultiply());
    	System.out.println(context.executeStrategy(1, 2));
    }
}
interface C{
	public int doOperation(int num1,int num2);
}
class OperationAdd implements C{
	@Override
	public int doOperation(int num1,int num2) {
    	return num1+num2;
    }
}    
class OperationSubstract implements C{
	@Override
	public int doOperation(int num1, int num2) {
		return num1-num2;
	}  	
}
class OperationMultiply implements C{
	@Override
	public int doOperation(int num1, int num2) {
		return num1 * num2;
	}
}
class Context{
	private C c;
	public Context(C c) {
		this.c = c;
	}
	public int executeStrategy(int num1,int num2) {
		return c.doOperation(num1, num2);
	}
}