如果子类中有与父类中同名的成员变量    然后调用子类对象的函数（此函数继承于父类 未覆盖） 那么 函数调用的是子类的成员变量还是父类的

1. class A
   
2. {
   
3.         static int x=10;
   
4.         public static int mun(int m)
   
5.         {
   
6.                 return x+m;
   
7.         }
   
8. }
   
9. 
   
10. public class text extends A{
    
11.         static int x=15;
    
12.         public static void main(String args[]){
    
13.                 System.out.println(mun(6));
    
14.         }
    
15. }

复制代码

运行结果是   16   说明调用mun方法传人6 是和父类中的变量x相加返回的。。。。

如果子类没有父类的那个方法，那么就用父类的，并且调用方法时应该是  父类名.方法();
一般是自动省略父类名的像楼上的例子就是 A.mun(6)   省略了A

如果子类有，那就是重写了。。。。当然调用子类的

class demo extends A
{
        int age=3;//同名的成员变量
        public static void main(String[] args)
        {
                demo d=new demo();
                d.show();//调用父类继承的show()函数
        }
}
class A
{
        int age=4;//父类的成员变量.
        public void show()
        {
                System.out.println(this.age);  //输出本类中的age的值
        }
}
输出结果:4

我总结过了，只有非静态方法，在运行时，才看右边，就是看子类。。。
其他所有情况，无论在编译还是运行，都看左边，就是看父类。。。

子类没有覆盖父类的方法，子类对象调用继承自父类中的方法调用的就是父类中的成员变量。

public class Test18 {
        public static void main(String[] args) {
                Fu z = new Zi();
                z.show();
        }

}
class Fu
{
        int x =2;//该变量只作用于父类
        public void show()
        {
                int x=3;//局部变量在作用于方法内
                System.out.println(x);此处x=3
                System.out.println(this.x);//调用的是该类的成员变量,此处的x=2
        }
}
class Zi extends Fu
{
       
        int x =4;//该变量只作用于子类中
        public void show()
        {
                int x=3;//局部变量只作用于方法中
                System.out.println(x);
                System.out.println(super.x);//调用的是父类的成员变量，注：当父类和子类有相同的变量名时，通过super和this来区分
                System.out.println(this.x);//调用的是该类的成员变量
        }
}
输出结果是
3
2
4

1. class A{
   
2.         String a = "我是父类成员变量。";
   
3.         public void show(){
   
4.                 System.out.println(this.a);
   
5.                 System.out.println(a);
   
6.         }
   
7. }
   
8. 
   
9. class B extends A{
   
10.         String a = "我是子类成员变量。";
    
11.         public static void main(String[] srgs){
    
12.                 B b = new B();
    
13.                 b.show();
    
14.                 System.out.println(b.a);
    
15.         }
    
16. }

复制代码

运行程序的结果是：

我是父类成员变量。
我是父类成员变量。
我是子类成员变量。

由此可以看出，当子类没有重写父类的方法时，程序运行时是父类的方法调用父类的成员变量。
若是重写了方法，代码如下：

1. class A{
   
2.         String a = "我是父类成员变量。";
   
3.         public void show(){
   
4.                 System.out.println(this.a);
   
5.                 System.out.println(a);
   
6.         }
   
7. }
   
8. 
   
9. class B extends A{
   
10.         String a = "我是子类成员变量。";
    
11.         public void show(){
    
12.                 System.out.println(this.a);
    
13.                 System.out.println(a);}
    
14.        
    
15.         public static void main(String[] srgs){
    
16.                 B b = new B();
    
17.                 b.show();
    
18.                 //new A().show();
    
19.                 System.out.println(b.a);
    
20.         }
    
21. }

复制代码

结果是：
我是子类成员变量。
我是子类成员变量。
我是子类成员变量。

可见，子类重写了父类方法后，才会在调用的时候使用子类成员变量。