精华内容
下载资源
问答
  • 对接口编程:接口和抽象类

    千次阅读 热门讨论 2014-05-16 09:40:10
    在《大话设计模式》这本书中,我会听到这个字眼“对接口编程”,而在文中的类图中,会提出这样一个疑问?为什么有的用的是:接口?有的用的是抽象类呢? 本文主要介绍以下内容:接口、抽象类。 文章的最后,会给出...

        在《大话设计模式》这本书中,我会听到这个字眼“对接口编程”,而在文中的类图中,会提出这样一个疑问?为什么有的用的是:接口?有的用的是抽象类呢?

        本文主要介绍以下内容:接口、抽象类。

        文章的最后,会给出软考下午设计模式题中的一些做题技巧


    • 什么是接口?
        接口是包含一组虚方法的抽象类型,其中每一种方法都有其名称、参数和返回值。接口方法不能包含任何实现,CLR 允许接口可以包含事件、属性、索引器、静态方法、静态字段、静态构造函数以及常数。
        注意:一个类可以实现多个接口,当一个类继承某个接口时,它不仅要实现该接口定义的所有方法,还要实现该接口从其他接口中继承的所有方法。


    • 什么是抽象类?
        抽象类提供多个派生类共享基类的公共定义,它既可以提供抽象方法,也可以提供非抽象方法。抽象类不能实例化,必须通过继承由派生类实现其抽象方法,因此对抽象类不能使用new 关键字,也不能被密封。如果派生类没有实现所有的抽象方法,则该派生类也必须声明为抽象类。


    • 对比分析



    • 考试秘籍

      下面从软考设计模式的做题技巧入手,提供一些参考:(以Java语言为例)

    抽象类用关键字abstract声明,用extends继承。抽象类的目的是定义一个框架,规定某些类必须具有的一些共性。抽象方法:没有函数体的方法

      注意包含抽象方法的类,一定是抽象类。

           抽象类的直接派生类必须实现其抽象方法,抽象类只能用于继承,不能用于创建对象(所谓的new)。


    接口用关键字interface声明,关键字implements实现。接口用于替代多继承的概念。

      注意:直接继承了接口的类,必须实现接口中的抽象方法;间接的则可以实现,也可以不实现。


    区分:

      1、接口和抽象类都不能创建对象。

      2、抽象类不能参与多继承,抽象类可以有非静态的成员变量,可以有非抽象的方法;

      3、接口可以参与多继承,所有的属性都是静态常量,所有的方法都是public方法。


    • 结论
        本文基本概况了接口和抽象类的概念、异同和使用规则。但是,对于面向对象和软件设计的深入理解,还是建立在不断实践的基础上。



    展开全文
  • 面向接口编程详解

    2021-02-27 09:41:57
    本系列《面向接口编程详解》将分为三部分:面向接口编程详解(一)——思想基础在这一篇中,将对接口及面向接口编程有个大致的介绍,着重在于思想上的讲解。面向接口编程详解(二)——编程实例这一篇将结合一个实例...
  • 面向接口编程的理解

    千次阅读 2016-06-10 11:59:20
    什么是面向接口编程

    一.面向接口编程和面向对象编程是什么关系

      首先,面向接口编程和面向对象编程并不是平级的,它并不是比面向对象编程更先进的一种独立的编程思想,而是附属于面向对象思想体系,属于其一部分。或者说,它是面向对象编程体系中的思想精髓之一。

      “面向对象”与“面向接口”并非两种不同的方法学,“面向接口”其实是“面向对象”的内在要求,是其一部分内涵的集中表述。我们对于理想软件的期待常被概括为“高内聚,低耦合”,这也是整个现代软件开发方法学所追求的目标。面向对象方法学作为现代软件开发方法学的代表,本身就蕴含着“高内聚,低耦合”的思想精髓,从这个意义上来说,“面向对象”这个表述更加侧重于“高内聚”,“面向接口”的表述则更加侧重于“低耦合”——不过是同一事物的不同侧面罢了。

    二.接口的本质

      接口,在表面上是由几个没有主体代码的方法定义组成的集合体,有唯一的名称,可以被类或其他接口所实现(或者也可以说继承)。它在形式上可能是如下的样子:

    interface InterfaceName
    {
        void Method1();
        void Method2(int para1);
        void Method3(string para2,string para3);
    }

      那么,接口的本质是什么呢?或者说接口存在的意义是什么。我认为可以从以下两个视角考虑:

    1)接口是一组规则的集合,它规定了实现本接口的类或接口必须拥有的一组规则。体现了自然界“如果你是……则必须能……”的理念。
    例如,在自然界中,人都能吃饭,即“如果你是人,则必须能吃饭”。那么模拟到计算机程序中,就应该有一个IPerson(习惯上,接口名由“I”开头)接口,并有一个方法叫Eat(),然后我们规定,每一个表示“人”的类,必须实现IPerson接口,这就模拟了自然界“如果你是人,则必须能吃饭”这条规则。
    从这里,我想各位也能看到些许面向对象思想的东西。面向对象思想的核心之一,就是模拟真实世界,把真实世界中的事物抽象成类,整个程序靠各个类的实例互相通信、互相协作完成系统功能,这非常符合真实世界的运行状况,也是面向对象思想的精髓。

    2)接口是在一定粒度视图上同类事物的抽象表示。注意这里我强调了在一定粒度视图上,因为“同类事物”这个概念是相对的,它因为粒度视图不同而不同。

      例如,在我的眼里,我是一个人,和一头猪有本质区别,我可以接受我和我同学是同类这个说法,但绝不能接受我和一头猪是同类。但是,如果在一个动物学家眼里,我和猪应该是同类,因为我们都是动物,他可以认为“人”和“猪”都实现了IAnimal这个接口,而他在研究动物行为时,不会把我和猪分开对待,而会从“动物”这个较大的粒度上研究,但他会认为我和一棵树有本质区别。

      现在换了一个遗传学家,情况又不同了,因为生物都能遗传,所以在他眼里,我不仅和猪没区别,和一只蚊子、一个细菌、一颗树、一个蘑菇乃至一个SARS病毒都没什么区别,因为他会认为我们都实现了IDescendable这个接口(注:descend vi. 遗传),即我们都是可遗传的东西,他不会分别研究我们,而会将所有生物作为同类进行研究,在他眼里没有人和病毒之分,只有可遗传的物质和不可遗传的物质。但至少,我和一块石头还是有区别的。

      可不幸的事情发生了,某日,地球上出现了一位伟大的人,他叫列宁,他在熟读马克思、恩格斯的辩证唯物主义思想巨著后,颇有心得,于是他下了一个著名的定义:所谓物质,就是能被意识所反映的客观实在。至此,我和一块石头、一丝空气、一条成语和传输手机信号的电磁场已经没什么区别了,因为在列宁的眼里,我们都是可以被意识所反映的客观实在。如果列宁是一名程序员,他会这么说:所谓物质,就是所有同时实现了“IReflectabe”和“IEsse”两个接口的类所生成的实例。(注:reflect v. 反映 esse n. 客观实在)

      也许你会觉得我上面的例子像在瞎掰,但是,这正是接口得以存在的意义。面向对象思想和核心之一叫做多态性,什么叫多态性?说白了就是在某个粒度视图层面上对同类事物不加区别的对待而统一处理。而之所以敢这样做,就是因为有接口的存在。像那个遗传学家,他明白所有生物都实现了IDescendable接口,那只要是生物,一定有Descend()这个方法,于是他就可以统一研究,而不至于分别研究每一种生物而最终累死。

      可能这里还不能给你一个关于接口本质和作用的直观印象。那么在后文的例子和对几个设计模式的解析中,你将会更直观体验到接口的内涵。

    三.面向接口编程综述

      通过上文,我想大家对接口和接口的思想内涵有了一个了解,那么什么是面向接口编程呢?我个人的定义是:在系统分析和架构中,分清层次和依赖关系,每个层次不是直接向其上层提供服务(即不是直接实例化在上层中),而是通过定义一组接口,仅向上层暴露其接口功能,上层对于下层仅仅是接口依赖,而不依赖具体类。
      这样做的好处是显而易见的,首先对系统灵活性大有好处。当下层需要改变时,只要接口及接口功能不变,则上层不用做任何修改。甚至可以在不改动上层代码时将下层整个替换掉,就像我们将一个WD的60G硬盘换成一个希捷的160G的硬盘,计算机其他地方不用做任何改动,而是把原硬盘拔下来、新硬盘插上就行了,因为计算机其他部分不依赖具体硬盘,而只依赖一个IDE接口,只要硬盘实现了这个接口,就可以替换上去。从这里看,程序中的接口和现实中的接口极为相似,所以我一直认为,接口(interface)这个词用的真是神似!

      使用接口的另一个好处就是不同部件或层次的开发人员可以并行开工,就像造硬盘的不用等造CPU的,也不用等造显示器的,只要接口一致,设计合理,完全可以并行进行开发,从而提高效率。
      本篇文章先到这里。最后我想再啰嗦一句:面向对象的精髓是模拟现实,这也可以说是我这篇文章的灵魂。所以,多从现实中思考面向对象的东西,对提高系统分析设计能力大有脾益。

    对本文的补充:

      仔细看了各位的回复,非常高兴能和大家一起讨论技术问题。感谢给出肯定的朋友,也要感谢提出意见和质疑的朋友,这促使我更深入思考一些东西,希望能借此进步。在这里我想补充一些东西,以讨论一些回复中比较集中的问题。

    1.关于“面向接口编程”中的“接口”与具体面向对象语言中“接口”两个词

      看到有朋友提出“面向接口编程”中的“接口”二字应该比单纯编程语言中的interface范围更大。我经过思考,觉得很有道理。这里我写的确实不太合理。我想,面向对象语言中的“接口”是指具体的一种代码结构,例如C#中用interface关键字定义的接口。而“面向接口编程”中的“接口”可以说是一种从软件架构的角度、从一个更抽象的层面上指那种用于隐藏具体底层类和实现多态性的结构部件。从这个意义上说,如果定义一个抽象类,并且目的是为了实现多态,那么我认为把这个抽象类也称为“接口”是合理的。但是用抽象类实现多态合理不合理?在下面第二条讨论。
    概括来说,我觉得两个“接口”的概念既相互区别又相互联系。“面向接口编程”中的接口是一种思想层面的用于实现多态性、提高软件灵活性和可维护性的架构部件,而具体语言中的“接口”是将这种思想中的部件具体实施到代码里的手段。

    2.关于抽象类与接口

      看到回复中这是讨论的比较激烈的一个问题。很抱歉我考虑不周没有在文章中讨论这个问题。我个人对这个问题的理解如下:
      如果单从具体代码来看,对这两个概念很容易模糊,甚至觉得接口就是多余的,因为单从具体功能来看,除多重继承外(C#,Java中),抽象类似乎完全能取代接口。但是,难道接口的存在是为了实现多重继承?当然不是。我认为,抽象类和接口的区别在于使用动机。使用抽象类是为了代码的复用,而使用接口的动机是为了实现多态性。所以,如果你在为某个地方该使用接口还是抽象类而犹豫不决时,那么可以想想你的动机是什么。
      看到有朋友对IPerson这个接口的质疑,我个人的理解是,IPerson这个接口该不该定义,关键看具体应用中是怎么个情况。如果我们的项目中有Women和Man,都继承Person,而且Women和Man绝大多数方法都相同,只有一个方法DoSomethingInWC()不同(例子比较粗俗,各位见谅),那么当然定义一个AbstractPerson抽象类比较合理,因为它可以把其他所有方法都包含进去,子类只定义DoSomethingInWC(),大大减少了重复代码量。
      但是,如果我们程序中的Women和Man两个类基本没有共同代码,而且有一个PersonHandle类需要实例化他们,并且不希望知道他们是男是女,而只需把他们当作人看待,并实现多态,那么定义成接口就有必要了。
      总而言之,接口与抽象类的区别主要在于使用的动机,而不在于其本身。而一个东西该定义成抽象类还是接口,要根据具体环境的上下文决定。
      再者,我认为接口和抽象类的另一个区别在于,抽象类和它的子类之间应该是一般和特殊的关系,而接口仅仅是它的子类应该实现的一组规则。(当然,有时也可能存在一般与特殊的关系,但我们使用接口的目的不在这里)如,交通工具定义成抽象类,汽车、飞机、轮船定义成子类,是可以接受的,因为汽车、飞机、轮船都是一种特殊的交通工具。再譬如Icomparable接口,它只是说,实现这个接口的类必须要可以进行比较,这是一条规则。如果Car这个类实现了Icomparable,只是说,我们的Car中有一个方法可以对两个Car的实例进行比较,可能是比哪辆车更贵,也可能比哪辆车更大,这都无所谓,但我们不能说“汽车是一种特殊的可以比较”,这在文法上都不通。

    展开全文
  • java面向接口编程

    2014-01-08 18:28:20
    面向接口编程的例子,生活中的实例来说明接口的概念,理解java接口有很大帮助!
  • Android 面向接口编程

    千次阅读 2017-07-04 19:41:26
    关键词:Android、POP、面向接口编程 、面向过程、面向协议一、概述面向接口编程是面向对象编程的一种实现方式,它的核心思想是将抽象与实现分离,从组件的级别来设计代码,达到高内聚低耦合的目的。最简单的面向...

    关键词:Android、POP、面向接口编程 、面向过程、面向协议

    一、概述

    面向接口编程是面向对象编程的一种实现方式,它的核心思想是将抽象与实现分离,从组件的级别来设计代码,达到高内聚低耦合的目的。最简单的面向接口编程方法是,先定义底层接口模块,再定义高层实现模块。但是这样存在一个问题,就是当修改底层接口的时候,高层实现也需要跟着修改,这也违反了开闭原则。 在面相对象设计基本原则(SOLID)中,依赖倒置原则说得就是这个问题。
    同时配合使用依赖注入思想,可以很好地处理这个问题。(PS:注意面向接口编程的接口并不是狭义上指Java中的接口,而是指超类型,可以是接口也可以是抽象类)

    二、依赖倒置&依赖注入

    依赖倒置原则是高层模块不应该依赖低层模块,两者都应该依赖其抽象;抽象不应该依赖细节,细节应该依赖抽象。这里的抽象就是接口或者抽象类,我们应该依赖接口或者抽象类 ,而不是依赖具体的实现来编程。它应该遵循如下特性:

    • 模块间的依赖通过抽象发生
    • 实现类之间不发生直接的依赖关系
    • 其依赖关系是通过接口或抽象类产生

    依赖注入是非主动初始化依赖对象,而通过外部来传入依赖的方式,称为依赖注入。它有几个好处:

    • 解耦,将依赖之间解耦
    • 方便做单元测试,尤其是Mock测试

    依赖倒置通常会通过引入中间层来处理模块间交互,这个中间层相当于一个抽象接口层,高层模块和底层模块都依赖于这个中间层来交互,底层模块改变不会影响到高层模块,这就满足了开放关闭原则。而且假如高层模块跟底层模块同时处于开发阶段,这样有了中间抽象层之后,每个模块都可以针对这个抽象层的接口同时开发,高层模块就不需要等到底层模块开发完毕才能继续。举一个例子,

    // 抽象:接口
    public interface ImageCache {
            ...   
    }
    
    // 错误例子:依赖于细节
    public class ImageLoader {
    
            // (直接依赖于细节)
            DoubleCache mCache = new DoubleCache();
    
            public void displayImage(String url, ImageView imageView) {
                    ...
            }
    
            // (直接依赖于细节)
            public void setImageCache(DoubleCache cache) {
                    mCache = cache;
            }
    
    }
    
    // 正确例子:依赖于抽象
    public class ImageLoader {
    
            // 依赖于抽象(接口或者抽象类)
            ImageCache mCache;
    
            // 设置ImageCache依赖于抽象
            public void setImageCache(ImageCache cache) {
                    mCache = cache;
            }
    
            public void displayImage(String url, ImageView imageView) {
                    ...
            }
    
    }
    
    public class Activity{
    
         ImageLoader mImageLoader;
    
         mImageLoader.setImageCache(new MemoryCache());// 依赖注入
         mImageLoader.displayImage(...);
    }

    上面定义的ImageCache就是抽象(接口),它相当于中间层。同时,在传入ImageCache的时候,是通过传入依赖的方式而不是在方法内部生成,这就是依赖注入的思想。

    再举一个例子,比如在项目中有涉及IM的功能,现在这个IM模块采用的是XMPP协议来实现,客户端通过这个模块来实现消息的收发,但是假如后面要换成其它协议,比如MQTT等,依赖倒置思想就可以很轻松的实现模块替换:

    458529-cbf419fb6dbdaed8.png

    public interface MessageDelegate{
         void goOnline();
         void sendMessage(String msg);
    }
    
    //xmpp实现
    public interface XMPPMessageCenter extends MessageDelegate{
         void goOnline();
         void sendMessage(String msg);
    }
    
    //MQTT实现
    public interface MQTTMessageCenter extends MessageDelegate{
         void goOnline();
         void sendMessage(String msg);
    }
    
    //业务层
    //使用遵循MessageDelegate协议的对象,针对接口编程,以后替换也很方便
    public interface BussinessLayer{
         MessageDelegate messageCenter;
         //业务
         messageCenter.goOnline();
         ...
    }

    三、策略模式

    那么,就很容易联想到面向接口编程的一个典型设计模式,策略模式。 策略模式定义了一系列的算法,并将每一个算法封装起来,而且使它们还可以相互替换。策略模式让算法独立于使用它的客户而独立变化。一般的使用场景如下:

    • 针对同一类型问题的多种处理方式,仅仅是具体行为有差别时。
    • 需要安全的封装多种同一类型的操作时。
    • 出现同一抽象多个子类,而又需要使用if-else 或者 switch-case来选择时

    strategy-kerison-uml.png

    Context用来操作策略的上下文环境,Strategy是策略的抽象,ConcreteStrategyA、ConcreteStrategyB等是具体的策略实现。

    四、核心要点

    1.封装变化

    找出程序中可能需要变化之处,把它们独立出来,不要和那些不需要变化的代码混在一起。

    如何区分变化的和不会变化的就尤为重要,可以简单定义为一切有弹性的无法确定的就作为变化的。举个例子,图像加载的方法就可以作为确定的不会变化的,而图像缓存策略有文件缓存、内存缓存等等,那么就可以作为变化的。所以,缓存相关部分的代码就需要独立出来,不跟其他代码混在一起。

    2.将行为转为属性

    区分好变化与不变化部分之后,将变化的部分抽象为接口或者抽象类 ,然后在调用处转为属性。

    在调用处,将接口或者抽象类转为属性,也就是声明为成员变量,这样在方法中具体调用的时候,就会根据行为实现的不同而产生不同的结果。

    五、实际应用

    在安卓开发中,有各种基础功能的类库,比如网络请求、图像加载、日志输出、数据存储等等。一般情况下,开源社区也有比较成熟的实现方案,项目有时候也会使用不同的方案。那么,如何定义一个架构,既可以自己去实现开发方案,同时也可以使用其他方案呢?答案就是利用策略模式,同时配合使用建造者模式、单例模式等,根据面向接口编程的思想去完成。下面以图像加载功能为例,去实现一个图像加载类库。

    目前比较流行的图像加载类库有Glide、Fresco、Picasso、UML等,从对这些类库的使用来看,对外提供的功能接口很多都比较类似,例如图像加载、缓存清理、额外配置等等。因此就可以从这些类库中提出公关接口部分出来,形成一个基础图像加载架构,然后再继续进行适配。先各自看一下加载图像的API方法:

    1、Glide

    Glide.with(getContext()).load(url).skipMemoryCache(true).placeholder(drawable).centerCrop().animate(animator).into(img);

    2、Fresco

    Uri uri = "file:///mnt/sdcard/MyApp/myfile.jpg";
    int width = 50, height = 50;
    ImageRequest request = ImageRequestBuilder.newBuilderWithSource(uri)
        .setResizeOptions(new ResizeOptions(width, height))
        .build();
    PipelineDraweeController controller = Fresco.newDraweeControllerBuilder()
        .setOldController(mDraweeView.getController())
        .setImageRequest(request)
        .build();
    mSimpleDraweeView.setController(controller);

    3、Picasso

     Picasso.with(context).load(url).resize(50, 50).centerCrop().into(imageView);

    4、Universal Image Loader

    ImageLoader.getInstance().displayImage(imageUri, imageView, options, new ImageLoadingListener() {
        @Override
        public void onLoadingStarted(String imageUri, View view) {
            ...
        }
        @Override
        public void onLoadingFailed(String imageUri, View view, FailReason failReason) {
            ...
        }
        @Override
        public void onLoadingComplete(String imageUri, View view, Bitmap loadedImage) {
            ...
        }
        @Override
        public void onLoadingCancelled(String imageUri, View view) {
            ...
        }
    }, new ImageLoadingProgressListener() {
        @Override
        public void onProgressUpdate(String imageUri, View view, int current, int total) {
            ...
        }
    });

    从上面可以发现,Glide和Picasso的使用方式几乎是一致的,通过链式调用,进行各自图像加载的配置,如缓存策略,动画,占位符等等。Universal Image Loader方法比较常规,通过单例模式进行图像加载方法的调用,方法参数包含有加载配置、回调接口等。而Fresco有一套自己的逻辑,把图像加载的逻辑封装到了UI中。对于图片加载而言,有最基本最重要的必选项,以及可有可无的可选项,从上面方法中提取必选项以及可选项:

    • 必选项:上下文环境(Context),URI(图片来源),ImageView(图片容器)
    • 可选项:Options (是否缓存、图像大小、圆角、动画、回调、缺省图等等)

    那么可以这样设计接口,

    public interface ImageLoaderStrategy{
    
         void showImage(ImageView imageview, String url, ImageLoaderOptions options);
         void showImage(ImageView imageview, int drawable, ImageLoaderOptions options);
    
    }

    当然对于必选项与可选项其实并没有严格的规范,例如Fresco的特殊设计,自己实现了图片容器而不是ImageView,这时候要么再添加一个方法:

    void showImage(View view, int drawable, ImageLoaderOptions options);

    要么就可以进一步拆分,把View和URI也加入到可选项中,然后使用泛型来动态设置可选项,如下:

    public interface ImageLoaderStrategy<T extends ImageLoaderOptions> {
        void loadImage(Context ctx, T options);
    }

    ImageLoaderOptions就是可选项,这些可选项可以从开源类库中提出公共的部分,由于这些属性都是可选择的,因此最好使用Builder模式来构建。

    public class ImageLoaderOptions{
    
        protected String url;
        protected ImageView imageView;
        protected int placeholder;
        protected int errorPic;
    
        public String getUrl() {
            return url;
        }
    
        public ImageView getImageView() {
            return imageView;
        }
    
        public int getPlaceholder() {
            return placeholder;
        }
    
        public int getErrorPic() {
            return errorPic;
        }
    
    }

    然后根据策略模式,设计出图像加载的基本框架:

    cda13f2eab9c573672e1.png

    最后再去实现其他部分,整体方案的设计并不难,涉及到具体实现就需要细心去写代码了。所以在进行面向接口编程时候,前期最关键的还是架构的设计,如何能够保证易拓展、易维护、易、易兼容等。架构设计好之后就是细节的实现,可以直接使用开源方案来组装,或者创造轮子再去实现一套新的方案。

    展开全文
  • 面向接口编程

    千次阅读 热门讨论 2014-08-25 20:01:14
    对于我们来说或许听到更多的是面向对象编程,这里说到了面向接口编程并不是和面向对象编程并驾齐驱一种编程思想体系,更确切的说,面向接口编程知识面向对象体系的一部分思想精髓.  接口,在表面上是由几个没有主体...

            对于我们来说或许听到更多的是面向对象编程,这里说到了面向接口编程并不是和面向对象编程并驾齐驱一种编程思想体系,更确切的说,面向接口编程知识面向对象体系的一部分思想精髓.

            接口,在表面上是由几个没有主体代码的方法定义组成的集合体,有唯一的名称,可以被类或其他接口所实现。它在形式上可能是如下的样子:

    interface InterfaceName

    {

        int Method1();

        string Method2(int para1);

        voidMethod3(string para2,string para3);

    }

    那么,接口的本质是什么呢?或者说接口存在的意义是什么。

         首先接口是一组规则的集合,它规定了实现本接口的类或接口必须拥有的一组规则。体现了“如果你是……则必须能……”

    例如,人都能呼吸,即“如果你是人,则必须能呼吸”。那么模拟到计算机程序中,就应该有一个IPerson接口,并有一个方法叫Breath(),然后我们规定,每一个表示“人”的类,必须实现IPerson接口,这就“如果你是人,则必须能呼吸”这条规则。

        其次接口是在一定粒度视图上同类事物的抽象表示。

         例如:在我们眼中我和身边的同事是同类,我们有能有共同的接口,但是在动物学家眼中,我们和狗是同类,都是动物,拥有共同的接口规则,而在生物学家眼中我们又和花花草草的同类,我们又共同的接口规则.说白了这些就是在某个粒度视图层面上对同类事物不加区别的对待而统一处理。而之所以敢这样做,就是因为有接口的存在

         最后那到底什么是接口编程呢?我觉得:在系统分析和架构中,分清层次和依赖关系,每个层次不是直接向其上层提供服务(即不是直接实例化在上层中),而是通过定义一组接口,仅向上层暴露其接口功能,上层对于下层仅仅是接口依赖,而不依赖具体类。

          这样做的好处是显而易见的,首先对系统灵活性大有好处。当下层需要改变时,只要接口及接口功能不变,则上层不用做任何修改。甚至可以在不改动上层代码时将下层整个替换掉,就像我们将一个2G内存条换成一个4G,计算机其他地方不用做任何改动,而是把原来内存条拔下来、新内存条插上就行了,因为计算机其他部分不依赖具体内存,而只依赖一个IDE接口,只要内存条实现了这个接口,就可以替换上去。从这里看,程序中的接口和现实中的接口极为相似,所以我一直认为,接口(interface)这个词用的真是神似!

          使用接口的另一个好处就是不同部件或层次的开发人员可以并行开工,就像造内存的不用等造CPU的,也不用等造显示器的,只要接口一致,设计合理,完全可以并行进行开发,从而提高效率。

    展开全文
  • IO接口编程

    千次阅读 2018-11-09 15:13:05
    IO接口编程 作者:毛茏玮 / Saint 掘金:https://juejin.im/user/5aa1f89b6fb9a028bb18966a 微博:https://weibo.com/5458277467/profile?topnav=1&amp;wvr=6&amp;is_all=1 GitHub:github.com/saint-000 ...
  • 面向接口编程的优点

    万次阅读 多人点赞 2017-04-13 19:04:43
    1 首先什么是面向接口编程? 面向接口编程就是先把客户的业务逻辑线提取出来,作为接口,业务具体实现通过该接口的实现类来完成。当客户需求变化时,只需编写该业务逻辑的新的实现类,通过更改配置文件(例如Spring...
  • 为什么我们要面向接口编程?!

    万次阅读 多人点赞 2020-03-06 09:54:17
    面向过程编程(Procedure Oriented、简称PO) 和 面向对象编程(Object Oriented、简称OO) 我们一定听过,然而实际企业级开发里受用更多的一种编程思想那就是:面向接口编程(Interface-Oriented)! 接口这个概念...
  • 关于面向接口编程

    千次阅读 2016-08-29 11:27:10
    面向接口编程(很重要的一种编程思想): 优点:松耦合,可以达到类似于插座的效果(热插拨)。 在spring的jdbc编程中,在引入数据库连接池的部分就做到了面向接口编程,以后无论换什么数据库连接池都不用修改代码 ...
  • “针对接口编程,而不是针对实现编程”的理解今天在阅读《Head First设计模式》的时候,看到了这句话:“针对接口编程,而不是针对实现编程”,第一次见到的时候,不太清楚作者想表达的意思,想着到后来看看实例就...
  • 为什么提倡面向接口编程

    千次阅读 多人点赞 2019-01-02 23:28:48
    为什么先行者们要提倡面向接口编程?要回答这个问题,我们先以一个反问作为开场: 1. 如果不是接口,那是谁? 在百度搜了一堆“为什么要面向接口编程”,最有道理的答案似乎是“方便维护和扩展”,因为“规范和...
  • 针对接口编程

    千次阅读 2007-11-05 22:15:00
    我认为“针对接口编程”应该这样理解:先分析问题,找出问题的共性,其共性提取基类,针对基类设计接口。如果一个接口仅有一个实现,那就应该考虑设计此接口的必要性,如果仅仅是为了所谓的“预先设计”而做出这样...
  • 面向接口编程的一些总结

    千次阅读 2018-07-24 21:08:11
    1.面向接口编程产生的背景  在一个面向对象的系统中,系统的各种功能是由许许多多的不同对象协作完成,在这种情况下各个对象内部是如何实现自己系统设计人员来说就不那么重要了.而各个对象之间的协作关系则成为...
  • 面向接口编程思想(的好处)

    千次阅读 2018-10-19 10:51:39
    1.什么是面向接口编程? 面向接口编程是开发程序的功能先定义接口,接口中定义约定好的功能方法声明,通过实现该接口进行功能的实现,完成软件或项目的要求.软件或项目随着时间的不断变化,软件的功能要进行升级或完善...
  • 在Java和C#的编程世界里,并没有出现像C++那样的多脉继承,它们只支持单一的继承,或者多级继承,这一变化最大的影响,我觉得是大大的降低了编程的...今天就来谈谈我Java中面向接口编程的看法,以及个人的一些改进。
  • Java为什么要面向接口编程

    千次阅读 2019-03-14 11:34:43
    就我目前的水平来看,Java使用面向接口编程主要有3点好处。 代码的灵活性和高可复用性 良好的可扩展性 低耦合 ...   我们学习知识,要做到知其...我们先看看不使用接口编程程序的影响是什么。 package i...
  • c#面向接口编程

    千次阅读 2013-09-13 18:20:06
    首先,面向接口编程和面向对象编程并不是平级的,它并不是比面向对象编程更先进的一种独立的编程思想,而是附属于面向对象思想体系,属于其一部分。或者说,它是面向对象编程体系中的思想精髓之一。 2.接口的本质...
  • 面向接口编程详解(一)

    千次阅读 2014-10-22 16:14:58
    而且,作为程序员,一定经常听到“面向接口编程”这个短语,那么它是什么意思?有什么思想内涵?和面向对象编程是什么关系?本文将一一解答这些疑问。 1.面向接口编程和面向对象编程是什么关系 首先,面向接口...
  • 面向接口编程和面向对象编程的区别

    万次阅读 多人点赞 2017-11-02 11:21:40
    而且,作为程序员,一定经常听到“面向接口编程”这个短语,那么它是什么意思?有什么思想内涵?和面向对象编程是什么关系?本文将一一解答这些疑问。 1.面向接口编程和面向对象编程是什么关系 首先,面向接口...
  • 接口编程的好处

    万次阅读 2011-01-21 08:22:00
    接口编程的好处在项目中的意义:  在传统的项目开发过程中,由于客户的需求经常变化,如果不采用面向接口编程,那么我们必须不停改写现有的业务代码。改写代码可能产生新的BUG,而且改写代码还会影响到调用该...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 923,670
精华内容 369,468
关键字:

对接口编程