public class MyInterfaceAbstractImpl implements MyInterfaceAbstract {
@Override
public void methodAbs1() {
System.out.println("这是第一个方法！");
}
@Override
public void methodAbs2() {
System.out.println("这是第二个方法！");
}
@Override
public void methodAbs3() {
System.out.println("这是第三个方法！");
}
@Override
public void methodAbs4() {
System.out.println("这是第四个方法！");
}
}
Demo01Interface.java
text
1
2
3
4
5
6
7
8
9
10
11
12
13
public class Demo01Interface {
public static void main(String[] args) {
// 错误写法！不能直接new接口对象使用。
// MyInterfaceAbstract inter = new MyInterfaceAbstract();
// 创建实现类的对象使用
MyInterfaceAbstractImpl impl = new MyInterfaceAbstractImpl();
impl.methodAbs1();
impl.methodAbs2();
}
}
四、接口的默认方法
从java 8开始，接口里允许默认方法
格式：
text
1
2
3
public default 返回值类型 方法名称(参数列表){
//方法体
}
接口的默认方法，可以通过接口实现类对象，直接调用。
接口的默认方法，也可以被接口实现类进行覆盖重写。
备注：接口当中的默认方法，可以解决接口升级的问题。
MyInterfaceDefault.java
text
1
2
3
4
5
6
7
8
9
10
11
12
13
public interface MyInterfaceDefault {
//抽象方法
public abstract void methodAbs();
//新添加一个抽象方法，会导致两个实现类报错
//public abstract void methodAbs2();
//为了解决上面的问题，需要将新添加的方法，改成默认方法。public省略不写，也会默认为public
public default void methodDefault() {
//一定要将这个大括号写上
System.out.println("这是新添加的默认方法");
}
}
MyInterfaceDefaultA.java
text
1
2
3
4
5
6
7
8
9
public class MyInterfaceDefaultA implements MyInterfaceDefault {
@Override
public void methodAbs() {
// TODO Auto-generated method stub
System.out.println("实现了抽象方法，AA");
}
}
MyInterfaceDefaultB.java
text
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
public class MyInterfaceDefaultB implements MyInterfaceDefault {
@Override
public void methodAbs() {
// TODO Auto-generated method stub
System.out.println("实现了抽象方法，BB");
}
@Override
public void methodDefault() {
// TODO Auto-generated method stub
System.out.println("实现类B覆盖重写了接口的默认方法");
}
}
public class MyInterfaceImpl implements MyInterfaceA,MyInterfaceB{
//覆盖重写所有抽象方法
}
如果实现类所实现的多个接口当中，存在重复的抽象方法，那么只需要覆盖重写一次即可
如果实现类没有覆盖重写所有接口当中的所有抽象方法，那么实现类就必须是抽象类
如果实现类实现的多个接口当中，存在重复的默认方法，那么实现类一定要对冲突的默认方法进行覆盖重写
一个类，如果直接父类当中的方法，跟接口当中继承的方法产生了冲突，优先用父类当中的方法。
MyInterfaceA.java
text
1
2
3
4
5
6
7
8
9
public interface MyInterfaceA {
public abstract void methodA();
public abstract void methodAbs();
public default void methodDefault() {
System.out.println("默认方法AAA");
}
}
MyInterfaceB.java
text
1
2
3
4
5
6
7
8
public interface MyInterfaceB {
public abstract void methodB();
public abstract void methodAbs();
public default void methodDefault() {
System.out.println("默认方法BBB");
}
}
MyInterfaceAbstract.java
text
1
2
3
4
5
6
7
8
public abstract class MyInterfaceAbstract implements MyInterfaceA,MyInterfaceB {
@Override
public void methodDefault() {
System.out.println("不管抽不抽象，有冲突，都得重写");
}
}
