面经整理-设计模式

本文是作者整理的个人笔记，文中可能引用到其他人的成果但是未指明出处，如有不妥，请指正，谢谢！

转载注明：http://blog.csdn.net/u012294820/article/details/78733998

单例的实现方式（懒汉，恶汉，静态内部类，枚举，双重检查）

参考一：http://note.youdao.com/noteshare?id=571f8ae9d2d2c5265b43136d5e65673f&sub=374A446B97EC464180FA90A3BC1F4378

单例模式的好处

1. 确保全局唯一性
2. 节约系统资源
3. 避免对共享资源的多场占用

观察者模式

观察者模式（又被称为发布-订阅（Publish/Subscribe）模式，属于行为型模式的一种，它定义了一种一对多的依赖关系，让多个观察者对象同时监听某一个主题对象。这个主题对象在状态变化时，会通知所有的观察者对象，使他们能够自动更新自己。

//观察者：
public class WeixinUser implements Observer {
    private String name;
    public WeixinUser(String name) {
        this.name = name;
    }
    public void update(String message) {
        System.out.println(name + "-" + message);
    }
}
//被观察者：
public class SubscriptionSubject implements Subject {
    private List weixinUserlist = new ArrayList();
    public void attach(Observer observer) {
        weixinUserlist.add(observer);
    }
    public void detach(Observer observer) {
        weixinUserlist.remove(observer);
    }
    public void notify(String message) {
        for (Observer observer : weixinUserlist) {
            observer.update(message);
        }
    }
}
//客户端：
public class Client {
    public static void main(String[] args) {
        SubscriptionSubject mSubscriptionSubject=new SubscriptionSubject();
        //创建微信用户
        WeixinUser user1=new WeixinUser("杨影枫");
        WeixinUser user2=new WeixinUser("月眉儿");
        WeixinUser user3=new WeixinUser("紫轩");
        //订阅公众号
        mSubscriptionSubject.attach(user1);
        mSubscriptionSubject.attach(user2);
        mSubscriptionSubject.attach(user3);
        //公众号更新发出消息给订阅的微信用户
        mSubscriptionSubject.notify("刘望舒的专栏更新了");
    }
}

举例：Android中BaseAdapter是被观察者，ListView是观察者

装饰器模式和代理模式的区别

装饰器模式：以对客户端透明的方式扩展对象的功能，是继承关系的一个替代方案；

代理模式：给一个对象提供一个代理对象，并由代理对象来控制对原有对象的引用；

区别：

• 代理模式，在一个代理类中创建被代理对象的实例。
• 装饰器模式，将原始对象作为一个参数传给装饰器的构造器。

举例：

• 代理模式：1）Spring AOP动态代理，2）Struts2中Action代理
• 装饰器模式：文件IO流，BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(new FileInputStream(new File("d:/text.txt"))));

代理模式：

//代理对象
public class Proxy implements Subject{
       private Subject subject;
       public Proxy(){
             //关系在编译时确定
            subject = new RealSubject();
       }
       public void doAction(){
             ….
             subject.doAction();
             ….
       }
}
//代理的客户
public class Client{
        public static void main(String[] args){
             //客户不知道代理委托了另一个对象
             Subject subject = new Proxy();
        }
}

装饰器模式：

//装饰器对象
public class Decorator implements Component{
        private Component component;
        public Decorator(Component component){
            this.component = component
        }
       public void operation(){
            ….
            component.operation();
            ….
       }
}
//装饰器的客户
public class Client{
        public static void main(String[] args){
            //客户指定了装饰者需要装饰的是哪一个类
            Component component = new Decorator(new ConcreteComponent());
        }
}

参考一： 装饰模式与代理模式的区别(转载)

工厂方法模式

同一个工厂，同一个方法，根据参数生产不同的对象

public class Factory {
     //可以在工厂类中添加任何你所需要的逻辑
     public static Product create(String str)
     {
         //生成ProductA
         if(str.equalsIgnoreCase("ProductA"))
         {
             return new ProductA();
         }
         else
             //生成ProductB
             if(str.equalsIgnoreCase("ProductB"))
             {
                 return new ProductB();
             }
         return null;
     }
  }

工厂方法模式

不同的工厂，生产不同的产品

public class FactoryA implements Factory {
     //实现工厂类的方法生成产品类A
     public Product createProduct()
     {
         return new ProductA();
     }
 }

 public class FactoryB implements Factory {
     //实现工厂类的方法生成产品类B
     public Product createProduct()
     {
         return new ProductB();
     }
 }

抽象工厂模式

不同的工厂，生产不同类型的产品，而同一个工厂可以生产同一个类型的多种产品

public class FactoryA implements Factory {
     @Override
     public Product createProduct()
     {
         return new ProductA();
     }
     @Override
     public Gift createGift()
     {
         return new GiftA();
     }
 }

 public class FactoryB implements Factory {
     @Override
     public Product createProduct() {
         return new ProductB();
     }
     @Override
     public Gift createGift() {
         return new GiftB();
     }
 }