目录
一:接口
(1)理解
在实际生活中,接口非常常见。比如在使用电脑,手机或者其他家电,给他们插电时,插头都能插到插/座孔中,这些插孔/座都能称之为接口。可是,这些家电在生产之前制造商并没有沟通插头与插座的型号问题,但是用的时候却都可以用(国内的家电在国内可以正常使用)。
由此可见,接口是一种公共的规范。
在Java中,也是这样:接口就是多个类的公共规范;
(2)定义格式:
public interface 接口名(){
接口内容;
}
接口是引用数据类型,最重要的是其中的 抽象方法 ;
当然,对于不同的JDK版本,其可容纳的内容一般不同,这里不做解释了。
(3)注意事项
1.抽象类的修饰符必须是 public abstract ;
2.这两个关键字可以省略不写,也可以省略其中一个;
二:接口的实现:
2.1 接口的一般使用
(1)接口类不能直接创建接口对象进行访问,必须有一个 “实现类” 来 “实现” (类比于抽象类必须有一个继承对象来间接访问);
(2) 接口的实现类必须覆盖重写接口所有的抽象方法(覆盖重写与抽象类中子类的覆盖重写原则相同,即去掉 abstract , 鼠标放在报错代码处,Alt+Enter,选择实现方法 即可 自动实现);
(3)如果实现类没有覆盖重写接口的所有抽象方法,那么它必须是抽象类;
下面是一个普通接口的案例:
接口有两个抽象方法,实现类实现接口,并覆盖重写所有抽象方法,测试类中创建实现类对象,来访问实现类的抽象方法;
package Interface01;
public interface MyInterface {
//接口中主要是 抽象方法
//public abstract可以省略不写
public void eat();
void sleep();
}
package Interface01;
public class MyInterfaceImplement implements MyInterface {
@Override
public void eat() { //重写接口方法 eat
System.out.println("好好吃饭饭");
}
@Override
public void sleep() { //重写接口方法 sleep
System.out.println("睡觉觉也是很好的事情");
}
}
package Interface01;
public class MyInterfaceDemo {
public static void main(String[] args) {
MyInterfaceImplement m=new MyInterfaceImplement();
m.sleep();
m.eat();
}
}
C:\Java\jdk-17.0.11\bin\java.exe "-javaagent:C:\Program Files\JetBrains\IntelliJ IDEA 2022.1.3\lib\idea_rt.jar=10335:C:\Program Files\JetBrains\IntelliJ IDEA 2022.1.3\bin" -Dfile.encoding=UTF-8 -classpath C:\Test\classDemo\out\production\classDemo Interface01.MyInterfaceDemo
睡觉觉也是很好的事情
好好吃饭饭
进程已结束,退出代码0
2.2 接口的默认方法
背景:如果一个接口有很多实现类,我们又需要在接口中添加一个方法,这样的话我们必须在许多实现类中覆盖重写新添加的方法,这会非常麻烦。那么我们可不可以在不改变许多实现类的情况下,仍然能访问新添加的方法呢?
默认方法 可以解决这个问题:
定义格式:public default void 方法名(){
方法体
}
案例演示:
有一个接口为 MyInterface ,有两个实现类 MyInterfaceImplement , MyInterfaceImplement02 ,还有一个测试类 MyInterfaceDemo;
其中,MyInterfaceImplement 实现类直接访问接口新增的默认方法,MyInterfaceImplement02 实现类覆盖重写了接口新增的默认方法;
代码如下:
package Interface01;
public interface MyInterface {
//接口中主要是 抽象方法
//public abstract可以省略不写
public void eat();
void sleep();
public default void drunk() {//接口的默认方法
System.out.println("这是接口的默认方法");
}
}
package Interface01;
public class MyInterfaceImplement implements MyInterface {
@Override
public void eat() { //重写接口方法 eat
System.out.println("好好吃饭饭");
}
@Override
public void sleep() { //重写接口方法 sleep
System.out.println("睡觉觉也是很好的事情");
}
}
package Interface01;
public class MyInterfaceImplement02 implements MyInterface{
@Override
public void eat() {
}
@Override
public void sleep() {
}
}
package Interface01;
public class MyInterfaceDemo {
public static void main(String[] args) {
MyInterfaceImplement m=new MyInterfaceImplement();
m.sleep();
m.eat();
m.drunk();//只接使用接口的默认方法
}
}
ackage Interface01;
public class MyInterfaceImplement02 implements MyInterface{
@Override
public void eat() {
System.out.println("吃吃吃,就会吃啊");
}
@Override
public void sleep() {
System.out.println("睡觉呼呼的睡啊");
}
@Override
public void drunk() {//接口的默认方法
System.out.println("接口的默认方法也可以覆盖重写哦");
}
}
package Interface01;
public class MyInterfaceDemo {
public static void main(String[] args) {
MyInterfaceImplement m=new MyInterfaceImplement();
m.sleep();
m.eat();
m.drunk();//只接使用接口的默认方法
System.out.println("============");
MyInterfaceImplement02 m2=new MyInterfaceImplement02();
m2.eat();
m2.sleep();
m2.drunk();
}
}
C:\Java\jdk-17.0.11\bin\java.exe "-javaagent:C:\Program Files\JetBrains\IntelliJ IDEA 2022.1.3\lib\idea_rt.jar=12499:C:\Program Files\JetBrains\IntelliJ IDEA 2022.1.3\bin" -Dfile.encoding=UTF-8 -classpath C:\Test\classDemo\out\production\classDemo Interface01.MyInterfaceDemo
睡觉觉也是很好的事情
好好吃饭饭
这是接口的默认方法
============
吃吃吃,就会吃啊
睡觉呼呼的睡啊
接口的默认方法也可以覆盖重写哦
进程已结束,退出代码0
2.3 接口的静态方法
有一些内容与类的对象无关,可以供类共享,这种内容就可以用 static 来定义;
格式:public static void 方法名( ){
方法体
};
访问的时候,通过接口名直接调用,与方法的对象是否创建无关;
我在前面的基础上的接口中,增添了一个静态方法 ,在测试类中使用接口名就可以直接调用;
package Interface01;
public interface MyInterface {
//接口中主要是 抽象方法
//public abstract可以省略不写
void eat();
void sleep();
public default void drunk() {//接口的默认方法
System.out.println("这是接口的默认方法");
}
public static void love(){
System.out.println("爱出者爱返,福往者福来");
};
}
package Interface01;
public class MyInterfaceDemo {
public static void main(String[] args) {
MyInterfaceImplement m=new MyInterfaceImplement();
m.sleep();
m.eat();
m.drunk();//只接使用接口的默认方法
System.out.println("============");
MyInterfaceImplement02 m2=new MyInterfaceImplement02();
m2.eat();
m2.sleep();
m2.drunk();
System.out.println("========");
MyInterface.love();//静态方法,接口名直接调用,不需要实现类对象调用
}
}
C:\Java\jdk-17.0.11\bin\java.exe "-javaagent:C:\Program Files\JetBrains\IntelliJ IDEA 2022.1.3\lib\idea_rt.jar=8357:C:\Program Files\JetBrains\IntelliJ IDEA 2022.1.3\bin" -Dfile.encoding=UTF-8 -classpath C:\Test\classDemo\out\production\classDemo Interface01.MyInterfaceDemo
睡觉觉也是很好的事情
好好吃饭饭
这是接口的默认方法
============
吃吃吃,就会吃啊
睡觉呼呼的睡啊
接口的默认方法也可以覆盖重写哦
========
爱出者爱返,福往者福来
进程已结束,退出代码0
2.4 接口的私有化方法
2.4.1普通私有方法:
其目的是降低接口中多个默认方法代码的冗余性,专门为默认方法服务,又防止其被接口实现类的对象调用造成不当使用,从而进行私有化定义;
格式:private void 方法名:( 参数列表 ){ } ;
举例演示:
我们创建了一个接口,里面有两个默认方法和一个默认方法的私有化定义;创建了一个实现类来实现它,还创建了一个测试类进行测试;
package Interface01;
public interface MyInterface {
public default void drunk() {//接口的默认方法
System.out.println("这是接口的默认方法");
DefaultCommon(); //调用默认方法的私有化方法
}
public default void love(){//接口的默认方法
System.out.println("爱出者爱返,福往者福来");
DefaultCommon(); //调用默认方法的私有化方法
}
private void DefaultCommon(){//默认方法的私有化
System.out.println("aaaaaa");
System.out.println("aaaaaa");
System.out.println("aaaaaa");
}
}
package Interface01;
public class MyInterfaceDemo {
public static void main(String[] args) {
MyInterfaceImplement02 m=new MyInterfaceImplement02();
m.love();
}
}
C:\Java\jdk-17.0.11\bin\java.exe "-javaagent:C:\Program Files\JetBrains\IntelliJ IDEA 2022.1.3\lib\idea_rt.jar=9329:C:\Program Files\JetBrains\IntelliJ IDEA 2022.1.3\bin" -Dfile.encoding=UTF-8 -classpath C:\Test\classDemo\out\production\classDemo Interface01.MyInterfaceDemo
爱出者爱返,福往者福来
aaaaaa
aaaaaa
aaaaaa
进程已结束,退出代码0
2.4.2 静态私有方法:
其目的是降低接口中多个静态方法的代码的冗余性,专门为静态方法服务,又防止其被接口直接调用造成不当使用,从而进行私有化定义;
格式:public static void 方法名:( 参数列表 ){ } ;
我们创建了一个接口,里面有两个静态方法和一个静态方法的私有化定义;创建了一个测试类进行测试;
package Interface01;
import static Interface01.MyInterface.DefaultCommon;
public interface MyInterface {
public static void drunk() {//接口的默认方法
System.out.println("这是接口的默认方法");
DefaultCommon(); //调用默认方法的私有化方法
}
public static void love(){//接口的默认方法
System.out.println("爱出者爱返,福往者福来");
DefaultCommon(); //调用默认方法的私有化方法
}
static void DefaultCommon(){//默认方法的私有化
System.out.println("aaaaaa");
System.out.println("aaaaaa");
System.out.println("aaaaaa");
}
}
package Interface01;
public class MyInterfaceDemo {
public static void main(String[] args) {
MyInterface.love();//接口名直接调用静态方法
}
}
2.5 接口的常量定义
前面说了,接口中重要的内容是抽象方法,那么可不可定义变量呢?答案是肯定的,只不过所谓的” 变量 “只能是常量。
规则:public static final 数据类型 常量名 = 数值;由于 final 的存在,其定义时必须赋值,且一旦赋值后不能改变;
由于是 static 修饰的,所以使用 类名 直接访问即可;
注意:(1) 变量名尽量全部大写,不同单词间使用下划线隔开,如:
public static static int CLASS_NUMBER = 6 ;
(2) public static final 是默认的,可以写,也可以不写;
案例演示:
我在前面基础上的接口中定义了一个常量,在测试类中通过类名直接访问;
package Interface01;
import static Interface01.MyInterface.DefaultCommon;
public interface MyInterface {
int NUMBER=99;//定义”变量“;
public static void drunk() {//接口的默认方法
System.out.println("这是接口的默认方法");
DefaultCommon(); //调用默认方法的私有化方法
}
public static void love(){//接口的默认方法
System.out.println("爱出者爱返,福往者福来");
DefaultCommon(); //调用默认方法的私有化方法
}
static void DefaultCommon(){//默认方法的私有化
System.out.println("aaaaaa");
System.out.println("aaaaaa");
System.out.println("aaaaaa");
}
}
package Interface01;
public class MyInterfaceDemo {
public static void main(String[] args) {
MyInterface.love();//接口名直接调用静态方法
System.out.println(MyInterface.NUMBER);//访问变量
}
}