几个遇到的设计模式

1:代理模式和中介模式和外观模式

代理模式 是一对一情况
A 要访问 C 但是 B里面有成员C, 对C的一些接口重新提供接口，A通过访问B 获得和C交互

安全代理，就是B根据A的情况限制A 可以访问C的范围


中介模式是 我需要和 多个对象交互，多个对象也可能和我交互。
       如果我和每个人多交互，但是我不想那么耦合，
       那么就创建一个 中介类， 而我只和中介类交互，，其他人需要和我交互也只和中介类交互
 
       把全部耦合在中介类里
       在我成员里拥有一个通用 中介对象，需要和其他交互时调用 中介，其他人也一样

一般中介模式由三部分组成
   @1： Mediator 抽象的中介角色  
   @2： Concrete Mediator 具体的中介角色
   @3： Colleague  同事角色(需要和你交互的)，共同拥有同一个具体中介角色
  


门面模式(外观):为一个复杂的模块或子系统提供一个供外界访问的接口.子系统相对独立——外界对子系统的访问只要黑箱操作即可
比如利息的计算问题，没有深厚的业务知识和扎实的技术水平是不可能开发出该子系统 的，但是对于使用该系统的开发人员来说，他需要做的就是输入金额以及存期，其他的都不 用关心，返回的结果就是利息，这时候，门面模式是非使用不可了。

2：单列模式

整个程序，只实例化一次，只有一个对象，一般全局类型的管理器，都要写成单例。

常见的实现方式:懒汉式单例
class CSingletonDemo
{

private:
 static CSingletonDemo *s;
public:
  static CSingletonDemo* getInstance(){
   
       if(NULL ==s){
          s = new CSingletonDemo ();
       }
       
       return s;
  } 
}
CSingletonDemo  *CSingletonDemo::s =NULL;

饿汉式单例:和懒汉一样，只是修改
CSingletonDemo  *CSingletonDemo::s =new CSingletonDemo ();

 3:装饰模式

3 装饰模式
package decorator;
import java.awt.*;
import javax.swing.*;
public class MorriganAensland
{
    public static void main(String[] args)
    {
        Morrigan m0=new original();
        m0.display();
        Morrigan m1=new Succubus(m0);
        m1.display();
        Morrigan m2=new Girl(m0);
        m2.display();
    }
}
//抽象构件角色：莫莉卡
interface  Morrigan
{
    public void display();
}
//具体构件角色：原身
class original extends JFrame implements Morrigan
{
    private static final long serialVersionUID = 1L;
    private String t="Morrigan0.jpg";
    public original()
    {
        super("《恶魔战士》中的莫莉卡·安斯兰");                
    }
    public void setImage(String t)
    {
        this.t=t;           
    }
    public void display()
    {   
        this.setLayout(new FlowLayout());
        JLabel l1=new JLabel(new ImageIcon("src/decorator/"+t));
        this.add(l1);   
        this.pack();       
        this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);  
        this.setVisible(true);
    }
}
//抽象装饰角色：变形
class Changer implements Morrigan
{
    Morrigan m;   
    public Changer(Morrigan m)
    {
        this.m=m;
    }   
    public void display()
    {
        m.display();
    }
}
//具体装饰角色：女妖
class Succubus extends Changer
{
    public Succubus(Morrigan m)
    {
        super(m);
    }   
    public void display()
    {
        setChanger();
        super.display();   
    }
    public void setChanger()
    {
        ((original) super.m).setImage("Morrigan1.jpg");           
    }
}
//具体装饰角色：少女
class Girl extends Changer
{
    public Girl(Morrigan m)
    {
        super(m);
    }   
    public void display()
    {
        setChanger();
        super.display();   
    }
    public void setChanger()
    {
        ((original) super.m).setImage("Morrigan2.jpg");           
    }
}

基本逻辑
需要装饰类A 那就写一个类B 将类A当做参数传入类B,在类B里对类A进行修改装饰，修改装饰仅用类A对外提供的接口


使用场景
当需要给一个现有类添加附加职责，而又不能采用生成子类的方法进行扩充时。例如，该类被隐藏或者该类是终极类或者采用继承方式会产生大量的子类。
当需要通过对现有的一组基本功能进行排列组合而产生非常多的功能时，采用继承关系很难实现，而采用装饰模式却很好实现。
当对象的功能要求可以动态地添加，也可以再动态地撤销时。

 4：观察者模式

4:观察者模式

   有两个抽象类 
         IObservable   被观察者          被观察者要继承该类
         IObserver     观察者            观察者要继承该类

    class IObservable
    {
      public void addObserver(Observer observer);
      public void deleteObserver(Observer observer); 
      public void notifyObservers(String context); 
      vector<IObserver> 
   }   被观察者抽象类 里有 观察者列表， 当观察事件发生时 依次通知

观察者也叫发布订阅模式， 当你需要观察的时候，继承下观察者 然后在被观察者那里注册下就可以了addObserver

 6:简单的工厂类

6:简单的工厂模式

 基类: 运算基类
 派生类:  乘法类，除法类，加法类，减法类

 工厂类： 根据需求传入类型，在工厂类里创建出对应的 的 派生类，返回基类