Java访问子类对象的实例变量

对于Java这种语言来说，一般来说，子类可以调用父类中的非private变量，但在一些特殊情况下，

Java语言可以通过父类调用子类的变量

具体的还是请按下面的例子吧!

package com.yonyou.test;

/**
 * 测试类
 * @author 小浩
 * @创建日期 2015-3-2
 */

class Base
{
	// 定义了一个名为i的实例变量
	private int i = 2;
	public Base()
	{
		this.display(); //注意这里面的this代表当前正在运行的对象，即Derived对象
	}
	public void display()
	{
		System.out.println(i);
	}
}
// 继承Base的Derived子类
class Derived extends Base
{
	// 定义了一个名为i的实例变量
	private int i = 22;
	// 构造器，将实例变量i初始化为222
	public Derived()
	{
		i = 222;              //②
	}
	public void display()
	{
		System.out.println(i);
	}
}
public class Test
{
	public static void main(String[] args)
	{
		// 创建Derived的构造器创建实例
		new Derived();       //①
	}
}

　　最后的结果是多少呢？没错就是0，是不是很意外，这里你需要明白。

public Base()
 {
 this.display(); //注意这里面的this代表当前正在运行的对象，即Derived对象
 }

　　这里面的this指的是当前正在运行的那个对象，那么当前运行的对象是谁？没错，就是Derived对象。

为了确定是Derived，我们可以看下面的代码：

	public Base()
	{
		System.out.println(this.i); //新增加的变量 其值为2
		this.display(); //注意这里面的this代表当前正在运行的对象，即Derived对象
		System.out.println(this.getClass());
	}

     //最后结果为:
     //    2
     //    0
     //    class com.yonyou.test.Derived

　　

但是现在的问题又出现了如果修改上面的代码加入System.out.println(this.i)

如下面的例子:

public Base()
	{
		System.out.println(this.i); //新增加的变量 其值为2
		this.display(); //注意这里面的this代表当前正在运行的对象，即Derived对象
	}

　　既然这俩this的指的是Derived对象，那为什么其值不是0，而是父类Base对象里面对应变量

的值2呢？

这里涉及到了编译类型和运行时类型相关的内容。当变量的编译类型和运行时类型不同的话，通过该对象访问其所引用对象的实例变量的时候

表现出该实例变量所声明时的类型决定。因为

System.out.println(this.i); //新增加的变量 其值为2

这里的this访问的变量，所以其值为声明它的对象Base的值，即2

但通过通过此实例变量调用它所对应的实例方法的时候，该方法的行为将由它实际所引用的对象来决定。

因为

this.display(); //注意这里面的this代表当前正在运行的对象，即Derived对象

这里的this的实际引用它的对象为Derived，所以其i值为0.

根据java创建对象时初始化对象的时机（http://www.cnblogs.com/xiohao/p/4349833.html），我们知道这时Derived中的变量i还没有初始化，

所以最后的结果为:0

最后提示一下如果是静态方法的话，仅仅序声明它的类型相关，与其它的没有任何关系哦...

下面是对比的例子:

1 静态方法,仅仅与其声明的类型有关

package com.yonyou.test;

/**
 * 测试类
 * @author 小浩
 * @创建日期 2015-3-20
 */

public class Test
 {
	public static void main(String[] args) {
               Base b=new Base();
               Base  c=new Inherit();
               b.a();
               b.b();
               c.a();
               c.b();
    }
	}
	class Base{
        static void a( ){System.out.println("A");  }
                 void b( ){System.out.println("B"); }
}
 class  Inherit extends Base{
          static void a( ){System.out.println("C");  }
                  void b( ){System.out.println("D"); }

}

最后的结果为:A,B,A,D

2.非静态方法正常，与其真正所引用的类型相关

package com.yonyou.test;

/**
 * 测试类
 * @author 小浩
 * @创建日期 2015-3-20
 */

public class Test
 {
	public static void main(String[] args) {
               Base b=new Base();
               Base  c=new Inherit();
               b.a();
               b.b();
               c.a();
               c.b();
    }
	}
	class Base{
         void a( ){System.out.println("A");  }
                 void b( ){System.out.println("B"); }
}
 class  Inherit extends Base{
           void a( ){System.out.println("C");  }
                  void b( ){System.out.println("D"); }

}

结果为:A,B,C,D

上面的话有一些绕，请务必多读几遍，反复揣摩，这样你会更上一层楼。

如果实在不懂也可以发送邮件至:12612455595@qq.com

如果你确实理解了的话，请通过下面的例子测试一下:

package com.yonyou.test;

/**
 * 测试类
 * @author 小浩
 * @创建日期 2015-3-2
 */

class Animal
{
	// desc实例变量保存对象toString方法的返回值
	private String desc;
	public Animal()
	{
		// 调用getDesc()方法初始化desc实例变量
		this.desc = getDesc();            //②
	}
	public String getDesc()
	{
		return "Animal";
	}
	public String toString()
	{
		return desc;
	}
}
public class Wolf extends Animal
{
	// 定义name、weight两个实例变量
	private String name;
	private double weight;
	public Wolf(String name , double weight)
	{
		// 为name、weight两个实例变量赋值
		this.name = name;                 //③
		this.weight = weight;
	}
	// 重写父类的getDesc()方法
	@Override
	public String getDesc()
	{
		return "Wolf[name=" + name + " , weight="
			+ weight + "]";
	}
	public static void main(String[] args)
	{
		System.out.println(new Wolf("灰太狼" , 32.3)); //①
	}
}

提示:最后的结果为:

Wolf[name=null , weight=0.0]

测试例子2:

class Base
{
	int count = 2;
	public void display()
	{
		System.out.println(this.count);
	}
}
class Derived extends Base
{
	int count = 20;
	@Override
	public void display()
	{
		System.out.println(this.count);
	}
}
public class FieldAndMethodTest
{
	public static void main(String[] args)
	{
		// 声明、创建一个Base对象
		Base b = new Base();             //①
		// 直接访问count实例变量和通过display访问count实例变量
		System.out.println(b.count);
		b.display();
		// 声明、并创建一个Derived对象
		Derived d = new Derived();       //②
		// 直接访问count实例变量和通过display访问count实例变量
		System.out.println(d.count);
		d.display();
		// 声明一个Base变量，并将Derived对象赋给该变量
		Base bd = new Derived();         //③
		// 直接访问count实例变量和通过display访问count实例变量
		System.out.println(bd.count);
		bd.display();
		// 让d2b变量指向原d变量所指向的Dervied对象
		Base d2b = d;                    //④
		// 访问d2b所指对象的count实例变量
		System.out.println(d2b.count);
	}
}

　　运行结果为:

2
2
20
20
2
20
2

　　

好吧，今天就先到这里吧、、、