接口 订阅
接口泛指实体把自己提供给外界的一种抽象化物(可以为另一实体),用以由内部操作分离出外部沟通方法,使其能被内部修改而不影响外界其他实体与其交互的方式。人类与电脑等信息机器或人类与程序之间的接口称为用户界面。电脑等信息机器硬件组件间的接口叫硬件接口。电脑等信息机器软件组件间的接口叫软件接口。在计算机中,接口是计算机系统中两个独立的部件进行信息交换的共享边界。这种交换可以发生在计算机软、硬件,外部设备或进行操作的人之间,也可以是它们的结合。 展开全文
接口泛指实体把自己提供给外界的一种抽象化物(可以为另一实体),用以由内部操作分离出外部沟通方法,使其能被内部修改而不影响外界其他实体与其交互的方式。人类与电脑等信息机器或人类与程序之间的接口称为用户界面。电脑等信息机器硬件组件间的接口叫硬件接口。电脑等信息机器软件组件间的接口叫软件接口。在计算机中,接口是计算机系统中两个独立的部件进行信息交换的共享边界。这种交换可以发生在计算机软、硬件,外部设备或进行操作的人之间,也可以是它们的结合。
信息
拼    音
jiē kǒu
IT释义
两个不同系统(或子程序)交接并通过它彼此作用的部分
分    类
硬件接口,软件接口
中文名
接口
功    能
沟通媒介
外文名
interface
接口词目
接口
收起全文
精华内容
参与话题
问答
  • JAVA基础——接口(全网最详细教程)

    万次阅读 多人点赞 2018-05-10 09:46:42
    Java基础——接口 接口概念 官方解释:Java接口是一系列方法的声明,是一些方法特征的集合,一个接口只有方法的特征没有方法的实现,因此这些方法可以在不同的地方被不同的类实现,而这些实现可以具有不同的...

                                       Java基础——接口


     

     

    接口概念


        官方解释:Java接口是一系列方法的声明,是一些方法特征的集合,一个接口只有方法的特征没有方法的实现,因此这些方法可以在不同的地方被不同的类实现,而这些实现可以具有不同的行为(功能)

        我的解释:接口可以理解为一种特殊的类,里面全部是由全局常量公共的抽象方法所组成。接口是解决Java无法使用多继承的一种手段,但是接口在实际中更多的作用是制定标准的。或者我们可以直接把接口理解为100%的抽象类,既接口中的方法必须全部是抽象方法。(JDK1.8之前可以这样理解)

     

    接口的特点


        就像一个类一样,一个接口也能够拥有方法和属性,但是在接口中声明的方法默认是抽象的。(即只有方法标识符,而没有方法体)。

     

    • 接口指明了一个类必须要做什么和不能做什么,相当于类的蓝图。
    • 一个接口就是描述一种能力,比如“运动员”也可以作为一个接口,并且任何实现“运动员”接口的类都必须有能力实现奔跑这个动作(或者implement move()方法),所以接口的作用就是告诉类,你要实现我这种接口代表的功能,你就必须实现某些方法,我才能承认你确实拥有该接口代表的某种能力。
    • 如果一个类实现了一个接口中要求的所有的方法,然而没有提供方法体而仅仅只有方法标识,那么这个类一定是一个抽象类。(必须记住:抽象方法只能存在于抽象类或者接口中,但抽象类中却能存在非抽象方法,即有方法体的方法。接口是百分之百的抽象类
    • 一个JAVA库中接口的例子是:Comparator 接口,这个接口代表了“能够进行比较”这种能力,任何类只要实现了这个Comparator接口的话,这个类也具备了“比较”这种能力,那么就可以用来进行排序操作了。

    为什么要用接口


    1.     接口被用来描述一种抽象。
    2. 因为Java不像C++一样支持多继承,所以Java可以通过实现接口来弥补这个局限
    3. 接口也被用来实现解耦。
    4. 接口被用来实现抽象,而抽象类也被用来实现抽象,为什么一定要用接口呢?接口和抽象类之间又有什么区别呢?原因是抽象类内部可能包含非final的变量,但是在接口中存在的变量一定是final,public,static的。

     

     

     

    接口的语法实现


        为了声明一个接口,我们使用interface这个关键字,在接口中的所有方法都必须只声明方法标识,而不要去声明具体的方法体,因为具体的方法体的实现是由继承该接口的类来去实现的,因此,接口并不用管具体的实现。接口中的属性默认为Public Static Final.一个类实现这个接口必须实现这个接口中定义的所有的抽象方法。

        一个简单的接口就像这样:拥有全局变量和抽象方法。

        为了实现这个接口,我们使用implements关键词去实现接口:

    其中testClass类实现了我们上面刚才定义的 in1 这个接口,既然你要实现接口,也就是实现接口代表的一种能力,那么你就必须去实现接口给你规定的方法,只有把接口给你规定的抽象方法都给实现了,才承认你这个类实现了这个接口,实现了这个接口代表的某种功能。上图实现了接口中规定的display()方法。

        写一个测试类,用来测试一下我们刚才实现的这个接口,因为testclass类的对象t实现了接口规定的display方法,那么自然而然就可以调用display()方法咯。

        有兴趣的同学可以去这个在线IDE亲自试一试:点击打开链接

     

     

    接口的进一步理解


     

        我们知道,如果某个设备需要向电脑中读取或者写入某些东西,这些设备一般都是采用USB方式与电脑连接的,我们发现,只要带有USB功能的设备就可以插入电脑中使用了,那么我们可以认为USB就是一种功能,这种功能能够做出很多的事情(实现很多的方法),其实USB就可以看做是一种标准,一种接口,只要实现了USB标准的设备我就认为你已经拥有了USB这种功能。(因为你实现了我USB标准中规定的方法),下面是具体的例子:

     

    先声明USB接口:其中规定了要实现USB接口就必须实现接口规定实现的read( )和write( )这两个方法。

    interface USB {
       
    void read();

       
    void write();
    }

    然后在写一个U盘类和一个键盘类,这两个类都去实现USB接口。(实现其中的方法)

    class YouPan implements USB {

        @Override

        public void read() {

            System.out.println("U盘正在通过USB功能读取数据");

        }

        @Override

        public void write() {

            System.out.println("U盘正在通过USB功能写入数据");

        }

    }

     

     

    这是U盘的具体实现。

    class JianPan implements USB {

        @Override

        public void read() {

            System.out.println("键盘正在通过USB功能读取数据");

        }

        @Override

        public void write() {

            System.out.println("键盘正在通过USB功能写入数据");

        }

    }

     

     

    这是键盘的具体实现。

        那么,现在U盘和键盘都实现了USB功能,也就是说U盘和键盘都能够调用USB接口中规定的方法,并且他们实现的方式都不一样。

    我们在写一个测试,来看看具体的实现:

    public class Main {

        public static void main(String[] args) {

            //生成一个实现可USB接口(标准)的U盘对象

            YouPan youPan = new YouPan();

            //调用U盘的read( )方法读取数据

            youPan.read();

            //调用U盘的write( )方法写入数据

            youPan.write();

            //生成一个实现可USB接口(标准)的键盘对象

            JianPan jianPan = new JianPan();

            //调用键盘的read( )方法读取数据

            jianPan.read();

            //调用键盘的write( )方法写入数据

            jianPan.write();

        }

    }

     

     

     

    结果如下:

     

     

        感兴趣的同学可以去在线IDE平台自己验证一下:点击打开链接

     

     

    关于接口的几个重点


    1. 我们不能直接去实例化一个接口,因为接口中的方法都是抽象的,是没有方法体的,这样怎么可能产生具体的实例呢?但是,我们可以使用接口类型的引用指向一个实现了该接口的对象,并且可以调用这个接口中的方法。因此,上图中最后的方法调用我们还可以这样写:(实际上就是使用了Java中多态的特性)

    public class Main {

        public static void main(String[] args) {

            //生成一个实现可USB接口(标准)的U盘对象

            //但是使用一个接口引用指向对象

            //USB接口类引用可以指向一个实现了USB接口的对象

            USB youPan = new YouPan();

            //调用U盘的read( )方法读取数据

            youPan.read();

            //调用U盘的write( )方法写入数据

            youPan.write();

            //生成一个实现可USB接口(标准)的键盘对象

            //但是使用一个接口引用指向对象

            //USB接口类引用可以指向一个实现了USB接口的对象

            USB jianPan = new JianPan();

            //调用键盘的read( )方法读取数据

            jianPan.read();

            //调用键盘的write( )方法写入数据

            jianPan.write();

        }

    }                                                                                                                                     

     

     2.一个类可以实现不止一个接口。

     

    3.一个接口可以继承于另一个接口,或者另一些接口,接口也可以继承,并且可以多继承

    4.一个类如果要实现某个接口的话,那么它必须要实现这个接口中的所有方法。

    5.接口中所有的方法都是抽象的和public的,所有的属性都是public,static,final的。

    6.接口用来弥补类无法实现多继承的局限。

    7.接口也可以用来实现解耦。

    接口的通俗理解


     

        前面我们讲多态的时候用“空调”——“遥控器”的方式去理解多态,实际上在上面的的几个重点中的第一条讲的也是多态的实现,比如,我们可以把“节能”作为一种标准,或者说节能就是一个“接口”,这个接口中有一个方法,叫做变频方法,任何空调,如果要称得上叫做节能空调的话,那么必须实现“节能”这个接口,实现“节能”这个接口,也就必须实现“节能”接口中规定实现的“变频”方法,这样才算是真正的实现了“节能”这个接口,实现了“节能”这个功能。

        当某个空调实现了“节能”接口后,这个空调就具备了节能的功能,那么我们也可以不用空调类的引用指向空调对象,我们可以直接使用一个“节能”接口类型引用的“遥控器”去指向“空调”,虽然这个“遥控器”上面只有一个按键,只有一个“变频”的方法,但是“遥控器”所指向的空调是实现了“节能”这个接口的,是有“变频”方法的实现的,我们用这个只有一个“变频”方法的遥控器去命令空调调用“变频”方法,也是行得通的,实在不清楚的同学可以去看我的另一篇文章:JAVA之对象的多态性

     

     

    接口的标识用法


        虽然接口内部定义了一些抽象方法,但是并不是所有的接口内部都必须要有方法,比如Seriallizable接口,Seriallizable接口的作用是使对象能够“序列化”,但是Seriallizable接口中却没有任何内容,也就是说,如果有一个类需要实现“序列化”的功能,则这个类必须去实现Seriallizable接口,但是却并不用实现方法(因为接口中没有方法),此时,这个Serilizable接口就仅仅是一个“标识”接口,是用来标志一个类的,标志这个类具有这个“序列化”功能。具体的实现请参考我的另一篇文章——JAVA之IO流。

     

    接口在生活中的思想体现


    其实,在我们的生活当中,有很多地方都体现了“接口”的思想,想必,正在阅读这篇博文的你,是不是也喜欢摄影呢?

    佳能(Canon)EOS 80D 单反相机 单反套机(EF-S 18-200mm f/3.5-5.6 IS 单反镜头)

    玩摄影的童鞋都知道,单反由相机镜头组成,相机分不同的型号,有半画幅的,也有全画幅的。镜头也是一样的,分长焦,短焦;还有定焦和变焦。每种镜头都有各自特定的发挥场景正是因为镜头的多元化,使得我们的摄影能够“术业有专攻”。大家想一想,如果我们的单反相机部分和镜头部分是固定在一起的,不能够更换镜头,那么将会多么的糟糕啊!

    因此,每个相机品牌为了能够兼容不同的镜头,各自发布了一套镜头卡口的标准,这套标准就好比我们前面提到的“接口”,都是某种“约束”。举个栗子,我们佳能的相机,不管你是哪一家镜头生产厂商,腾龙也好,适马也好,只要你按照我佳能卡口的标准来生产镜头,你生产的镜头都能够很好的在我佳能相机上面驱动。

    因此,当我们打开“狗东”,准备给自己的新相机买镜头的时候,就不难发现,我们需要根据自己相机的品牌来挑选特定卡口的镜头,这样的镜头才能被我们的相机正常驱动。

    回到Java上面来说,其实接口给我们带来的最大的好处就是“解耦”了,相机能够搭配不同的镜头,才能有各种各样的搭配玩法,变得更加的灵活。在软件系统中也是一样的,接口可以有很多不同“特色”的实现类,我们只需要声明同一个接口,却可以引用很多个该“接口”引申出来的“子类”,这不也大大增强了我们软件系统中组件的灵活性吗?

    聪明的你,对于“接口”的理解是不是又更加的深入了呢?

     

    参考资料


    1.Java开发实战经典》 李兴华著  清华大学出版社

    2.https://www.geeksforgeeks.org/interfaces-in-java  作者:Mehak Kumar. and Nitsdheerendra.   翻译:刘扬俊

     

    博客文章版权说明


    第一条 本博客文章仅代表作者本人的观点,不保证文章等内容的有效性。

    第二条 本博客部分内容转载于合作站点或摘录于部分书籍,但都会注明作/译者和原出处。如有不妥之处,敬请指出。

    第三条 征得本博客作者同意的情况下,本博客的作品允许非盈利性引用,并请注明出处:“作者:____转载自____”字样,以尊重作者的劳动成果。版权归原作/译者所有。未经允许,严禁转载

    第四条 对非法转载者,“扬俊的小屋”和作/译者保留采用法律手段追究的权利

    第五条 本博客之声明以及其修改权、更新权及最终解释权均属“扬俊的小屋”。

    第六条 以上声明的解释权归扬俊的小屋所有。

     

    展开全文
  • 接口与实现

    千次阅读 多人点赞 2018-10-29 00:18:23
    一、接口是什么?  接口是抽象的抽象(抽象类是具体的抽象)。  例如制作一款运动手表,接口就是产品需要实现的功能。我这款手表要实现与APP的结合,要实现来电的提醒,要实现闹铃的设置,要实现心率的实时监控...

    一、接口是什么?

            接口是抽象的抽象(抽象类是具体的抽象)。

            例如制作一款运动手表,接口就是产品需要实现的功能。我这款手表要实现与APP的结合,要实现来电的提醒,要实现闹铃的设置,要实现心率的实时监控,要实现步数的记录......  我不会告诉你任何具体的实现方法,我只会给你一个产品功能的框架,而如果你是我团队的一员,要来制作这款运动手表,那么你就一定要把我定义的内容全部实现。

           即“如果你是......, ,就必须......”

            这就是接口,在程序中,它就相当于是一个类的行为规范。 

    二、接口的作用?     接口的作用(引索   

         1. 有利于代码的规范

          2. 有利于代码进行维护

          3.  有利于代码的安全和严密

          4. 丰富了继承的方式

    三 、接口的相关语法

          接口声明

                    关键字:interface       public interface  接口名 {}

          接口体

                    1. 常量(没有变量)  ( public static final ) int MAX = 100;     可以省略public static final

                    2. 抽象方法                 (public abstract) void add();                 可以省略public abstract

                    常量和抽象方法都只有一种访问修饰符:public

                    接口默认提供  public,static,final,abstract 关键字

          接口的实现

               关键字:implements

                1. 类可以实现一个或多个接口     public class Dog implements Eatable,Sleepable

                    Dog 也可以继承一个具体类    public   class  Dog   extends   Animal  implements   Eatable , Sleepable

                 2. 类中必须重写接口中的全部方法( 抽象类   可只重写接口中的部分方法)

                 3. 类中重写的方法,访问修饰符必须是  public

                 4. 接口中定义的常量,在继承了接口的类中可以直接使用。             

          接口间的继承 

                 public interface A{}

                 public interface B extends A{}      // 接口B继承的A

    public interface Eatable{     //定义了一个Eatable接口
    	void eat();
    }
    
    public interface Sleepable{    //定义了一个Sleepable接口
    	void sleep();
    }
    
    public class Animal{          // 定义了一个Animal类
    	public String name;
    	public Animal(String name) {
    		this.name = name;
    	}
    }
    
    public Dog extends Animal implements Eatable,Sleepable{    //继承了Animal类,Eatable接口 ,Sleepable方法
    	public Dog(String n) {
    		this(n);
    	}
    	public void eat() {         //重写Eatable中的eat方法
    		System.out.println(name+"吃骨头");
    	}
    	public void sleep() {       //重写Sleepable中的sleep方法
    		System.out.println(name+"睡得很好");
    	}
    }

    四、接口的回调(类似于 对象的上转型对象 )

           是什么?    接口名 接口的对象  =  实现了接口的类的对象

           该 接口对象 可以调用 被类实现了的 接口方法

         

    public interface Com{}
    
    public class Object implements Com{}
    
    Com com = new Object();   //接口的回调

     

     

              

    展开全文
  • 接口的定义及使用

    万次阅读 多人点赞 2018-08-07 17:50:28
    一、接口的基本定义 如果一个类之中只是由抽象方法和全局常量所组成的,那么在这种情况下不会将其定义为一个抽象类,而只会将其定义为接口,所以所谓的接口严格来讲就属于一个特殊的类,而且这个类里面只有抽象方法...

    一、接口的基本定义

    如果一个类之中只是由抽象方法和全局常量所组成的,那么在这种情况下不会将其定义为一个抽象类,而只会将其定义为接口,所以所谓的接口严格来讲就属于一个特殊的类,而且这个类里面只有抽象方法与全局常量。

    要定义一个接口使用interface关键字完成。

    范例:定义接口

    interface A {// 定义了接口
    	public static final String MSG = "Hello";// 全局常量
    	// 抽象方法
    
    	public abstract void print();
    }

    由于接口里面存在有抽象方法,所以接口对象不可能直接使用关键字new进行实例化的操作,所以接口的使用原则如下:

    · 接口必须要有子类,但是此时一个子类可以使用implements关键字实现多个接口;

    · 接口的子类(如果不是抽象类),必须要覆写接口中的全部抽象方法;

    · 接口的对象可以利用子类对象的向上转型进行实例化操作。

     

    范例:实现接口

    interface A {// 定义了接口
    	public static final String MSG = "Hello";// 全局常量
    	// 抽象方法
    
    	public abstract void print();
    }
    
    interface B {
    	public abstract void get();
    }
    
    class X implements A, B {// X类实现A和B两个接口
    
    	@Override
    	public void get() {
    		System.out.println("B接口的抽象方法!");
    	}
    
    	@Override
    	public void print() {
    		System.out.println("A接口的抽象方法!");
    	}
    }
    
    public class Demo {
    	public static void main(String args[]) {
    		X x = new X();
    		A a = x;// 向上转型
    		B b = x;// 向上转型
    		a.print();
    		b.get();
    	}
    }

    以上的代码实例化了X类对象。由于现在X是A和B的子类,所以X类的对象可以变成A接口或者B接口类的对象。

    public class Demo {
    	public static void main(String args[]) {
    		A a = new X();
    		B b = (B) a;
    		b.get();
    		System.out.println(a instanceof A);
    		System.out.println(a instanceof B);
    	}
    }

    在定义结构上来讲,A和B接口没有任何的直接联系,但是这两个接口却同时拥有一个子类:X子类,千万不要被类型和名称所迷惑。因为最终实例化的是X子类,而这个子类属于B类的对象,所以以上的代码成立。只不过从代码的编写上来讲并不是很好。

     

    但是要知道一点,对于子类而言,除了接口之外,还可能会去继承抽象类,所以说一个子类既要继承抽象类又要去实现接口的话,那么请先使用extends继承,而后再使用implements实现。

    interface A {// 定义了接口
    	public static final String MSG = "Hello";// 全局常量
    	// 抽象方法
    
    	public abstract void print();
    }
    
    interface B {
    	public abstract void get();
    }
    
    abstract class C {
    	public abstract void change();
    }
    
    class X extends C implements A, B {// X类实现A和B两个接口
    
    	@Override
    	public void get() {
    		System.out.println("B接口的抽象方法!");
    	}
    
    	@Override
    	public void print() {
    		System.out.println("A接口的抽象方法!");
    	}
    
    	@Override
    	public void change() {
    		System.out.println("C类的抽象方法!");
    
    	}
    }

    对接口而言,发现里面的组成就是抽象方法和全局常量,所以很多的时候也有一些人为了省略编写,可以不用写上abstract或public static final,并且在方法上是否编写public结果都是一样的,因为在接口里面只能够使用一种访问权限——public。以下两个接口的定义效果是完全相同的:

    interface A {

    public static final String MSG = "hello";

    public abstract void fun();

    }

    interface A {

    String MSG = "hello";

    void fun();

    }

    在接口里面没有写上public,其最终的访问权限也是public,绝对不是default。为了防止某些不熟悉语法的开发者出现错误,所以强烈建议在接口定义方法的时候一定要写上public。

    interface A {
    	String MSG = "hello";
    	public void fun();
    }

    对于接口的组成,99%的情况下都是以抽象方法为主,很少有接口只是单纯的去定义常量。

     

    一个抽象类可以去定义一个抽象类,但是反过来,一个接口却可以使用extends关键字同时继承多个接口(但是不能继承抽象类)。

    范例:观察接口的多继承

    interface A {
    	public void funA();
    }
    interface B{
    	public void funB();
    }
    //C接口同时继承了A和B两个父接口
    interface C extends A,B{//此处使用的是extends
    	public void funC();
    }
    class X implements C{
    	@Override
    	public void funA() {}
    	@Override
    	public void funB() {}
    	@Override
    	public void funC() {}
    
    }

    从继承关系上讲抽象类的限制要比接口多很多:

    · 一个抽象类只能够继承一个抽象的父类,而接口没有这个限制;

    · 一个子类只能够继承一个抽象类,而却可以实现多个接口。

    在Java里面,接口的主要功能是解决单继承局限问题。

     

    虽然从接口本身的概念来讲只能够由抽象方法和全局变量组成,但是所有的内部结构是不受到这些要求限制的,也就是说:在接口里面可以定义普通内部类、抽象内部类、内部接口。

    范例:在接口里定义抽象类

    interface A {
    	public void funA();
    	abstract class B {
    		public abstract void funB();
    	}
    }
    class X implements A {// X实现了A接口
    	public void funA() {
    		System.out.println("Hello");
    	}
    	class Y extends B {// 内部抽象类的子类
    		@Override
    		public void funB() {
    		}
    	}
    }

    范例:在一个接口内部如果使用了static去定义一个内部接口表示是一个外部接口。

    interface A {
    	public void funA();
    	static interface B {// 外部接口
    		public void funB();
    	}
    }
    class X implements A.B {
    	@Override
    	public void funB() {
    	}
    }

    大部分情况,只要求清楚内部接口的定义即可。

    先期总结:接口在实际的开发之中有三大核心作用:

    · 定义不同层之间的操作标准;

    · 表示一种操作的能力;

    · 表示将服务器端的远程方法视图暴露给客户端。


    二、接口的实际应用——标准定义

    电脑上可以使用U盘、Mp3、打印机,这些设备都是连接到USB设备上的。

    所有的代码如果要进行开发,一定要首先开发出USB接口标准,因为有了标准后,电脑才可以去使用这些标准,设备厂商才可以设计USB设备。

    范例:定义USB标准

    //标准可以连接不同层的操作类
    interface USB{//定义标准一定就是接口
    	public void start();
    	public void stop();
    }

    范例:定义电脑

    class Computer{
    	public void plugin(USB usb){//插入
    		usb.start();//固定操作
    		usb.stop();//固定操作
    	}
    }

    不管以后会有多少个设备,只要它是USB标准的实现子类,就都可以在电脑上使用。

    范例:定义U盘

    class Flash implements USB{
    	@Override
    	public void start() {
    		System.out.println("U盘开始使用");
    	}
    	@Override
    	public void stop() {
    		System.out.println("U盘停止使用");
    	}
    }

    范例:定义打印机

    class Print implements USB{
    	@Override
    	public void start() {
    		System.out.println("打印机开始使用");
    	}
    	@Override
    	public void stop() {
    		System.out.println("打印机停止使用");
    	}
    }

    按照这样的方式,准备出几万个子类都可以,并且这几万个子类都可以在电脑的plugin()方法上使用。

    public class Demo {
    	public static void main(String args[]) {
    		Computer com = new Computer();
    		com.plugin(new Flash());
    		com.plugin(new Print());
    	}
    }

    此时可以很好的描述出现实的关系。

    在现实的生活之中,标准的概念随处可见,而在程序里面标准就是用接口来定义的。


    三、接口的应用——工厂设计模式(Factory)

    下面首先来观察一段程序代码:

    interface Fruit {
    	public void eat();
    }
    
    class Apple implements Fruit {
    
    	@Override
    	public void eat() {
    		System.out.println("吃苹果");
    	}
    }
    
    public class Demo {
    	public static void main(String args[]) {
    		Fruit f = new Apple();
    		f.eat();
    	}
    }

    以上的程序可以通过主方法得到Fruit接口对象,但是有没有一些问题呢?

    如果要想确认一个代码是否真的好,有这么几个标准:

    · 客户端调用简单,不需要关注具体细节;

    · 客户端之外的代码修改,不影响用户的使用,即:用户不用去担心代码是否变更。

    本次的程序没有任何的语法错误,但是关键的问题就出在关键字“new”上。一个接口不可能只有一个子类,所以对于Fruit也有可能产生多个子类对象。

    class Orange implements Fruit {
    
    	@Override
    	public void eat() {
    		System.out.println("吃橘子");
    	}
    }

    现在的客户端上要想得到这新的子类对象,需要修改代码,修改为:

    public class Demo {
    	public static void main(String args[]) {
    		Fruit f = new Orange();
    		f.eat();
    	}
    }

    发现如果现在直接在客户端上产生了实例化对象,那么每一次要想更换对象,都需要修改客户端上的执行代码,这样的做法明显是不好的。

    在整个的代码过程之中,我们最需要关心的是如何取得一个Fruit接口对象,而后进行方法的调用,至于说这个接口对象是被谁实例化的,那不是客户端的工作。

    所以经过分析发现,最大的问题就在于关键字new,而这一问题就可以理解为耦合度太高。耦合度太高的直接问题是代码不方便维护,就相当于A一直要与B绑定在一起。可以完全参考Java虚拟机的设计思想:

    · 程序——>JVM——>适应不同的操作系统(A——>C——>B);

    范例:增加一个过渡

    class Factory {
    	public static Fruit getInstance(String className) {
    		if ("apple".equals(className)) {
    			return new Apple();
    		} else if ("orange".equals(className)) {
    			return new Orange();
    		} else {
    			return null;
    		}
    	}
    }
    
    public class Demo {
    	public static void main(String args[]) {
    		Fruit f = Factory.getInstance("apple");
    		f.eat();
    	}
    }

    现在的客户端不会看见具体的子类,因为所有的接口对象都是通过Factory类取得的,如果日后要扩充新的子类对象,则只需要修改Factory类即可,客户端的调用不会发生变化。

    扩展题目:请编写一个Factory程序。(以上答案)


    四、接口的应用——代理设计模式(Proxy)

    范例:程序(皇帝宠幸妃子)

    interface Subject {// 整个操作的核心主题
    	public void make();
    }
    
    class RealSubject implements Subject {
    	@Override
    	public void make() {
    		System.out.println("过程……");
    	}
    }
    
    class ProxySubject implements Subject {
    	private Subject subject;
    
    	// 要接收一个真实主题的操作对象
    	public ProxySubject(Subject subject) {
    		this.subject = subject;
    	}
    
    	public void prepare() {
    		System.out.println("准备……");
    	}
    
    	@Override
    	public void make() {
    		this.prepare();
    		this.subject.make();
    		this.destory();
    	}
    
    	public void destory() {
    		System.out.println("销毁");
    	}
    }
    
    public class Demo {
    	public static void main(String args[]) {
    		Subject sub = new ProxySubject(new RealSubject());
    		sub.make();// 调用的是代理主题的操作
    	}
    }

    代理设计模式的核心精髓就在于有一个主题操作接口(可能有多种方法),核心业务主题只完成核心功能,例如:吃饭,而代理主题负责完成所有与核心主题有关的辅助性操作。

    扩展题目:请编写一个Proxy程序。(以上答案)


    五、抽象类与接口的区别

    抽象类和接口在使用上是非常相似的,所以很多人很乐意去解释两者的区别。

    No

    区别

    抽象类

    接口

    1

    关键字

    Abstract class

    Interface class

    2

    组成

    构造方法、抽象方法、普通方法、static方法、常量、变量

    抽象方法、全局常量

    3

    子类使用

    class 子类 extends 抽象类

    class 子类 implements 接口,接口,……

    4

    关系

    可以实现多可接口

    不能够继承抽象类,却可以继承多个父接口

    5

    权限

    各种权限

    public

    6

    限制

    单继承局限

    没有单继承局限

    7

    子类

    抽象类和接口都必须有子类,子类必须要覆写全部的抽象方法

    8

    实例化对象

    依靠子类对象的向上转型进行对象的实例化。

    经过比较可以发现,抽象类支持的功能绝对要比接口更多,但是只有一点不好,那就是单继承局限,这重要的一点就掩盖了所有抽象类的优点,即:当抽象类和接口都可以使用的时候,优先考虑接口。

    一个参考(50%):

    · 在进行某些公共操作的时候一定要定义出接口;

    · 有了接口就需要利用子类完善方法;

    · 如果自己写的接口,那么绝对不要去使用关键字new直接实例化接口子类,使用工厂类完成。

     

    总结:

    1. 接口与抽象类定义的不同;
    2. 接口作为标准用于解耦合以及不同层之间的连接桥梁;

     

    展开全文
  • 接口

    千次阅读 2019-11-02 17:25:14
    1. 接口的引入 2. 接口的概念 接口也是一种数据类型,比抽象类更加抽象的'类'。 接口是功能的集合,它只描述功能所具备的方法,如何实现这些方法由实现类(子类)通过方法重写来完成。 3. 接口的定义和使用格式 3.1...

    1. 接口的引入

    2. 接口的概念

    • 接口也是一种数据类型,比抽象类更加抽象的'类'。
    • 接口是功能的集合,它只描述功能所具备的方法,如何实现这些方法由实现类(子类)通过方法重写来完成。

    3. 接口的定义和使用格式

    3.1 定义格式

    
     
    interface 接口名{
        // 抽象方法
        // 默认方法:JDK1.8
    }

    3.2 使用格式

    
     
    
     
    class 类名 implements 接口名{
                // 重写抽象方法
    }

    3.3 示例代码

    /**
     * 表演功能接口
     */
    public interface Perform {
        // 抽象方法
        void show();
    }​
    //动物类:用来描述动物类的共性内容
    abstract class Animal {
        // 成员方法
        public abstract void crow();
    }
    ​/**
     * 猴子类:继承 Animal
     */
    class Monkey extends Animal implements Perform{
        @Override
        public void crow() {
            System.out.println("唧唧...");
        }​
        @Override
        public void show() {
            System.out.println("表演捉老鼠");
        }
    }
    /**
     * 老虎类:继承 Animal
     */
    class Tiger extends Animal implements Perform{
        @Override
        public void crow() {
            System.out.println("嗷嗷...");
        }
        @Override
        public void show() {
            System.out.println("老虎表演胸口碎大石");
        }
    }​
    public class Demo01 {
        public static void main(String[] args) {
            // 创建猴子对象
            Monkey m = new Monkey();
            m.crow();
            m.show();
    
     
            // 创建老虎对象
            Tiger t = new Tiger();
            t.crow();
            t.show();
        }
    }

    4. 接口的特点和注意事项

    4.1 接口特点

    • 接口不能直接创建对象,只能创建实现类对象。
    • 接口中定义的成员变量是常量了
    • 接口中的常量有默认的修饰符:public static final
    • 接口中的抽象方法有默认的修饰符:public abstract
    • 接口中的方法在JDK1.8之后可以有默认的实现(可以有方法体,但是需要使用default关键字修饰),在JDK1.8之前所有的方法都是抽象方法。

    4.2 注意事项

    • 接口可以继承接口,而且可以多继承。
    • 一个类在继承一个类的同时可以实现多个接口,多个接口名之间使用逗号分隔
    • 一个实现类实现接口时需要重写接口接口所有抽象方法,否则该类必须定义为抽象类。

    5. 接口和抽象类的区别

    • 相同点

      • 都不能创建对象
      • 都可以定义抽象方法
      • (JDK1.8之后)都可以定义非抽象方法
    • 不同点

      • 接口中定义成员变量是常量,抽象类中可以定义成员变量和常量。

      • 接口中没有构造方法,抽象类有构造方法

      • 接口可以多继承,类只能单继承。

      • 接口中的成员有默认修饰符

        • 常量:public static final
        • 方法:public abstract
      • 抽象类的成员没有默认修饰符

      • 在JDK1.8之前,接口中只能定义抽象方法,在JDK1.8之后可以定义非抽象方法

      • 抽象类可以定义普通方法和抽象方法

      • 接口中的成员的修饰符是固定,抽象类中的成员的修饰符可以自定义

    6. 接口和抽象类的选择

    • 先考虑该功能是否是这种数据类型的共性内容

      • 如果是共性内容,则将该功能定义在父类中。 然后再考虑该功能是否会被所有子类重写如果是,则将该功能(方法)定义为抽象方法,那么该类就定义为抽象类。
      • 如果不是该中数据类型的共性内容,则就应该将该功能定义在接口中,需要拥有该功能的类实现该接口并重写抽象方法即可。
    展开全文
  • 接口&接口文档

    万次阅读 2018-09-02 23:16:41
    一、接口简介 API(Application Programming Interface)即应用程序接口,可以任务是一个软件组件或一个Web服务与外界进行交互的接口,在这里接口可以和API划等号。 接口可以简单的理解为一个黑盒子,从一边输入...
  • 接口是什么?什么是接口

    千次阅读 2019-07-31 14:27:32
    什么是接口? 1、什么是接口?  接口一般来讲分为两种: (1)程序内部的接口:方法与方法、模块与模块之间的交互,程序内部抛出的接口,如登录发帖,发帖就必须要登录,如果不登录不能发帖,发帖和登录这两个模块...
  • 接口概念和作用

    万次阅读 多人点赞 2018-08-16 22:33:23
    一、接口概念和作用 1.接口语法 interface 接口名{  // 静态常量,抽象方法 } 说明:① 声明一个接口使用关键字interface,而不是class,class是用来声明一个类,class和interface是属于同一个级别的。  ② 接口...
  • 接口是什么?为什么要使用它?

    万次阅读 多人点赞 2018-08-14 10:27:24
    1 什么是接口 接口是一种用来定义程序的协议,它描述可属于任何类或结构的一组相关行为。 接口是一组规则的集合,它规定了实现本接口的类或接口必须拥有的一组规则。体现了自然界“如果你是……则必须能……”的...
  • Java中接口作用的理解

    万次阅读 多人点赞 2018-05-08 23:27:49
    关于Java中接口作用的深入理解。这是个很容易遇到的问题吧,看下面红色的部分应该就能理解了。 / 2019/3/1 补充 : 接口的存在也是为了弥补类无法多继承的缺点,假设一个情况,父类--Animal 子类--Dog、Cat 、People...
  • 接口测试工具Postman接口测试图文教程

    万次阅读 多人点赞 2018-07-11 13:10:03
    市场上有很多优秀的,完善的接口测试工具,比如SoapUI,Postman等,能够高效的帮助后端开发人员独立进行接口测试。这里使用Postman接口测试工具,此处以请求方式为POST的userLogin登录接口为例。
  • 自动化接口测试之Postman(一篇搞定)

    万次阅读 多人点赞 2018-07-13 14:17:33
    Postman自动化接口测试 该篇文章针对已经掌握 Postman 基本用法的读者,即对接口相关概念有一定了解、已经会使用 Postman 进行模拟请求的操作。 当前环境: Window 7 - 64 Postman 版本(免费版): ...
  • 接口测试工具Postman使用实践

    万次阅读 多人点赞 2017-12-05 16:18:55
    接口测试工具Postman使用实践本次chat内容包括: 接口的定义 接口的分类 为何要进行接口测试 接口文档示例 Postman工具简介 借助Postman完成HTTP请求接口测试 Postman + Newman + Jenkins 实现接口自动化测试 一、...
  • 什么是接口测试?怎样做接口测试

    万次阅读 多人点赞 2018-08-20 11:17:31
    扫盲内容: 1.什么是接口? 2.接口都有哪些类型?...接口测试主要用于外部系统与系统之间以及内部各个子系统之间的交互点,定义特定的交互点,然后通过这些交互点来,通过一些特殊的规则也就是协议...
  • Jmeter接口测试+压力测试

    万次阅读 多人点赞 2017-05-14 14:01:50
    jmeter是apache公司基于java开发的一款开源压力测试工具,体积小,功能全,使用方便,是一个比较轻量级的测试工具,使用起来非常简单。因为jmeter是java开发的,所以运行的时候必须先要安装...其中接口测试的简单操作
  • 接口测试 | 接口测试入门

    万次阅读 多人点赞 2018-02-24 13:08:37
    接口测试讲义 1. 接口测试的类型 主要包含三种测试: Web接口测试, 应用程序接口(API, application programming interface)测试, 数据库测试。 实际上意义就是UI界面到数据库之间,数据流...
  • 接口测试

    万次阅读 2020-06-02 12:55:06
    接口测试简介 1.什么是接口 接口就是内部模块对模块,外部系统对其他服务提供的一种可调用或者连接的能力的标准,就好比usb接口,他是系统向外接提供的一种用于物理数据传输的一个接口,当然仅仅是一个接口是不能...
  • 接口测试简介以及接口测试用例设计思路

    万次阅读 多人点赞 2018-09-07 11:50:27
    接口测试简介 1.什么是接口 接口就是内部模块对模块,外部系统对其他服务提供的一种可调用或者连接的能力的标准,就好比usb接口,他是系统向外接提供的一种用于物理数据传输的一个接口,当然仅仅是一个接口是不能...
  • JMeter接口测试入门

    万次阅读 多人点赞 2018-07-16 16:23:08
    除了压力测试外,JMeter在接口测试方面也有广泛的应用。2、JMeter安装访问JMeter官网:https://jmeter.apache.org/download_jmeter.cgi,点击下载后解压缩,依次打开\apache-jmeter-4.0\JMeter\bi...
  • 接口测试全流程

    万次阅读 多人点赞 2018-05-28 11:16:07
    1.什么是接口? 2.接口都有哪些类型? 3.接口的本质是什么? 4.... 接口测试主要用于外部系统与系统之间以及内部各个子系统之间的交互点,定义特定的交互点,然后通过这些交互点来,通过一些...
  • 接口测试用例设计(详细干货)

    万次阅读 多人点赞 2018-01-19 09:34:46
    那么接口测的用例设计...1 接口测试 1.1 接口测试接口:主要是子模块或者子系统间交互并相互作用的部分。这里说的接口是广义的,客户端与后台服务间的协议;插件间通信的接口;模块间的接口;再小到一个类提供的方法

空空如也

1 2 3 4 5 ... 20
收藏数 4,398,901
精华内容 1,759,560
关键字:

接口