继承

最新推荐文章于 2025-08-06 16:23:50 发布

ticojj

最新推荐文章于 2025-08-06 16:23:50 发布

阅读量100

点赞数

CC 4.0 BY-SA版权

分类专栏： java 文章标签： java

本文链接：https://blog.youkuaiyun.com/ticojj/article/details/84549838

java 专栏收录该内容

8 篇文章

订阅专栏

本文探讨了Java中多态的特性，特别是方法重写而非属性重写的概念，并通过实例展示了如何在继承结构中正确访问属性及调用方法。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

1.class Foo {   
2.    public int a;   
3.  
4.    public Foo() {   
5.        a = 3;   
6.    }   
7.  
8.    public int addFive() {   
9.        a += 5;   
10.        return a;   
11.    }   
12.  
13.    public int getA() {   
14.        return a;   
15.    }   
16.}   
17.  
18.public class Bar extends Foo {   
19.    public int a;   
20.  
21.    public Bar() {   
22.        a = 8;   
23.    }   
24.  
25.    public int addFive() {   
26.        this.a += 5;   
27.        return a;   
28.    }   
29.  
30.    public int getA() {   
31.        return a;   
32.    }   
33.  
34.    public static void main(String[] args) {   
35.        Foo foo = new Bar();   //foo.a=3,bar.a=8   
36.        //调用的是子类中的方法   
37.        System.out.println(foo.getA());   
38.        //直接调用父类中的a   
39.        System.out.println("Value: " + foo.a);  //foo.a=3,bar.a=13   
40.        //调用的是子类中的方法   
41.        System.out.println(foo.addFive());  //bar.a=8+5 
42.           
43.    }   
44.}

父类中的a和子类中的a是两个不同的成员变量，同时存在的，不会出现覆盖的现象。

输出结果：
8
Value: 3
13

楼主，只需要明白一点就行了：在Java中重写指的是方法的重写，而不是属性的重写，还有多态也只是方法的多态，没有属性的多态。

注意：这句 Foo foo = new Bar();创建了一个Bar对象
一个对象创建的过程分成4步：
1.分配总空间
2.递归创建父类对象
3.调用本类构造方法
4.初始化本类属性；
还有第2点其实是创建了父类的属性和方法,并没有创建父类对象,用人们的眼光来把它
单独拿出来看,像是创建了父类对象似的;
父类的除private方法以外的方法都被子类所继承.并且覆盖但是属性却没有被覆盖,所以foo.a 访问的是父类的属性,而 foo.addFive(); 调用的是子类覆盖父类的 addFive()方法,既然调用的是子类的方法,所以这个方法修改的是子类属性的值

其实去看Debug View的内存树会比较清楚

在子类中调用父类同名属性可以这样写super.a

---------------------------

class Base{  
   public int a;  
   public static int b;  
   public Base(){  
     a=1;  
     b=1;  
   }  
   public void addFivetoa(){  
    a+=5;  
   }  
   public static void addSixtob(){  
    b+=6;  
   }  
}  
public class Son extends Base{  
  //public int a;  
  //public static int b;  
  public Son(){  
   a=2;  
   b=2;  
  }  
public void addFivetoa(){  
   a+=5;  
  }  
public static void addSixtob(){  
   b+=6;  
}  
public static void main(String args[]){  
Son son = new Son();  
Base base = son;  
base.addFivetoa();  
base.addSixtob();  
System.out.println(base.a);//7  
System.out.println(base.b);//8  
System.out.println(son.a);//7  
System.out.println(son.b);//8  
}  
}  

过程：先初始化Base的b为0，然后调用父类的构造方法初始化a=1，b=1，然后调用Son的构造方法初始化a=2，b=2； 
base.addFivetoa();//a=7;调用的子类的 
base.addSixtob();//b=8；调用的父类的 
属性是不能多态的，静态方法也不能多态。 
图示： 
[img] http://dl.iteye.com/upload/attachment/146753/1c112269-254f-3f9e-9bd4-afa547d99cd3.jpg[/img] 

衍生： 
Java代码 
class Base{  
   public int a;  
   public static int b;  
   public Base(){  
     a=1;  
     b=1;  
   }  
   public void addFivetoa(){  
    a+=5;  
   }  
   public static void addSixtob(){  
    b+=6;  
   }  
}  
public class Son extends Base{  
  public int a;  
  public static int b;  
  public Son(){  
   a=2;  
   b=2;  
  }  
public void addFivetoa(){  
   a+=5;  
  }  
public static void addSixtob(){  
   b+=6;  
}  
public static void main(String args[]){  
Son son = new Son();  
Base base = son;  
base.addFivetoa();  
base.addSixtob();  
System.out.println(base.a);//1  
System.out.println(base.b);//7  
System.out.println(son.a);//7  
System.out.println(son.b);//2  
}  
}

0 0

class Base{
   public int a;
   public static int b;
   public Base(){
     a=1;
     b=1;
   }
   public void addFivetoa(){
    a+=5;
   }
   public static void addSixtob(){
    b+=6;
   }
}
public class Son extends Base{
//public int a;
//public static int b;
public Son(){
   a=2;
   b=2;
}
public void addFivetoa(){
   a+=5;
}
public static void addSixtob(){
   b+=6;
}
public static void main(String args[]){
Son son = new Son();
Base base = son;
base.addFivetoa();
base.addSixtob();
System.out.println(base.a);//7
System.out.println(base.b);//8
System.out.println(son.a);//7
System.out.println(son.b);//8
}
}

过程：先初始化Base的b为0，然后调用父类的构造方法初始化a=1，b=1，然后调用Son的构造方法初始化a=2，b=2；
base.addFivetoa();//a=7;调用的子类的
base.addSixtob();//b=8；调用的父类的
属性是不能多态的，静态方法也不能多态。
图示：
[img] http://dl.iteye.com/upload/attachment/146753/1c112269-254f-3f9e-9bd4-afa547d99cd3.jpg[/img]

衍生：
Java代码
class Base{
   public int a;
   public static int b;
   public Base(){
     a=1;
     b=1;
   }
   public void addFivetoa(){
    a+=5;
   }
   public static void addSixtob(){
    b+=6;
   }
}
public class Son extends Base{
public int a;
public static int b;
public Son(){
   a=2;
   b=2;
}
public void addFivetoa(){
   a+=5;
}
public static void addSixtob(){
   b+=6;
}
public static void main(String args[]){
Son son = new Son();
Base base = son;
base.addFivetoa();
base.addSixtob();
System.out.println(base.a);//1
System.out.println(base.b);//7
System.out.println(son.a);//7
System.out.println(son.b);//2
}
}

过程：先初始化Base的b为0，然后调用父类的构造方法初始化a=1，b=1，然后调用Son的构造方法初始化子类中的a和b，a=2，b=2；
base.addFivetoa();//调用子类的方法，son.a=7
base.addSixtob();//调用父类的方法，base.b=1+6=7
剩下的base.a和son.b都没有变化所以分别为1，2。
其中加粗红色的1是父类的b的值，base.addSixtob()(是静态的)所以要调用addSixtob()所在类base的b的值也就是，或者说是base对象调用了addSixtob()，所以要访问base对象所在类的b值。