常用设计模式的理解

1,单例模式:  1,构造方法为私有; 2,有个getInstance()方法返回唯一的实例(整个系统唯一)
//a,饿汉式单例,一般java中使用饿汉模式
public class Singleton {      
    private static Singleton singleton = new Singleton();  
    private Singleton(){}  
    public static Singleton getInstance(){  
        return singleton;  
    }  
}
//b,懒汉式单例,一般C#中使用懒汉模式
public class Singleton {  
    private static Singleton singleton;  
    private Singleton(){}  
      
    public static synchronized Singleton getInstance(){  
        if(singleton==null){  
            singleton = new Singleton();  
        }  
        return singleton;  
    }  
}  
		
2,工厂方法模式:   有工厂接口,有产品接口, 产品实例由工厂的createProduct()方法得到
interface IProduct {  
    public void productMethod();  
}  
  
class Product implements IProduct {  
    public void productMethod() {  
        System.out.println("产品");  
    }  
}  
  
interface IFactory {  
    public IProduct createProduct();  
}  
  
class Factory implements IFactory {  
    public IProduct createProduct() {  
        return new Product();  
    }  
}  
  
public class Client {  
    public static void main(String[] args) {  
        IFactory factory = new Factory();  
        IProduct prodect = factory.createProduct();  
        prodect.productMethod();  
    }  
}  


3,简单工厂模式:   与工厂方法的区别就是 1,没有工厂接口, 2,工厂中有一个实例化产品的静态方法
举例: Calendar.getInstance() 就是典型的简单工厂模式: 工厂(Calender)有个一个静态的方法getInstance()得到不同的产品(Calender实例)
PS: 这个例子有点特殊工厂(Calendar)和产品(Calendar)是同一个类
PS: 如果每次调用 Calendar.getInstance() 得到不一样的实例就是简单工厂模式; 如果得到的实例是同一个实例那就是单例模式 ; 如果工厂(Calendar)要从接口(ICalendar)实例化那就是工厂方法模式


4,抽象工厂方法模式:
//产品1
interface IProduct1 {  
    public void show();  
}  
//产品2
interface IProduct2 {  
    public void show();  
}  
  
class Product1 implements IProduct1 {  
    public void show() {  
        System.out.println("这是1型产品");  
    }  
}  
class Product2 implements IProduct2 {  
    public void show() {  
        System.out.println("这是2型产品");  
    }  
}  
//只有一个工厂,却能实例化多个产品
interface IFactory {  
    public IProduct1 createProduct1();  
    public IProduct2 createProduct2();  
}  
class Factory implements IFactory{  
    public IProduct1 createProduct1() {  
        return new Product1();  
    }  
    public IProduct2 createProduct2() {  
        return new Product2();  
    }  
}  
  
public class Client {  
    public static void main(String[] args){  
        IFactory factory = new Factory();  
        factory.createProduct1().show();  
        factory.createProduct2().show();  
    }  
}  

就是在工厂方法里面能产生不同类型的产品 IProduct createProduct()-->IProduct1 createProduct1() 和 IProduct2 createProduct2() 等等
说白了就是: 工厂方法模式中工厂接口(IFactory)只有一个需要实现的方法 而 抽象工厂方法模式中工厂接口(IFactory)里面有多个需要实现的方法



5,原型模式:  指实现clone()方法达到复制实例的目的

以上集中模式都是创建类模式,本质上都是对对象的创建过程进行封装。


【行为类模式】
6,模版方法模式:   定义一个操作中算法的框架，而将一些步骤延迟到子类中，使得子类可以不改变算法的结构即可重定义该算法中的某些特定步骤。
本质: 虚方法(abstract)   ;  我们定义一个接口,延迟到具体业务中去实现,也属于模版方法模式

7,中介者模式:  同事类直接的交互通过中介类来实现,就叫中介者模式       
同事类: A和B如果是同事类,则: A的属性变更会影响B的属性,  B的属性变更会影响A的属性
通过将中介者作为参数传入A,B中来达到A,B互相影响的目的  这种设计模式叫中介者模式

8,观察者模式:  
C#的事件处理就是用观察者模式实现的,例如添加点击按钮的事件处理 btn1.click += btn1_click1;  btn1.click += btn1_click2;  这样我们就给btn1添加了两个观察者btn1_click1,btn1_click2(只是这里的观察者是一个方法,一般来说观察者是一个对象)
典型的观察者模式代码:
abstract class Subject {
	private Vector<Observer> obs = new Vector<Observer>();
	//添加,删除观察者
	public void addObserver(Observer obs){
		this.obs.add(obs);
	}	
	public void delObserver(Observer obs){
		this.obs.remove(obs);
	}
	protected void notifyObserver(){
	    //通知所有的观察者
		for(Observer o: obs){
			o.update();
		}
	}
	public abstract void doSomething();
}

class ConcreteSubject extends Subject {
	public void doSomething(){
		System.out.println("被观察者事件反生");
		this.notifyObserver();
	}
}
interface Observer {
	public void update();
}
class ConcreteObserver1 implements Observer {
	public void update() {
		System.out.println("观察者1收到信息，并进行处理。");
	}
}
class ConcreteObserver2 implements Observer {
	public void update() {
		System.out.println("观察者2收到信息，并进行处理。");
	}
}

public class Client {
	public static void main(String[] args){
		Subject sub = new ConcreteSubject();
		sub.addObserver(new ConcreteObserver1()); //添加观察者1
		sub.addObserver(new ConcreteObserver2()); //添加观察者2
		sub.doSomething();
	}
}

动态绑定和静态绑定
子类基础父类,重写了父类的方法叫覆盖: 覆盖是动态绑定的
同一个类中,一个方法有多个实现叫重载: 重载是静态绑定的

9,命令模式:
10,责任连模式:  调用nextHandler来代替else if;  当if的判断条件比较复杂时可以用责任链模式重构
11,策略模式:	基于一个基类,实现了两个子类   这个过程就是策略模式
13,迭代器模式:	foreach循环就是迭代器模式,    你如果有几个集合,你去实现他的迭代方法, 就是迭代器模式
14,解释器模式:	解释代码的执行方式,相当于java虚拟机解析java代码的过程
15,备忘录模式: