举例java接口通俗理解,JAVA接口实例
本文给大家带来了一些关于java的知识，包括接口的概念，一些知识点的总结，语法规则，接口的使用以及接口的特点等。来看看吧，希望对你有帮助。
如何解决写爬虫IP受阻的问题？立即使用。
接口
图形流
接口的概念以及一些知识点汇总
接口与类的相同处
接口与类的不同处
接口的一些特点
抽象类和接口的区别
-1010在JDK1.8之前，它们有以下区别
所以这里要注意的是：JDK1.8以后，接口中允许含有静态方法和方法体，允许包含具体实现的方法，该方法我们称之为“默认方法”，这种方法使用default关键字来修饰JDK1.9以后，允许将方法定义为private，使某些复用的代码不会将方法暴露出去抽象类存在的意义是为了让编译器更好地校验，一般抽象类我们不会直接使用，而是使用它的子类，如果不小心通过抽象类创建了对象，编译器就会及时提醒我们。。
那么现实生活中的界面是怎样的呢？可以是USB口，电源插座等。在笔记本上。
那么这些接口在实现意义和使用标准上是不同的。
从上面的例子我们可以看出：接口就是公共的行为规范标准，大家在实现时，只要符合规范标准，就可以通用。在Java中，接口可以看成是：多个类的公共规范，是一种引用数据类型
语法规则
接口的定义格式与定义类的定义格式基本相同。将class关键字更改为interface关键字定义了一个接口。
公共接口名称{
//抽象方法
公共抽象void method 1()；
//public abstract是固定搭配，可以不填。
公共void method 2()；
抽象void方法3()；
void方法4()；
//注意：以上的编写方法都是接口中的抽象方法，所以像method4}
接口的使用
接口不能直接实例化使用，必须要有一个类去实现它，实现接口中所有的抽象方法这样写代码更整洁
类名公共类名实现接口名{
//.}注意：子类和父类之间是extends继承关系，类与接口之间是implements实现关系。
//USB接口公共接口USB{
void open device()；
void close device()；}//鼠标类，实现USB接口公共类鼠标实现USB{
@覆盖
public void openDevice(){
System.out.println(打开鼠标)；
}
@覆盖
public void closeDevice(){
System.out.println(关闭鼠标)；
}
公共void click(){
System.out.println(“鼠标点击”)；
} }//键盘类，实现USB接口公共类键盘实现USB {
@覆盖
public void openDevice(){
System.out.println(打开键盘)；
}
@覆盖
public void closeDevice(){
System.out.println(关闭键盘)；
}
公共void输入(){
System.out.println(“键盘输入”)；
} }//笔记本类：使用USB设备公共类计算机{
公共void powerOn(){
System.out.println(打开笔记本电脑)；
}
public void powerOff(){
System.out.println(关闭笔记本电脑)；
}
公共void使用的设备(USB usb){
USB . open device()；
if(鼠标的usb实例){
鼠标mouse=(鼠标)usb
mouse . click()；
}else if(键盘的usb实例){
键盘keyBoard=(键盘)usb
键盘.输入()；
}
USB . close device()；
} }//测试类：公共类TestUSB{
公共静态void main(String[] args){
电脑computer=新电脑()；
computer . poweron()；
//使用鼠标设备
computer . usedevice(new Mouse())；
//使用键盘设备
computer.useDevice(新键盘())；
computer . power off()；
}}输出：
instanceof
上面的代码示例中提到了instanceof，可能有些朋友不太理解。我在之前的博客里介绍过，这里再给大家解释一下。
Instanceof是Java的保留关键字，左边是对象，右边是类，返回类型是Boolean。
它的具体作用是测试左对象是右类创建的实例化对象还是右类的子类。
如果是，则返回true，否则返回false【instanceof使用注意事项】。
现有的继承关系，然后使用instanceof(包括接口的实现)。
【instanceof应用场景】
当你需要对一个物体进行施法时，你需要使用instanceof进行判断。
接口的特性
接口类型是引用类型，但它不能直接引用新接口的对象公共类test USB {
公共静态void main(String[] args){
USB USB=new USB()；
} }//编译时会出错：USB是抽象的，不能实例化。
接口中的每个方法都是公共抽象方法，也就是接口中的方法会被隐式指定为公共抽象(只有公共抽象，其他修饰符会报错)公共接口USB {
//编译错误：此处不允许修饰符private
//或者java:缺少方法体，或者声明是抽象的
私有void open device()；
void close device()；
//不同版本的JDK编译器标准不同，错误也不同}接口中的方法不能在接口中实现，公共接口USB只能由实现接口的类实现{
void open device()；
//编译失败：因为接口中的方法默认是抽象的。
//错误：接口抽象方法不能有主体}
但是如果我们在这里添加一个默认值，那么我们就可以实现方法体。
在接口中重写方法时，不能使用default作为访问权限来修饰公共接口USB { void open device()；//默认为public void close device()；//默认为public} public类鼠标实现USB {
@覆盖
void openDevice(){
System.out.println(打开鼠标)；
}
//.}//这里编译会报错。在USB中重写openDevice方法时，不能使用默认修饰符。
实现此接口，重写此接口的方法的访问限定修饰符的范围大于接口中的范围。
接口可以包含变量，但接口中的变量将被编译器自动隐式指定为public static final变量公共接口USB {
双品牌=3.0；//默认为：最终公共静态装饰
void open device()；
void close device()；}公共类TestUSB {
公共静态void main(String[] args){
system . out . println(USB . brand)；
//可以通过接口名直接访问，表示该变量是静态的。
//下面的写法会报错Java:最终变量brand不能赋值。
USB.brand=2.0
//说明品牌有最终属性
}}
不能有静态代码块和构造函数publicneterface USB {
公共USB(){
}//编译失败
{
}//编译失败
void open device()；
void close device()；}
虽然接口不是类，但是接口编译后的字节码文件的后缀格式也是。班级。如果该类没有实现接口中的所有抽象方法，则该类必须设置为抽象类。JDK8规定接口可以包含上述默认方法
实现多个接口
。在Java中，类是相互继承的，一个类只能被一个父类继承，即Java中不支持多继承，但是010-5900。以下是代码演示。
公共类动物{
受保护的字符串名称；
公共动物(字符串名称){
this.name=name
} }公共接口IFlying {
void fly()；}公共接口运行{
空运行()；}公共接口正在迁移{
虚空游()；}
然后我们将创建几个具体的animal类来接受和实现这些接口。
比如猫会跑。
公共类Cat扩展动物工具IRunning{
公共类别(字符串名称){
超级(名)；
}
@覆盖
公共无效运行(){
System.out.println(小猫 this.name 正在运行)；
}}鱼会游泳。
公共课鱼目混珠
公共鱼(字符串名){
超级(名)；
}
@覆盖
公共虚空游(){
System.out.println(小鱼 this.name 正在游泳)；
}}而且青蛙会跑会游泳。
公共课青蛙伸农具跑步，游泳{
公共青蛙(字符串名){
超级(名)；
}
@覆盖
公共无效运行(){
system . out . println( frog this . name 正在运行)；
}
@覆盖
公共虚空游(){
System.out.println(青蛙 this.name 正在游泳)；
}}一个类可以实现多个接口
注意：一个类实现多个接口的时候，每个接口中的抽象方法都要去实现，除非类用abstract修饰，为抽象类
公类鹅伸农具跑、走、飞{
公鹅(串名){
超级(名)；
}
@覆盖
公共void fly() {
system . out . println(this . name‘飞天’)；
}
@覆盖
公共无效运行(){
System.out.println(this.name 正在运行)；
}
@覆盖
公共虚空游(){
System.out.println(this.name 正在漂在水上);
}}这段代码展现了爪哇面向对象编程中最常见的用法：一个类继承了一个父类，然后同时实现多个接口
继承表达的含义是还有一种动物水陆空三栖，它是大白鹅,而接口表达的含义是is-a
有了接口之后，类的使用者就不需要去关注具体的类的属性是否符合，而只需要关心某个类是否具有某个特性/功能，如果有，就可以实现对应的接口
那么我们现在实现一个走路的方法
公共类测试演示1 {
公共静态空走(咿咿呀咿呀){
System.out.println(我带着小伙伴去散步);
我在跑步。run()；
}
公共静态void main(String[] args) {
猫猫=新猫(小猫);
走路（猫);
青蛙青蛙=新青蛙(小青蛙);
走路（青蛙);
}}输出结果
只要是会跑的，带有跑这个属性特征的，都可以接受相应的对象
公共类机器人实现运行中{
私有字符串名称；
公共机器人（字符串名称){
this.name=name
}
@覆盖
公共无效运行(){
System.out.println(this.name 正在用轮子跑);
}
公共静态void main(String[] args) {
机器人机器人=新机器人(机器人);
行走（机器人);
}}
故输出结果为
接口之间的继承
在爪哇中，类和类之间是单继承的，一个类可以实现多个接口，接口与接口之间可以多继承。
即：用接口可以达到多继承的目的
接口可以继承一个接口，达到复用的效果。这里使用延伸关键字
界面运行{
空运行();}接口正在迁移{
虚空游();}//两栖的动物，即能跑，也能游泳接口双生的扩展IRunning正在漫游{ }类青蛙实现IAmphibious {
.}通过接口继承创建一个新的接口双生的表示"两栖的"。
创建的青蛙类就实现了这个两栖的接口
接口使用的例子
我们在之前的数组中讲解过给数组排序，那么我们该如何给对象数组排序呢？
首先我们定义一个学生的类，然后重写一下线方法
公共课学生{
私有字符串名称；
私有int分数；
公共学生（字符串名称，int分数){
this.name=name
得分=分数
}
@覆盖
公共字符串toString() {
返回"学生"
name= name \
,分数=分数
};
}}我们再给定一个学生对象数组，根据这个对象数组中的元素进行排序
这里我们按照分数降序排序
公共课学生{
私有字符串名称；
私有int分数；
公共学生（字符串名称，int分数){
this.name=name
得分=分数
}
@覆盖
公共字符串toString() {
返回"学生"
name= name \
,分数=分数
};
}
公共静态void main(String[] args) {
学生[]学生=新生[]{
新生(《一》，95)，
新生(乙，96)，
新生(丙，97)，
新生( D ，98)，
};
}}那么按照我们之前的理解，数组中有一个可以供我们使用的分类方法，我们能否直接使用呢？
数组.排序(学生);System.out.println(学生);//运行结果：线程“主”Java。郎。抛出中出现异常：class ClassArray .不能将学生强制转换为可比较的类(ClassArray .学生位于加载程序"应用程序"的未命名模块中；可比较的位于加载程序“自举”的java.base模块中
在爪哇。基础/Java。util。comparabletimsort。countrunandmakesanding(comparabletimsort。Java:320)
位于Java。基础/Java。util。comparabletimsort。排序(comparabletimsort。Java:188)
位于Java。基础/Java。util。数组。排序(数组。Java:1041)
在ClassArray .学生。主(学生。java:36)
我们可以看到这里程序报错了，这里的意思是学生并没有实现可比较的的接口
那么这里的分类是进行普通数字的比较，大小关系明确，而我们指定的是两个学生对象的引用变量，这样的大小关系的指定是错误的，我们需要额外去人为规定对象中的比较元素
那么怎么实现呢？
公共课学生实行对等学习{
私有字符串名称；
私有int分数；
公共学生（字符串名称，int分数){
this.name=name
得分=分数
}
@覆盖
公共字符串toString() {
返回"学生"
name= name \
,分数=分数
};
}
@覆盖
公共国际比较（学生o) {
if (this.scoreo.score){
return-1；//如果当前对象应排在参数对象之前，则返回小于0的数字
} else if(this.scoreo.score){
返回1;//如果当前对象应排在参数对象之后，则返回大于0的数字
}否则{
返回0;//如果当前对象和参数对象不分先后，则返回0
}
}}那么我们在这里重写了比较的方法，自己定义了比较的规则，我们就自己再去写一个分类的方法，去调用这个比较方法，真正意义上实现对对象数组的排序
我们使用冒泡排序法
公共静态空的排序(Comparable[] array){//这里要注意，虽然接口不能实例化对象，//但是接口类型的引用变量可以指向它的实现类对象//这里的实现类对象就是实现了这个接口的对象//例如可比[]可比=新生[3];//所以这里的参数就可以用可比[]数组来接收
for(int bound=0；边界长度绑定){
for(int cur=array。长度-1；路边；cur - ){
如果(数组[cur-1]。compareTo(array[cur])0){
//这里就说明顺序不符合要求，交换两个变量的位置
comparable tmp=array[cur-1]；
array[cur-1]=array[cur]；
array[cur]=tmp；
}
}
} }排序方法写好了，我们写一个主要的函数来测试一下
公共静态void main(String[] args) {
学生[]学生=新生[]{
新生(《一》，95)，
新生(《乙》，91)，
新生(丙，97)，
新生( D ，95)，
};
System.out.println(排序前：数组。tostring(学生))；
排序（学生);
System.out.println(排序后：数组。tostring(学生))；
}运行结果
e:\ develop \ Java \ JDK-11 \ bin \ Java exe -Java代理：E:\ IDEA \ IntelliJ IDEA社区版2021 .3 .2 \ lib \ IDEA _ rt . jar=65257:E:\ IDEA \ IntelliJ IDEA社区版2021 .3 .2 \ bin -d文件。encoding=UTF-8-class path E:\ Java code \ gyl Java \ Interface \ out \ production \ Interface class array .学生分类前：[学生{name=A ，score=95}，学生{name=B ，score=91}，学生{name=C ，score=97}，学生{name=D ，score=95 }]排序后：[学生{name=C ，score=97}，学生{name=A ，score=95}，学生{name=D ，score=95}，学生{name=B ，score=91}]那么我们如果想要按照名字排序呢？也是可以的
导入Java。util。数组；导入Java。util。比较器；/**
*用智能理念创建。
*描述：您好，欢迎您的评论~
*用户：格雷米
*日期：-2013年四月
*目的地：利用可比较的的接口实现对对象数组选择性排序的功能
*/班级学生实施比较学生{
公共字符串名称；
公共年龄
公共学生（字符串名称，整数){
this.name=name
this.age=年龄；
}
@覆盖
公共字符串toString() {
返回"学生"
name= name \
,年龄=年龄
};
}
@覆盖
公共国际比较（学生o) {
返回这个。姓名。比较到(o . name)；
} }类年龄比较仪实现比较研究{
@覆盖
公共（同Internationalorganizations）国际组织比较（学生o1，学生o2) {
返回O1。年龄-氧气。年龄；
} }类名比较仪实现比较研究{
@覆盖
公共（同Internationalorganizations）国际组织比较（学生o1，学生o2) {
返回O1。姓名。与O2相比。姓名)；
} }公共类测试演示{
公共静态void main(String[] args) {
学生[]学生=新生[3];
学生[0]=新生(张三,19);
学生[1]=新生(‘李斯’，8)；
学生[2]=新生(‘ABC’，78)；
年龄比较器年龄比较器=新年龄比较器()；
名称比较器name comparator=new name comparator()；
//这里的方法分类是排列里面自带的，非常方便，
//只需将我们写好的比较器传过去就好了
System.out.println(排序前：数组。tostring(学生))；
数组.排序(学生，名称比较器)；
System.out.println(排序后：数组。tostring(学生))；
可比学生[]可比学生=学生；
}
public static void main 2(String[]args){
/*学生学生1=新生(张三,19);
学生学生2=新生(‘ABC’，78)；
如果(学生2。比较对象(学生1)0){
系统。出去。println( fafaa )；
}*/
}
公共静态void main 1(String[]args){
学生[]学生=新生[3];
学生[0]=新生(张三,19);
学生[1]=新生(‘李斯’，8)；
学生[2]=新生(‘ABC’，78)；
System.out.println(排序前：数组。tostring(学生))；
数组.排序(学生);
System.out.println(排序后：数组。tostring(学生))；
}}
Clonable接口以及深拷贝
其作用如其名，是用来进行克隆的，可克隆是个很有用的接口。
目标类中存在一个克隆方法，调用这个方法可以创建出一个对象，实现"拷贝"。
但是我们想要合法调用克隆方法，就要先实现可克隆的接口，
否则就会抛出CloneNotSupportedException异常
/**
*用智能理念创建。
*描述：您好，欢迎您的评论~
*用户：格雷米
*日期：-2013年四月
*目的地：利用可克隆的的接口实现克隆方法，克隆含对象的对象
*/类货币实现可克隆的{
公双钱=19.9;
@覆盖
受保护对象克隆()引发CloneNotSupportedException {
返回超级棒。clone()；
} }类人实现可克隆的{
public int id=1234
公款m=新钱();
@覆盖
公共字符串toString() {
返回"人员{"
id= id \
};
}
@覆盖
受保护对象克隆()引发CloneNotSupportedException {
人tmp=(人)超级。clone()；
tmp。m=(钱)这个。m .克隆()；
返回终端监督程式（Terminal Monitor Program的缩写）
//返回超级棒。clone()；
} }公共类测试演示{
公共静态void main(String[] args) {
对象o=新人();
对象o2=新钱();
}
公共静态void main1(String[] args)引发CloneNotSupportedException {
人员人员1=新人();
Person person2=(人)人1。clone()；
系统。出去。println(人称1。m . money)；
系统。出去。println(人称2。m . money)；
系统。出去。println(===================)；
人物2。m . money=99.99
系统。出去。println(人称1。m . money)；
系统。出去。println(人称2。m . money)；
}}推荐学习： 《java视频教程》 以上就是带你搞懂爪哇的接口（实例详解)的详细内容，更多请关注我们其它相关文章！
郑重声明：本文由网友发布，不代表盛行IT的观点，版权归原作者所有，仅为传播更多信息之目的，如有侵权请联系，我们将第一时间修改或删除，多谢。