精华内容
下载资源
问答
  • 代理模式: class B {  A a;  public B(){a=new A();}  f(){a.f()} } B b=new B(); b.f(); //实质就是调用A的f方法 适配器模式: class B implements AA{  AA a =new A();  f(){a.f()} } AA aa=ne

    代理模式:

    class B {

         A a;

         public B(){a=new A();}

         f(){a.f()}

    }

    B b=new B();

    b.f();    //实质就是调用A的f方法

    适配器模式:

    class B implements  AA{

         A a =new A();

       attack(){a.攻击();}

    }

    AA aa=new B();

    aa.attack();  //AA接口类型的变量实际调用了A类的攻击()方法,

     

    //通过接口调用A类的方法,A的方法和接口的方法不一致,需要“翻译者类B”适配

    //AA接口中attack()方法,而A中是   进攻()  方法,也就是说A不是AA接口的实现类 ,这个AA a =new A();行不通

    //所以换成AA a=new B();构造B类成为AA接口的实现类,重写attack()方法,而该方法的实现用的是A类的  进攻()  方法

    展开全文
  • 代理模式  组成:  抽象角色:通过接口或抽象类声明真实角色实现的业务方法。  代理角色:实现抽象角色,是真实角色的代理,通过真实角色的业务逻辑方法来实现抽象方法,并可以附加自己的操作...
  • 适配器模式和代理模式比较专题1

    千次阅读 2012-05-20 00:36:15
    适配器模式和代理模式是二个比较容易混淆的模式,我想谈一下这两个模式的差别,不过我先分别介绍一下这二个模式,然后再做比较,我想这样大家可能会比较容易理解,对于不懂这两个模式的人来说也多个了解的机会。...

    设计模式适配器模式

    适配器模式和代理模式是二个比较容易混淆的模式,我想谈一下这两个模式的差别,不过我先分别介绍一下这二个模式,然后再做比较,我想这样大家可能会比较容易理解,对于不懂这两个模式的人来说也多个了解的机会。

    适配器说通俗点就是把一个东西包装一下变成另外一个东西,为什么要包装而不直接就用这个东西呢?呵呵,如果能直接用就犯不着适配了,要适配当然就是由于某些原因你用不了当前这个东西。最容易理解的就是电器的例子,比如你在中国买的电器使用电压是220V,结果你跑到国外去了,国外提供的电压是110V,问题就来了,你必须使用的是220V的,国外提供给你的却只有110V的,所以你根本就用不了,除非你能够将110V的转化成为220V才能行。此时适配器就排上用场了,你使用一个转压器不就可以把110V专成220V了吗?对于程序设计亦然。

             下面举一个例子,假如你开始做一个项目的时候你需要写一个集合的枚举接口如下:

    public interface Enumeration

         {

             bool HasMoreElement();

             object nextElement();

         }

           调用的方法如下:

    public void BeforeDisplay(Enumeration e)

         {

             while (e.HasMoreElement())

             {

                  e.nextElement();

             }

         }

           后来由于某一种原因(可能是代码重构、或者类库升级),你定义了另外一个新的集合枚举接口如下:

    public interface Iterator

         {

             bool MoveNext();

             object Current();

             void Reset();

         }

           使用新的接口调用方法如下:

    public void OldDisplay(Iterator e)

         {

             while (e.MoveNext())

             {

                  e.Current();

             }

         }

         现在如果要求新的方法都只使用新的接口一切都很顺利,但是由于原来的很多方法用的仍然是旧的接口,而由于逻辑的重用或者 为了升级后类库的向前兼容,你需要将当前的新接口Iterator转换成旧的接口Enumeration以调用原来的方法,这时候就需要我们写一个适配器。

         如何编写适配器?由于我们需要用的是Enumeration接口,所以适配器必须是Enumeration的,即必须继承自Enumeration;接着想我们需要利用新的Iterator做业务,简单点就是我们需要用Iterator中的方法,所以最容易想到的一个方法就是拥有一个Iterator的实例,直接调用该实例的方法实现Enumeration接口不就可以了吗?(如果Iterator是个具体的类,我们还可以再继承该类,来个双重继承,利用该具体类的方法实现Enumeration接口,效果一致)

         示例代码如下:

    public class Itermeration:Enumeration

         {

             private Iterator it;

             public Itermeration(Iterator it)

             {

                  this.it=it;

             }

     

             public bool HasMoreElement()

             {

                  return it.MoveNext();

             }

     

             public object nextElement()

             {

                  return it.Current();

             }

         }

         注意:由于我们需要将新接口Iterator转换成旧的接口Enumeration,所以新的类必须继承旧的接口Enumeration,将传入的Iterator转换成Enumeration接口。这样调用方法如下:

    public void Display(Iterator e)

         {

             BeforeDisplay(new Itermeration(e));

               //此处将Iterator转化为Itermeration,而Itermeration又是继承自Enumeration,所以实际上就是将Iterator转化为Enumeration

         }

         注意:我们为了将Iterator转化成Enumeration,采用的方式是在他们之间增加了一层,使用Itermeration类来转化,这是面向对象设计中抽象的一个主要思想,贯穿很多设计模式。

         适配器模式有两种,我现在举的这个例子是对象的适配器模式,还有一种是类的适配器模式(对应上边括弧中的注释),这两种方式网上介绍的已经太多,我这里就不再赘述,当然现实中以对象的适配器模式使用最多,这也是为什么我举这种类型例子的原因。

         其实适配器的思想是很容易理解的,很多人觉得困惑的原因常常不是他们不知道什么是适配器,而是他们联系自己曾有的经验,找不到要这么做的理由,所以内心深处总是对这么做感觉疑惑,当然很多其他的模式也是如此。

         那到底什么时候需要用适配器呢?一个根本的理由就是系统需要使用现有的类,但是这个类的接口不符合当前的要求。

         注意我这里说的是根本理由,因为这个理由是适配器出现的致命原因,由于这个理由出现了适配器,然后我们仔细揣摩出现后的适配器突然就发现他还有其它的好处,也就冒出了其它的理由。我强调这个的主要原因就是因为很多人开始看一篇文章描述觉得好像是这么回事,结果又看其它人的文章反而觉得越来越迷糊,实际上很大程度上的原因是很多文章往往为了强调全面而花了很多笔墨去写那些后来想起来的好处,而对根本理由轻轻带过,导致很多人误以为导出这种模式的原因是为了使用后来这些好处,结果就越搅越迷糊了。

         这里我给出另外一个使用理由,如果你看不太懂没有关系,完全可以忽略不看。

         另一个理由就是我们系统中有很多彼此不大关联的类,而且这些类的接口都非常简单,(注意是接口都非常简单,如果都比较复杂用这种方法就是没事找事)。现在我想建立一个可以重复使用的类来跟这些简单类打交道,于是就使用适配,个人认为纯粹是为了方便。

    展开全文
  • 1.适配器模式 将一个类的接口转换成客户希望的另一个接口,使得原本接口不兼容而不能一起工作的类可以一起工作 应用场景:1.《设计模式》中提到如果想使用一个已经存在的类,但它的接口与你的要求不一致,可以使用...

    1.适配器模式

    将一个类的接口转换成客户希望的另一个接口,使得原本接口不兼容而不能一起工作的类可以一起工作

    应用场景:1.《设计模式》中提到如果想使用一个已经存在的类,但它的接口与你的要求不一致,可以使用设计模式

                       2.我自己的一点认识,Java中就是如果一个类需要实现某个接口中的部分方法,如果通过直接继承该接口的话,需要去实现所有的

    方法但是如果先用一个类继承 该 接 口,然后所有方法采用空实现,其他类再去继承该类则避免了要对接口的所有方法进行实现


    代码:

    //1.场景1
    //客户希望的的的接口
    public interface Target{
        public void request();
    }
    
    //当前使用的类
    public class MyClass{
        public void specificRequest(){
            ……
        }
    }
    
    //使用适配器使得能提供客户需要的接口
    public class TargetClass extends MyClass implements Target{
       
        @Override
        public void request(){
            super.specificRequest();
        }
    }
    
    
    //场景2
    //想使用的接口
    public interface Resource{
        public void method1();
        public void method2();
        ……
    }
    
    //只需要使用接口中的 method1方法的类,直接继承的情况
    public class PartOfResource implements Resource{
        public void method1(){
            System.out.println("method1……")
        }
        
        public void method2(){}
        public void method3(){}
        ……
    }
    
    //适配器类
    public class ResourceAdapter implements Resource{
        public void method1(){}
        public void method2(){}
        public void method3(){}
        ……
    }
    
    //只需要使用接口中的 method1方法的类,间接继承的情况
    public class PartOfResource extends ResourceAdapter{
         public void method1(){
            System.out.println("method1……")
        }
    }
    
    


    2.代理模式

    为其他对象提供一种代理以控制对这个对象的访问


    代码:

    public abstract Subject{
        public abstract void Request();
    }
    
    public class RealSubject extends Subject{
        @Override
        public void Request(){
            System.out.println("RealSubject");
        }
    }
    
    public class SubjectProxy extends Subject{
        RealSubject  realSubject;
        @Override
        public void Request(){
        if(realSubject==null){
            realSubject=new RealSubject();
        }
        realSubject.Request();
        }
    }
    //1.静态代理
    public interface Ilogin(){
        public void login();
        public void logout();
    }
    
    public class RealLogin implements Ilogin{
        public void login(){
            System.out.println("login……");
        }
        
        public void logout(){
            System.out.println("logout……");
        }
    }
    
    public class LoginProxy implements Ilogin{
        private RealLogin realLogin;
         public void login(){
            System.out.println("go to login");
            realLogin.login();
            System.out.println("login success");
        }
        
        public void logout(){
            System.out.println("go to logout");
            realLogin.logout();
            System.out.println("logout success");
        }
    }
    
    //思考一个问题,如何避免重复的代码?没错,使用反射
    //2.动态代理,JDK中提供一个Proxy类
    public class MyInvocationHandler implements InvocationHandler{
        private Object target;  
     
        public MyInvocationHandler(Object target){  
            this.target = target;  
        }  
        
        
        @Override  
        public Object invoke(Object proxy, Method method, Object[] args)throws Throwable {
            
             System.out.println("begin……");
             Object retValue = method.invoke(target, args);
             System.out.println("end……");
        }
    
    }
    //测试类
    public class Test{
        public static void main(String[] args){
            Ilogin target=new RealLogin();
            InvocationHandler handler=new MyInvocationHandler(target);
            Ilogin proxy=(Ilogin)Proxy.newProxyInstance(target.getClass().getClassLoader(),
            target.getClass().getInterfaces(),handler);
            proxy.login();
            proxy.logout();
        }
    }
    
    
    




    展开全文
  • 代理模式:  class B {  A a;  public B(){a=new A();}  f(){a.f()} } B b=new B(); b.f(); //实质就是调用A的f方法   适配器模式: class B implements AA{  AA a =new A...

    代理模式:

     class B {

         A a;

         public B(){a=new A();}

         f(){a.f()}

    }

    B b=new B();

    b.f();    //实质就是调用A的f方法

     

    适配器模式:

    class B implements  AA{

         AA a =new A();

        f(){a.f()}

    }

    AA aa=new B();

    aa.f();

    //通过接口调用A类的方法,A的方法和接口的方法不一致,需要“翻译者类B”适配

    //D接口中attack()方法,而A中是   进攻()  方法

    //一般的如果适配就是AA a =new A(); a.f();

    展开全文
  • 简介 适配器模式适配器模式(英语:adapter pattern)有时候也称包装样式或者包装。将一个类的接口转接成用户所期待的。一个适配使得因接口不兼容而不能在一起工作的类工作在一起,做法是将类自己的接口包裹在一个...
  •  适配器模式适配器模式(英语:adapter pattern)有时候也称包装样式或者包装。将一个类的接口转接成用户所期待的。一个适配使得因接口不兼容而不能在一起工作的类工作在一起,做法是将类别自己的接口包裹在一个...
  • 适配器模式和代理模式比较专题2

    千次阅读 2012-05-20 00:37:07
    设计模式—代理模式   代理这个词大家肯定已经非常熟悉,因为现实中接触的很多,其实现实中的东西恰恰可以非常形象直观地反映出模式的抽象过程以及本质。现在房子不是吵得热火朝天吗?我们就以房子为例,来拨开...
  • 适配器模式和代理模式表面上看来都是通过添加中间层来解除紧耦合的问题,那么这两种模式有什么区别呢,刚学不久的人真心会感到混乱。        适配器模式主要解决的是接口的兼容...
  • 适配器模式代理模式和装饰者模式是设计模式中的高频设计模式,三者非常相似,需要重点区分下。 适配器模式一般使用的情况包括:系统需要使用现有的类,但此类已经不符合系统的需要。想要建立一个可以重复使用的类...
  • 文章目录Mybatis日志模块和适配器模式代理模式一、日志模块二、适配器模式三、目录结构四、源码解析4.1 目标接口4.2 适配者4.3 适配器Slf4jImpl4.4 小结五、其他适配器六、工厂LogFactory七、JDBC日志代理增强八、...
  • 适配器模式是提供原先接口不一样的接口,做一个二次转换,原来的接口还是可以继续使用的。 代理模式 原先的接口是不能访问的(无权使用),只能通过代理来去访问原先接口。代理过程中可能会对原有接口功能做一定...
  • 代理模式适配器模式概述应用场景优缺点实现代理模式概述应用场景优缺点实现 Android开发学习笔记之设计模式——适配器模式&代理模式 结构型模式即通过将类或对象按某种布局组成更大、更复杂的结构的设计模式。...
  • 代理模式和适配器模式 适配器模式 将一个类的接口转换成客户希望的另外一个接口。Adapter模式使得原本由于接口不兼容而不能一起工作的那些类可以一起工作。 ---百度百科 简单来说就是起到应该翻译器的作用,将真实...
  • 举个例子,现在书城卖道德经的书,有线装版,有精装版,有日文版,有英文版,其中线装版精装版就是装饰模式,日文版英文版就是适配器模式,各种版本都是为迎合不同消费者的不同需求。为什么...
  • 代理模式的代理对象被代理对象都实现了同一个接口,代理对象有被代理对象的引用,但client调用代理对象的方法时,方法其实是调用了被代理对象相应的方法。 适配器模式 适配器有被适配对象的引用,client可以通过...
  • 代理模式 装饰器模式 适配器模式 区别: 适配器模式是将一个类A装换成另一个类B。类A类B的接口不同 装饰着模式是为一个类A增添新的功能,从而变成类B。类A类B的接口相同,在构造器中...
  • 装饰模式扩展既有对象的状态功能,适配器模式实现不同接口的转换,代理模式某种意义上是通过第三方来进行对象的访问控制、监管。 四人帮:装饰模式动态地给一个对象添加一些额外的职责。装饰模式使用组合代替...
  • 代理模式和适配器模式: 相同点: 都为另一个对象提供间接性访问,而且都是从自身以外的接口向这个对象转发请求 ... 相同点: 装饰模式和保护代理模式实现上是类似的,都是再转调其他对象的前后执...
  • 前面几节课我们学习了代理模式、桥接模式、装饰器模式,今天,我们再来学习一个比较常用的结构型模式:适配器模式。这个模式相对来说还是比较简单、好理解的,应用场景也很具体,总体上来讲比较好掌握。 关于适配器...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,858
精华内容 743
关键字:

适配器模式和代理模式