面经整理-设计模式

最新推荐文章于 2025-01-08 09:08:02 发布

功夫小子1917

最新推荐文章于 2025-01-08 09:08:02 发布

阅读量1.1k

点赞数

文章标签：设计模式

本文链接：https://blog.youkuaiyun.com/u012294820/article/details/78733998

版权

本文总结了设计模式在确保全局唯一性和节约系统资源方面的应用。通过代理模式实现对共享资源的高效管理，如Spring AOP动态代理和Struts2中的Action代理。同时探讨了装饰器模式如何在文件IO流中发挥作用，例如使用BufferedReader对InputStreamReader进行装饰，以提升读取效率。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

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

转载注明：http://blog.youkuaiyun.com/u012294820/article/details/78733998

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

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

 
 单例模式的好处 

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

 
 观察者模式 

  观察者模式（又被称为发布-订阅（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<Observer> weixinUserlist = new ArrayList<Observer>();
    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();
     }
 }