Java中父类和接口或接口和接口中出现同名属性或同名同参数方法时，如何区分(全文干货)

1.父类和接口中出现同名属性

/**
 * @Author: YuShiwen
 * @Date: 2020/11/19 12:35 PM
 * @Version: 1.0
 */
interface InterfaceA{
    int number = 0;
}

class SuperClass{
    int number = 1;
}

public class ClassA extends SuperClass implements InterfaceA{
    public void printNumber(){
    	//如果子类没有定义同名的属性，number是不明确的，编译不通过。
        //System.out.println(number);

        //通过super.调用父类中的属性number
        System.out.println(super.number);
        //通过接口名.调用接口中的属性number
        System.out.println(InterfaceA.number);
    }

    public static void main(String[] args) {
        new ClassA().printNumber();
    }
}


  

 

  
1
  
2
  
3
  
4
  
5
  
6
  
7
  
8
  
9
  
10
  
11
  
12
  
13
  
14
  
15
  
16
  
17
  
18
  
19
  
20
  
21
  
22
  
23
  
24
  
25
  
26
  
27
  
28
  
29
 

输出结果：

1
0

Process finished with exit code 0


  

 

  
1
  
2
  
3
  
4
  
5
 

2.父类和接口中出现同名方法

我们这里只讨论接口中的静态方法和默认方法，不讨论接口中的抽象方法，
因为接口中的抽象方法实现类(子类)需要重写，所以调用的是子类重写的方法，这里不讨论接口中的抽象方法

/**
 * @Author: YuShiwen
 * @Date: 2020/11/19 12:49 PM
 * @Version: 1.0
 */
interface InterfaceMethod{
    //静态方法
    public static void hobby(){
        System.out.println("我喜欢健身！");
    }
    //默认方法
    public default void drink(){
        System.out.println("口渴了，喝饮料！");
    }

    public default void eat(){
        System.out.println("吃汉堡！");
    }
}

class ClassMethod{
    public void hobby(){
        System.out.println("我喜欢跑步！");
    }

    public void drink(){
        System.out.println("口渴了，喝水！");
    }

    public void eat(){
        System.out.println("吃饭！");
    }
}
public class ClassB extends ClassMethod implements InterfaceMethod{

    public void eat(){
        System.out.println("吃牛排！");
    }

    public void printMethod(){
        //不存在指定不明确情况，如果子类没有重写覆盖该方法，直接是父类中的方法；
        // 因为接口中定义的静态方法，只能通过接口来调用。
        hobby();//也可以写成super.hobby();

        //接口中定义的静态方法，只能通过接口来调用。
        InterfaceMethod.hobby();

        //如果子类(或实现类)继承的父类和实现的接口中声明了同名同参数的默认方法，
        //那么子类在没有重写此方法的情况下，默认调用的是父类中的同名同参数的方法。
        //类优先原则
        drink();
        //接口中的方法
        InterfaceMethod.super.drink();

        //子类有重写此方法的情况
        //子类
        eat();
        //父类
        super.eat();
        //调用接口中的默认方法
        InterfaceMethod.super.eat();
    }

    public static void main(String[] args) {
        new ClassB().printMethod();
    }
}


  

 

  
1
  
2
  
3
  
4
  
5
  
6
  
7
  
8
  
9
  
10
  
11
  
12
  
13
  
14
  
15
  
16
  
17
  
18
  
19
  
20
  
21
  
22
  
23
  
24
  
25
  
26
  
27
  
28
  
29
  
30
  
31
  
32
  
33
  
34
  
35
  
36
  
37
  
38
  
39
  
40
  
41
  
42
  
43
  
44
  
45
  
46
  
47
  
48
  
49
  
50
  
51
  
52
  
53
  
54
  
55
  
56
  
57
  
58
  
59
  
60
  
61
  
62
  
63
  
64
  
65
  
66
  
67
  
68
 

输出结果：

我喜欢跑步！
我喜欢健身！
口渴了，喝水！
口渴了，喝饮料！
吃牛排！
吃饭！
吃汉堡！

Process finished with exit code 0


  

 

  
1
  
2
  
3
  
4
  
5
  
6
  
7
  
8
  
9
  
10
 

3.接口和接口中出现同名属性

/**
 * @Author: YuShiwen
 * @Date: 2020/11/19 1:19 PM
 * @Version: 1.0
 */
interface InterfacePropertyA{
    public static final int number = 0;
}

interface InterfacePropertyB{
    int number = 1;
}
public class ClassC implements InterfacePropertyA,InterfacePropertyB{
    public static void main(String[] args) {
        ClassC classC = new ClassC();
        //如果子类没有定义同名的属性，classC.number指定不明确
        //System.out.println(classC.number);

        System.out.println(InterfacePropertyA.number);
        System.out.println(InterfacePropertyB.number);

    }
}

  

 

  
1
  
2
  
3
  
4
  
5
  
6
  
7
  
8
  
9
  
10
  
11
  
12
  
13
  
14
  
15
  
16
  
17
  
18
  
19
  
20
  
21
  
22
  
23
 

输出结果：

0
1

Process finished with exit code 0


  

 

  
1
  
2
  
3
  
4
  
5
 

4.接口和接口中出现同名方法

首先接口中定义的静态方法，只能通过接口来调用，出现同名同参数静态方法只需要用接口进行调用即可。
其次接口中的抽象方法，没有方法体，需要实现类重写，调用时肯定是实现类中重写的方法。
如果实现类实现了多个接口，而这多个接口中定义了同名同参数的默认方法，那么在实现类没有重写此方法的情况下，报错。接口冲突。这就需要我们必须在实现类中重写此方法。

文章来源: blog.csdn.net，作者：Mr.Yushiwen，版权归原作者所有，如需转载，请联系作者。

原文链接：blog.csdn.net/MrYushiwen/article/details/109808022