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

复制代码

运行的到的结果是：

我是父类成员变量。

虽然子类有与父类重名的成员变量，但子类在调用父类的方法时，使用的仍是父类的成员变量。

问题是：如果不在子类中重写父类的方法，是否可以在子类调用父类方法时，使用子类成员变量？可以的话如何实现？不可以的话，稍微解释一下为什么。

class A{
        String a = "我是父类成员变量。";
        A(String a){this.a=a;}
        public void show(){
                System.out.println(this.a);
        }
}

class method extends A{
        String a = "我是子类成员变量。";
        method(String a)
        {
                super(a);
        }
        public static void main(String[] srgs){
                method b = new method("我是子类构造函数");
                b.show();
                //System.out.println(b.a);
        }
}
通过构造函数.构造函数可以使子父类中的同名变量在赋值上明确.

应该是不能的吧，子类在创建对象时，内存中同时也创建了一块保存父类数据内容的区域，则可以调用父类中的内容

而父类在创建对象时，是不知道子类中的数据内容的，也就不知道子类中有什么样的成员属性，除非在父类中拿到子类对象，才可以对子类的数据进行操作，

个人理解

假如是你这个代码.我想应该是不能用子类的变量.. 我觉得没有什么方法...因为你子类里什么方法都没有.但是你可以在这个class A{
        String a = "我是父类成员变量。";
        public void show(){
                System.out.println(new B().a);        }
}

class B extends A{
        String a = "我是子类成员变量。";
        
        public static void main(String[] srgs){
                B b = new B();
                b.show();
                System.out.println(b.a);
        }
}

如果想在调用show（）方法时调用子类的成员变量，那么就只能复写父类的方法
class Fu
{
        String a ="我是父类成员变量";
        public void show()
        {
                System.out.println(a);//这里你可以这么理解，此处的a=super.a（此处在程序中是不能写成super.a,可以这么理解），但是你想改成this.a，又什么
                                          //操作都没有，那就只能按照父类的来，要想按自己的来就必须复写该方法，就好比你要吃东西，然后你父类给你吃苹果
                                          //，但是你却想吃梨，却又不去拿，那就自有别人给你什么，你就吃什么了，纯属个人理解
        }
        
}
public class Test2 extends Fu {

        String a = "我是子类成员变量";
        public static void main(String[] args) {
                Fu f = new Test2();
                f.show();
                Test2 t = (Test2)f;
                System.out.println(t.a);//调用的是子类变量
                System.out.println(f.a);//调用的是父类变量
        }
}

罗海云 发表于 2013-2-21 21:47
假如是你这个代码.我想应该是不能用子类的变量.. 我觉得没有什么方法...因为你子类里什么方法都没有.但是你 ...

输出的还是父类的变量a



抱歉 是我错了

刘勇强 发表于 2013-2-21 22:00
输出的还是父类的变量a

不会啊.我试了.

我觉得不可以吧，除非把方法改了有参数的，把子类自己传进去
因为父类根本不知道自己有没有子类，是什么样的，有几个，而子类继承了父类，却能获得所有的父类非私有的属性和方法。

就着楼主的贴问个题:

  b.show(); 执行时，其中的this.a 的this应该是b的引用吧  

这样的话，对象b中除了自己的  String a = "我是子类成员变量。";


还有继承的A的  String a = "我是父类成员变量。";


程序是怎么确定输出的是 父类中的a  ，而不是子类的a呢？

重复了...

1. import java.lang.reflect.Method;
   
2. 
   
3. /**
   
4. * 如果不在子类中重写父类的方法，是否可以在子类调用父类方法时，使用子类成员变量？可以的话如何实现？不可以的话，稍微解释一下为什么。
   
5. * @author Administrator
   
6. *
   
7. */
   
8. 
   
9. class A{
   
10.     String a = "我是父类成员变量。";
    
11.     public void show(String a){
    
12.             System.out.println(a);
    
13.     }
    
14. }
    
15. 
    
16. class B extends A{
    
17.     String a = "我是子类成员变量。";
    
18.    
    
19.     public static void main(String[] srgs) throws Exception{
    
20.        /* A ai=new A();   
    
21.             Method method=A.class.getMethod("show", String.class);
    
22.             method.invoke(ai,a);*/
    
23.             A a1=new A();
    
24.             a1.show(a1.a);
    
25.             B b = new B();
    
26.         b.show(b.a);
    
27. 
    
28.     }
    
29. }

复制代码

输出结果是
我是父类成员变量。
我是子类成员变量。

符合你的要求么

个人认为应该是不行的，因为子类的变量对父类来说应该是未知的，父类的方法调用不了子类的变量，不过要是楼主修改下父类的方法改成用参数将变量传入可以将子类变量当参数传进去= ， =····不过这么干好像已经背离了楼主的初衷了···感觉2楼的哥们虽然在能让父类的变量有与子类的变量相同的赋值，但也不是楼主所说的在父类的方法中调用子类的变量啊，感觉不是，坐等高人来解答

经过反复试验，我成功了{:soso_e113:}  楼主说的这种情况是可以实现的
首先要弄清楚，在继承中，创建子类对象时程序的运行顺序是   父类非静态代码块->父类构造函数->子类初始化代码块->子类构造函数
在子类调用父类方法时，使用子类成员变量，那就在子类构造函数中处理，代码如下

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

复制代码

运行结果是    我是子类成员变量

楼上这个明显是直接把父类的成员变量给修改了嘛···

贾文泽 发表于 2013-2-21 22:16
经过反复试验，我成功了  楼主说的这种情况是可以实现的
首先要弄清楚，在继承中，创建子类对 ...

直接修改了父类成员变量了，这虽然结果是符合要求了，但还是不是直接使用子类成员变量。

李挺 发表于 2013-2-21 22:10
输出结果是
我是父类成员变量。
我是子类成员变量。

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

复制代码

谢谢，原来很简单嘛，怎么没想到……
我从新写了一下，得到想要的结果了，代码如上。

李挺 发表于 2013-2-21 22:10
输出结果是
我是父类成员变量。
我是子类成员变量。

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

复制代码

按照你的思路，我从新写了程序，得到想要的结果了。