A类调用B类方法，B类方法中调用了其他的方法，此时A也重写了此方法，那么A对象最终调用谁的？

本文链接：https://blog.csdn.net/qq_41238794/article/details/138787633

A类调用B类方法，此时B类方法中调用了其他的方法，但是A也重写了它，那么最终调用谁的？

`答案：调用A的`

问题描述

继承关系代码结构如下：

class A extends B{
    @Override
    public void fun1(){  //3. 但是A也重写了它  重写父类fun1方法 
        System.out.println("A fun1");  
    }
    @Override
    public void fun(){
        super.fun();  //1. A类调用B类方法 调用父类的fun()方法
    }
}
class B{
    public void fun(){
        System.out.println("B fun");
        fun1();         //2. 此时B类方法中调用了其他的方法 此时调用谁的呢？
        this.fun1();   //这个又调用谁的呢？

    }
    public void fun1(){
        System.out.println("B fun1"); 
    }
}

运行结果：

  public static void main(String[] args) {
        B a=new A();  
        a.fun();//调用a方法
    }

运行的结果是：
B fun
A fun1
A fun1

原因分析：

为什么？为什么在B类中的方法调用自身的方法结果是调用A的？？

那是因为当 A 类的对象调用 B 类的 fun() 方法时，实际上是通过 A 类的方法来调用的，因为 A 类继承了 B 类，并且没有重写 B 类中的 fun() 方法。
在 B 类的 fun() 方法中，有两个调用 fun1() 方法的地方：一个是直接调用 fun1()，另一个是通过 this.fun1() 调用。在这两种情况下，this 关键字都指向当前对象，即 A 类的一个实例。
由于 A 类重写了 fun1() 方法，因此在调用 this.fun1() 时，会根据对象的实际类型来决定调用哪个版本的 fun1() 方法。在这个情况下，对象的实际类型是 A 类，所以调用的是 A 类中的 fun1() 方法。
因此，不管是 fun1() 还是 this.fun1()，在这个上下文中都调用的是 A 类中的 fun1() 方法。

如果重写后两个都想用怎么办？：

方法一：写一块

例如：新建一个 Message 对象，并将读取到的数据存入 Message，然后 mHandler.obtainMessage(READ_DATA, bytes, -1, buffer).sendToTarget();换成 mHandler.sendMessage()。

 @Override
    public void fun1(){
        super.fun1();
        System.out.println("A fun1");
    }

方法二：A中专门定义一个方法调用 (其实没什么意义)

  public void  cellBFun1(){
        super.fun1();
   }

此时又有问题了如果是字段(即成员变量)呢？：

我们在AB类中分别加入：
A 中 public String s =“aaa”;
B中 public String s =“bbb”;
然后进行如下的执行：

//  B类中打印s这个字段的值
   public void fun3(){
        System.out.println(s);
        System.out.println(this.s);
    }
//此时A类中没有重写(覆写)fun3

那么此时输出的谁的呢？

运行的结果是：
bbb
bbb

为什么？
因为方法有重写但是字段没有重写

如果是静态的呢？：

我们在AB类中分别加入：
A 中 public String s =“aaa”;
B中 public String s =“bbb”;
然后进行如下的执行：

//main()中
B a =new A();//把A类对象用父类类型接收  看看它自己调用的谁的方法和字段

//类中
class A extends B{
    public static String ss="AAAAA";
    public static void staticFun(){
        System.out.println("A  staticFun");
    }
    @Override
    public void fun(){
       System.out.println(ss); //可以看出调用的是B自己的
    	staticFun(); 
        super.fun();
    }

}
class B{
    public static String ss="BBBBB";
   public void fun(){
   //输出静态字段
        System.out.println(ss); //可以看出调用的是B自己的
      //  System.out.println(A.ss);  //如果想用A的就类名.调用
    //输出静态方法
         staticFun();//可以看出调用的是B自己的
     //   A.staticFun();//如果想用A的就类名.调用
    }
    public static void staticFun(){
        System.out.println("B  staticFun");
    }
}

那么此时输出的谁的呢？

运行的结果是：
AAAAA
A staticFun
BBBBB
B staticFun
此时会发现字段没啥区别，各用各的，但是静态咋不用类A的呢？为什么和非静态的不一样呢？
静态是和类一起创建的，我们自己定义的类的class实例大都是在你第一次使用类的时候创建的，此时创建也会把静态字段，方法分配空间并创建。静态代码块的话会直接执行。
简单的来说就是静态的是类的，需要类名.调用，在类中的话可以省去。