java子类继承父类问题

0 0

采纳的答案

class Foo {
	public int a;

	public Foo() {
		a = 3;
	}

	public int addFive() {
		a += 5;
		return a;
	}

	public int getA() {
		return a;
	}
}

public class Bar extends Foo {
	public int a;

	public Bar() {
		a = 8;
	}

	public int addFive() {
		this.a += 5;
		return a;
	}

	public int getA() {
		return a;
	}

	public static void main(String[] args) {
		Foo foo = new Bar();
		//调用的是子类中的方法
		System.out.println(foo.getA());
		//直接调用父类中的a
		System.out.println("Value: " + foo.a);
		//调用的是子类中的方法
		System.out.println(foo.addFive());
		
	}
}

输出结果：
8
Value: 3
13

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

2009年9月14日 09:25

walsh
967
0 0 1

添加评论

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值。
图示：

2009年9月18日 17:48

red_xie
0
0 0 2

添加评论

0 0

Foo foo = new Bar();
就相当于Foo foo = new Foo();没什么区别！！

2009年9月18日 17:11

Sonnow
1
0 0 0

添加评论

0 0

受教了，好好学习。

2009年9月18日 16:16

zhong_wei_hu
31
0 0 0

添加评论

0 0

不好意思，说错了。谢谢上面的纠正

2009年9月18日 10:32

jakend
8
0 0 0

添加评论

0 0

引用

Foo foo = new Bar(); 此时，new的虽然是Bar()的实力，但是在内存看到的只是父类的方法跟属性，与子类无关。所以，a的值为3。

子类的方法，父类的属性

2009年9月18日 10:25

蔡华江
3392
0 0 0

添加评论

0 0

Foo foo = new Bar(); 此时，new的虽然是Bar()的实力，但是在内存看到的只是父类的方法跟属性，与子类无关。所以，a的值为3。

2009年9月18日 10:23

jakend
8
0 0 0

添加评论

0 0

Foo foo = new Bar();    //foo.a=3,bar.a=8
foo.addFive();          //bar.a=8+5
System.out.println("Value: "+ foo.a);  //foo.a=3,bar.a=13

这也是隐藏域，提供setter/getter的一个原因吧。

2009年9月17日 15:29

ldinh
30
0 0 0

添加评论

0 0

父类中的a和子类中的a是两个不同的成员变量，同时存在的，不会出现覆盖的现象。
Foo foo = new TestEYE1(); //调用父类构造。
此时，foo虽然是TestEYE1，但是它是被当作Foo来执行的。
所以它的一些TestEYE1属性全部都被禁用。但是堆中存在这些属性。
当调用
foo.addFive();   方法时，由于子类对父类的方法重写，执行子类的方法，
this.a +=5; 其中this可以不加的，默认的就是调用本类（TestEYE1）的成员变量。

最后打印foo.a，foo虽然有两个a成员变量，但是因为它现在是Foo身份，所以子类的a是禁用的，但是它还是存在的，只要身份变成TestEYE1，就会打印子类的a属性。看第二次打印的结果就知道了。
System.out.println("Value: "+ foo.a);
System.out.println("Value: "+ ((TestEYE1)foo).a);

这个题目，如果楼主觉得混要，有一个简单的方法，把子类的a全改成b，就知道了。
因为对计算机而言，这两个成员变量就算是名字相同，它也认为不同的。
只要明白，这两个成员变量都存在就好理解了~

2009年9月16日 13:43

rachel_g
30
0 0 0

1条评论

0 0

分析得都很好，学习了

2009年9月16日 09:55

moses3017
4
0 0 2

添加评论

0 0

是的，分析得很好呢.......

2009年9月15日 09:25

kill8108
30
0 0 0

添加评论

0 0

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

2009年9月14日 22:03

paris1221
43
0 0 0

添加评论

0 0

楼上回答的很棒，方法是重写，属性不能重写。

2009年9月14日 11:16

dreamdml
18
0 0 0

添加评论

0 0

呵呵，虽然知道子类能override方法，不能override属性，但还是没做出来，羞愧。

2009年9月14日 00:04

zhangyou1010
3
0 0 4

添加评论

0 0

引用

有点值得关注的是。如果addFive返回类型改成int 之后
你打印System.out.println(foo.addFive());
的值是18，而不是13。

晕。。我用了两次 foo.addFive(); 怪不得是18.
晕到我。

2009年9月13日 13:41

Rowen
1062
0 0 0

添加评论

0 0

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

2009年9月12日 20:32

liusu
96
0 0 0

添加评论

0 0

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

2009年9月12日 14:27

网络黑侠
95
0 0 0

添加评论

0 0

主要的问题是你要理解子类重写父类方法会造成父类方法被覆盖，而属性却不是这样；
          Foo foo = new Bar();
程序运行到这一部，是实例化一个子类对象交给父类引用，在这个对象中有两个属性a，父类的属性a=3和子类自己的a=8 ，而addFive方法只有一个，那就是子类重写的addFive方法；
         foo.addFive();
这一步调用的是子类重写后的方法，所以在这里值发生改变的是子类的a而不是父类的，这时候子类的a=8+5=13，而父类的a=3没有变。
         System.out.println("Value: "+ foo.a);
foo是一个父类的引用，foo.a是父类的a当然是等于3了

2009年9月12日 14:25

网络黑侠
95
0 0 0

添加评论

0 0

Foo foo = new Bar();
像这种upcast（向上造型）
1.域：调用父类属性
2.方法：调用子类方法
这里 foo.addFive();   调用子类的方法
有点值得关注的是。如果addFive返回类型改成int 之后
你打印System.out.println(foo.addFive());
的值是18，而不是13。
至于输出的是3
就是因为第一条，调用的是父类的属性。而跟方法无关。

引用

详情见：thinking in java 4th 的例子
中文版156
英文版290

2009年9月12日 12:25

Rowen
1062
0 0 0

添加评论

0 0

Foo foo = new Bar(); //实际上实例化Foo 类中的a = 3；
foo.addFive(); //实际上调用了Bar类的方法

如果是想得到 5 + 8 = 13的结果，就封装a字段

class Foo {
private int a;
public Foo() { a = 3; }
public void addFive() { a += 5; }
public int getA() {
return a;
}

}

public class Bar extends Foo{
    private int a;
    public Bar() { a = 8; }

    public int getA() {
return a;
}

@Override
    public void addFive() { a +=5; }

    public static void main(String[] args) {
        Foo foo = new Bar();
        foo.addFive();
        System.out.println("Value: "+ foo.getA());
    }

}