java接口的理解

最新推荐文章于 2022-03-12 01:31:59 发布

码界一棵葱

最新推荐文章于 2022-03-12 01:31:59 发布

阅读量632

点赞数

分类专栏： Java

本文链接：https://blog.csdn.net/lyyybz/article/details/8770563

版权

Java 专栏收录该内容

19 篇文章 0 订阅

订阅专栏

你确实已经在用接口了，最典型的比如Swing里面的监听。回头想想，是不是？

接口，interface，从中文的翻译上来说，接口的意思就是两个系统之间的联系。

所以如果想要理解接口，你必须先搞清楚两个系统之间会有什么样的联系呢？怎么联系呢？

我们举例说明：（下面的文字需要你打开你的编程工具，跟我一起实现所有代码。）

比如一个大牌导演，现在要组织一台晚会，这个大牌导演最擅长的就是大场面、大制作，演员无所为，他把谁放进去，谁准大红大紫。但是也不是没有任何标准，抓一个人就用，导演列出了他要使用的演员的标准：能说好台词；好，就这个标准，普天之下，谁符合标准谁就可以拿来用了。

导演和演员是有关系的，导演需要支配演员。

我们看具体的演员和一个具体的导演。

演员类：

Code:

package net.qingsoft.example;
publicclass Player {
publicvoid say(String message)
{
System.out.println("表演台词：---"+message+"---");
}
}

导演类：

Code:

package net.qingsoft.example;
publicclass Director {
publicvoid perform(Player player)
{
System.out.println("演出马上开始...");
player.say("青软培训探秘Java");
System.out.println("演出现在结束...");
}
}

大家已经看到了，导演中的perform方法会用到演员Player；

我们测试一下：

Code:

package net.qingsoft.example;
publicclass Test {
publicstaticvoid main(String[] args) {
Player player = new Player();
Director director = new Director();
director.perform(player);
}
}

结果：

Code:

演出马上开始...
表演台词：---青软培训探秘Java---
演出现在结束...

没错，就是这个结果。

现在呢有个机器人，很厉害，也可以说台词。

Code:

package net.qingsoft.example;
publicclass Robot {
publicvoid say(String message)
{
System.out.println("我是机器人，我说台词：==="+message+"===");
}
}

那么这个机器人能否提供给导演来用呢？

也就是能否这样用呢？

Code:

Robot Robot = new Robot();
Director director = new Director();
director.perform(player);

别听我说，你最好现在就实验一下。看到了吧，不行。为什么呢？因为perform方法要的是Player，很明显，Robot和Player没有任何关系。我要的是馒头，你给我了一把剪刀，这个不行。

你想到了，让perform方法能使用Robot不就行了么，对我们可以重载。

修改一下Director类，重载perform方法

Code:

package net.qingsoft.example;
publicclass Director {
publicvoid perform(Player player)
{
System.out.println("演出马上开始...");
player.say("青软培训探秘Java");
System.out.println("演出现在结束...");
}
publicvoid perform(Robot robot)
{
System.out.println("演出马上开始...");
robot.say("青软培训探秘Java");
System.out.println("演出现在结束...");
}
}

怎么样，现在你也可以perform(robot)了吧

呵呵，新的问题又来了，现在我在想，为什么下面这个鹦鹉不能去参加演出呢？

Code:

package net.qingsoft.example;
publicclass Parrot {
publicvoid say(String message)
{
System.out.println("鹦鹉学舌：---"+message+"---");
}
}

是的，你现在依然还不能这样调用：

Code:

Parrot parrot = new Parrot ();
Director director = new Director();
director.perform(parrot);

对，继续重载perform方法吧

可是能拿来做演员的实在太多了，猴子、猩猩，据说最近韩国有头大象都在练习说话了，怎么办？难道我要一直重载无数个perform方法么？

其实，导演perform要的就是一个会说话的这么个玩意，你拿来的玩意只要符合这个标准，就没问题了。那么我们不妨换个思路，导演只确认演员的标准，也就是只要求演员能说话就好了。

好的，导演对演员要求的标准是：

Code:

package net.qingsoft.example;
publicinterface Actress {
publicvoid say(String message);
}

这是个接口，导演根本不看你到底如何表演，只是要求了说你必须会say(String)，你只要会这个就可以了。不过我给接口起这个Actress 名字确实不太合适，凑合用吧，也代表了现在导演的潮流了。

大家注意了，这个接口里面明确的say方法是抽象的，不需要任何具体操作，因为这是导演树立标准的时候所不需要考虑的。

导演类也改变为：

Code:

package net.qingsoft.example;
publicclass Director {
publicvoid perform(Actress actress)
{
System.out.println("演出马上开始...");
actress.say("青软培训探秘Java");
System.out.println("演出现在结束...");
}
}

你注意到了么，perform的参数变成了Actress。也就是现在不用再无休止的重载了，现在我们的导演perform方法只要一个，就是符合Actress这个标准就可以了。啥都行，只要符合这个标准。怎么才能符合这个标准呢？没错，就是implements，只要你的类，无论他出身何处（从什么继承），只要他implements了我们的接口，他就是一个光荣的Actress了（你可能会想那些男演员怎么办？那头大象怎么办？）。

好的，我们可以让我们之前的Player implements Actress，Robot implements Actress,Parrot implements Actress，甚至你现在的随便一个类implements Actress，然后你就可以

Code:

Xxxx xxxx = new Xxxx();
Director director = new Director();
director.perform(xxxx);

只要这个Xxxx类实现了Actress标准就可以了。（你可以把任何一个类implements Actress，然后拿来替换Xxxx）

导演可以再也不用管到底天下有多少的可以当演员的类了，也不用天天为了频繁跳出来的新的演员类而不断重载方法了。他只看一件事情，就是你说来参加我导演的大戏，你必须符合我定的标准。当然导演可能随时更改这个标准。他更改标准的时候也从来不去关心那些符合标准的人的情况，我给改了标准，你们如果还要继续implements，那没办法，你们必须也要重新添加新的方法（我新定的标准），然后才能继续为我所用。

导演只看到了标准。

演员只需要符合标准。

导演可以不看演员的具体出身。

导演可以不管不问演员的其他需要。

导演只使用符合既定标准的那些方法。

谁想当演员，谁就要实现导演定义演员的标准。

拿起键盘，马上实验一下吧。

我只为了你能理解接口在编程中的作用。我们后面继续看看ActionListener到底是个什么，Java的监听如何实现呢？

多重继承是指一个子类可以有多个直接父类，该子类可以全
部或部分继承所有直接父类的数据成员及成员方法。而Java出于安全性、简化程序结构的考虑，不支持类间的多继承而只支持单继承。然而在

解决实际问题的过程中，在很多情况下仅仅依靠单继承不能将复杂的问题描述清楚。为了使Java程序的类间层次结构更加合理，更符合实际问

题的本质，Java语言提供接口来实现多重继承机制。

(1) interface是声明接口的关键字，可以把它看成一个特殊
类。
(2) 接口名要求符合Java标识符规定。
(3) 修饰符有两种：public 和默认。public修饰的接口是公共
接口，可以被所有的类和接口使用；默认修饰符的接口只能被
同一个包中的其他类和接口使用。
(4) 父接口列表：接口也具有继承性。定义一个接口时可以
通过extends关键字声明该接口是某个已经存在的父接口的派生接
口，它将继承父接口的所有属性和方法。与类的继承不同的是一
个接口可以有一个以上的父接口，它们之间用逗号分隔。
(5) 常量数据成员声明：常量数据成员前可以有也可没有修
饰符。修饰符是public final static和fina1 static；接口中的数据成
员都是用 final修饰的常量，写法如下：
修饰符数据成员类型数据成员名=常量值
或
数据成员名=常量值
例如：
public final static double PI=3.14159；
final static int a=9；
int SUM=100；(等价于final static int SUM=100;)
(6) 抽象方法声明：接口中的方法都是用abstract修饰的抽象
方法。在接口中只能给出这些抽象方法的方法名、返回值和参
数列表，而不能定义方法体，即这些接口仅仅是规定了一组信
息交换、传输和处理的“接口”。格式如下：
返回值类型方法名(参数列表)；
其中：接口中的方法默认为public abstract方法。接口中方
法的方法体可以由Java语言书写，也可以由其他语言书写。方
法体由其他语言书写时，接口方法由native修饰符修饰。
从上面的格式可以看出，定义接口与定义类非常相似。实
际上完全可以把接口理解成为一种特殊的类，由常量和抽象方
法组成的特殊类。一个类只能有一个父类，但是它可以同时实
现若干个接口。这种情况下，如果把接口理解成特殊的类，那
么这个类利用接口实际上就获得了多个父类，即实现了多重继
承。
接口定义仅仅是实现某一特定功能的一组功能的对外接口
和规范，而不能真正地实现这个功能，这个功能的真正实现是
在“继承”这个接口的各个类中完成的，即要由这些类来具体定义
接口中各抽象方法的方法体。因而在Java中，通常把对接口功能
的“继承”称为“实现”。

定义接口注意事项
定义接口要注意以下几点：
(1) 接口定义用关键字interface，而不是用class。
(2) 接口中定义的数据成员全是final static，即常量。
(3) 接口中没有自身的构造方法，所有成员方法都是抽象
方法。
(4) 接口也具有继承性，可以通过extends关键字声明该接
口的父接口。

类实现接口的注意事项
一个类要实现接口，即一个类要调用多个接口时，要注意
以下几点：
(1) 在类中，用implements关键字就可以调用接口。一个类
若要调用多个接口时，可在implements后用逗号隔开多个接口的
名字。
(2) 如果实现某接口的类不是abstract的抽象类，则在类的定
义部分必须实现指定接口的所有抽象方法，即为所有抽象方法
定义方法体，而且方法头部分应该与接口中的定义完全一致，
即有完全相同的返回值和参数列表。
(3) 如果实现某接口的类是abstract的抽象类，则它可以不实
现该接口所有的方法。但是对于这个抽象类的任何一个非抽象
的子类而言，它们的父类所实现的接口中的所有抽象方法都必
须有实在的方法体。这些方法体可以来自抽象的父类，也可以
来自子类自身，但是不允许存在未被实现的接口方法。这主要
体现了非抽象类中不能存在抽象方法的原则。
(4) 接口的抽象方法的访问限制符都己指定为public，所以类在实现方法时，必须显式地使用public饰符，否则将被系统警告为缩小了接口中

定义的方法的访问控制范围。正是因为抽象的概念在问题领域没有对应的具体概念，所以用以表征抽象概念的抽象类是不能够实例化的。

在面向对象的概念中，我们知道所有的对象都是通过类来描绘的，但是反过来却不是这样。并不是所有的类都是用来描绘对象的，如果一个类

中没有包含足够的信息来描绘一个具体的对象，这样的类就是抽象类。抽象类往往用来表征我们在对问题领域进行分析、设计中得出的抽象概

念，是对一系列看上去不同，但是本质上相同的具体概念的抽象。

从某种意义上说，interface是一种特殊形式的abstractclass。
abstarctclass在Java语言中体现了一种继承关系，要想使得继承关系合理，父类和派生类之间必须存在"isa"关系，即父类和派生类在概念本

质上应该是相同的）。对于interface来说则不然，并不要求interface的实现者和interface定义在概念本质上是一致的，仅仅是实现了

interface定义的契约而已。abstractclass在Java语言中表示的是一种继承关系，一个类只能使用一次继承关系。但是，一个类却可以实现多

个interface。

接口（interface）可以说成是抽象类的特例。接口中的所有方法都必须是抽象的，接口中的方法定义默认为public abstract finable。
看一下他们在语法上的区别吧！
1，抽象类里可以有构造方法，而接口内不能有构造方法。
2，抽象类中可以有普通成员变量，而接口中不能有普通成员变量。
3，抽象类中可以包含非抽象的普通方法，而接口中所有的方法必须是抽象的，不能有非抽象的普通方法。
4，抽象类中的抽象方法的访问类型可以是public ，protected和默认类型，但接口中的抽象方法只能是public类型的，并且默认即为

public abstract类型。
5，抽象类中可以包含静态方法，接口内不能包含静态方法。
6，抽象类和接口中都可以包含静态成员变量，抽象类中的静态成员变量的访问类型可以任意，但接口中定义的变量只能是public static

类型，并且默认为public static类型。
7，一个类可以实现多个接口，但只能继承一个抽象类。
再补充点两者在应用上的区别：
接口更多的是在系统框架设计方法发挥作用，主要定义模块之间的通信，而抽象类在代码实现方面发挥作用，可以实现代码的重用

2.public abstract class A {
int i=1;
public void printI() {
System.out.println("i="+i);
}
}

public class B extneds A{
int i=2;
public static void main(String[] args) {
B b=new B();
b.printI();
}
} 输出地结果为1
（1）子类B 的构造方法被调用，实例化一个B对象，B对象的成员被初始化
（2）jvm隐含的调用父类的构造方法,实例化一个A对象，A对象的成员被初始化。
（3）由于A对象的printI()未被屏蔽，所以调用的A对象的printI()函数。
那么，在这里A的成员函数当然是访问自己的成员变量了。
类的继承知识点
（1）java不支持多重继承，也就是说子类至多只能有一个父类
（2）子类继承了其父类中不是私有的成员变量和成员方法，作为自己的成员变量和方法
（3）子类中定义的成员变量和父类中定义的成员变量相同时，则父类中的成员变量不能被继承
（4）子类中定义的成员方法，并且这个成员方法的名字，返回类型，及参数个数和类型与父类的某个成员方法完全相同，则父类的成员方法不