Java基础知识(接口)
接口
Java接口是一系列方法的声明，是一些方法特征的集合，一个接口只有方法的特征没有方法的实现，因此这些方法可以在不同的地方被不同的类实现，而这些实现可以具有不同的行为（功能）。
接口的定义
接口：
- 在JAVA编程语言中是一个抽象类型，是抽象方法的集合，接口通常以interface来声明。一个类通过继承接口的方式，从而来继承接口的抽象方法。而接口是更加彻底的抽象，接口中全部是抽象方法。（JDK8之前），接口同样是不能创建对象的。
- 并且为了弥补我们之前继承中只能单继承的缺点，Java为了我们提供了接口，它可以多实现接口。
- 接口更像是表达一种能力规范，就想之前我们定义动物，动物有吃的行为方法，而其他实现了动物接口类的动物都必须实现吃这一行为方法。所以其作用主要告诉实现类，你要实现我里面所具备的功能。
那么接口和抽象有什么区别吗？
接口和抽象的区别
- 抽象类中的方法可以有方法体，就是能实现方法的具体功能，但是接口中的方法不行。
- 抽象类中的成员变量可以是各种类型的，而接口中的成员变量只能是 public static final 类型的。
- 接口中不能含有静态代码块以及静态方法(用 static 修饰的方法)，而抽象类是可以有静态代码块和静态方法。
- 一个类只能继承一个抽象类，而一个类却可以实现多个接口。
注意：
JDK 1.8 以后，接口里可以有静态方法和方法体了，接口允许包含具体实现的方法，该方法称为默认方法，默认方法使用 default 关键字修饰。
具体的学习，我们一起来看看吧！
接口的格式
主要通过interface关键字修饰在类上，使其成为一个接口类！接口中的所有方法都必须只声明方法标识，而不要去声明具体的方法体。
|
1
2
3
4
5
|
//接口的格式：
修饰符 interface 接口名称{
// 抽象方法
void eat();
}
|
而如果类需要去实现该接口的关键字implements。
实现的过程需注意的点：
- 必须重写实现的全部接口中所有抽象方法。
- 如果一个类实现了接口，但是没有重写完全部接口的全部抽象方法，这个类也必须定义成抽象类。
|
1
2
3
4
5
6
7
8
9
10
11
12
|
//实现接口的格式：
修饰符 class 类名 implements 接口名 {
// 实现接口中的所有抽象方法
void eat(){}
}
// 多实现的格式：
修饰符 class 类名 implements 接口1,接口2,接口3...{
// 抽象方法
void eat();
....
}
|
接口中的主要成分
我们这里先讲述在JDK8之前，接口中的成分包含：抽象方法和常量
抽象方法：
接口中的抽象方法默认会自动加上public abstract修饰程序员无需自己手写！！
按照规范：以后接口中的抽象方法建议不要写上public abstract，为什么呢？因为没有必要啊，默认会加上。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
|
package src.com.na.pojo;
/**
* 先定义一个接口父类 --> 动物类
* 动物都有一个吃的抽象方法
*/
public interface Animal {
// 定义为抽象方法后，无需去做方法实体的实现！
// 默认修饰符就是public abstract 可以忽略不写！
// public abstract void eat();
// 这种写法也可以，默认忽略了public abstract
void eat();
}
|
常量：
在接口中，我们定义的成员变量默认会加上： public static final修饰。
这代表了什么，在接口中定义的成员变量实际上是一个常量，而我们知道被final关键字修饰的变量是不可被修改，并且也被static静态化修饰了变量，这意味着我们可以直接用接口名访问。
而我们在定义成员变量即常量必须要给初始值。
|
1
2
3
4
5
6
7
8
9
10
11
|
package src.com.na.pojo;
/**
* 先定义一个接口父类 --> 动物类
* 动物都有一个吃的抽象方法
*/
public interface Animal {
// 定义成员变量是常量
// 默认修饰符就是public static final 可以忽略不写！
// public static final String NAME = "动物";
String NAME = "动物";
}
|
注意：常量命名规范建议字母全部大写，多个单词用下划线连接。即ANIMAL_NAME
接口的案例
我们这次以运动员为例吧，这苏神，看得我心血来潮，这不比什么博人传、奥特曼来的热血多了吗。
定义运动员接口
|
1
2
3
4
5
6
7
8
9
10
11
12
13
|
package src.com.na.pojo;
/**
* 定义一个运动员接口类，运动员可以分很多种：比如田径运动员，举重运动员，乒乓球运动员等。
* 定义了这些运动员之间的一些规范。
*/
public interface SportMan {
// 例如：运动员，都可以运动，都有对应的项目吧
void project();
// 运动员都会有比赛成绩，结果吧。
void performance();
// 运动员都会参加什么比赛得到什么奖吧，排在第几位吧！
String competition(String project);
}
|
定义田径运动员子类去实现运动员接口
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
|
package src.com.na.pojo;
/**
* 定义一个田径运动员，苏神 yyds！ 9.83s
*/
public class AthleticsMan implements SportMan{
/*
实现接口后，必须重写里面的所有抽象方法！！！
*/
@Override
public void project() {
System.out.println("苏神参加了奥运会100米项目！！");
}
@Override
public void performance() {
System.out.println("苏神创造了历史，代表亚洲人可以冲进100米决赛，踏进决赛！并创造了亚洲记录9.83s!!!!");
}
@Override
public String competition(String project) {
return "苏炳添参加"+project+"得到第六名！yyds!!!";
}
}
|
定义测试类：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
|
package src.com.na;
import src.com.na.pojo.AthleticsMan;
/**
* 测试接口
*/
public class Demo {
public static void main(String[] args) {
AthleticsMan suBingTian = new AthleticsMan();
suBingTian.project();
suBingTian.performance();
System.out.println(suBingTian.competition("100米"));
}
}
|
结果：
苏神参加了奥运会100米项目！！
苏神创造了历史，代表亚洲人可以冲进100米决赛，踏进决赛！并创造了亚洲记录9.83s!!!!
苏炳添参加100米得到第六名！yyds!!!
接口与接口的关系
我们知道类与类之间可以有继承关系，而我们接口与类之间是实现关系，那么接口与接口之间的关系呢？
在Java中，接口与接口之间是可以多继承的：也就是一个接口可以同时继承多个接口。相当于在继承中，将其他接口其他接口的抽象方法与本接口进行了合并。
代码如下：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
|
package src.com.na;
public class Demo2 {
}
// run接口
interface Run{
void run();
}
interface Project{
void Project();
}
/*
* 总结：
* 接口与类之间是多实现的。
* 接口与接口之间是多继承的。
* */
interface SportMan2 extends Run , Project {
String competition(String project); // 抽象方法，比赛。
}
|
JDK 8之后的接口新增方法
在JDK 8开始之后，接口似乎变得不再纯洁了！
接口中不再只是抽象方法，接口还可以有默认方法（也就是实例方法），和静态方法了，还包含了私有实例方法和私有静态方法
1. 含有默认方法和静态方法
- 默认方法：使用 default 修饰，不可省略，供子类调用或者子类重写。
- 静态方法：使用 static 修饰，供接口直接调用。
代码如下：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
|
package src.com.na.pojo;
/**
* 测试接口中可以含有默认方法和静态方法
*/
public interface InterfaceTest {
// 含有默认方法，default关键字
public default void defaultMethod() {
System.out.println("默认方法");
}
// 含有静态方法，static关键字
public static void staticMethod() {
System.out.println("静态方法");
}
}
|
2. 含有私有方法和私有静态方法
- 私有方法：使用 private 修饰，供接口中的默认方法或者静态方法调用。
- 私有静态方法：使用 private 修饰，使用 static 修饰。
代码如下：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
|
package src.com.na.pojo;
/**
* 测试接口中可以含有私有方法和私有静态方法
*/
public interface InterfaceTest2 {
// 含有私有方法，private修饰
private void privateMethod() {
System.out.println("私有方法");
}
// 含有私有静态方法，static关键字,private修饰
private static void privateStaticMethod() {
System.out.println("私有静态方法");
}
}
|
接口的特点：
- 接口中的方法全是抽象方法，默认会自动加上public abstract修饰。
- 接口中，无法定义成员变量，但是可以定义常量，其值不可以改变，默认使用public static final修饰。
- 接口中，没有构造器，所以是不能创建对象滴！
- 类与接口之间的关系是多实现的。
- 接口与接口之间关系是多继承的。
- 接口更多体现的是一种规范。
- JDK 8开始，接口不再纯洁，支持静态方法，默认方法，私有方法。
总结
相信各位看官都对Java基础中的抽象和接口的知识和使用有了一定了解，等待下一次更多Java基础的学习吧！
本篇文章就到这里了，希望能给你带来帮助，也希望您能够多多关注服务器之家的更多内容！
原文链接：https://blog.csdn.net/weixin_45766180/article/details/119336315