package baseDemo;

class A{
        private String name="aaaaa";

        public String getName() {
                System.out.println(this.getClass().getName());//在这是子类。
                return name;
        }

        public void setName(String name) {
                this.name = name;
        }
       
       
}
class B extends A{
        private String name="bbbb";
       
}
public class ExtendsDemo {

        public static void main(String[] args) {
                        B b = new B();                 //创建子类对象
                        System.out.println(b.getName()); //输出:aaaaa    在这为什么返回的是父类的name;
        }
}

由于，代码的框显示不出来，重新在下一楼楼重新整理下。读完下完的还是有问题的话。看看下面的简单继承例子：

1. 
   
2. class Car
   
3. {
   
4.        private int CarNumber;//定义成员变量：车牌号
   
5.        void SetNumber(int  CarNumber)//成员方法：设置车牌号
   
6.        {
   
7.                this.CarNumber=CarNumber;
   
8.        }
   
9.        void ShowNumber()//输出车牌号
   
10.        {
    
11.                System.out.println("My Car No. is："+CarNumber);
    
12.        }
    
13. }
    
14. class Bus extends Car//继承父类的方法，没有复写继承的方法，并有自己的两个方法，子类实际4个方法
    
15. {
    
16.        private int Capacity;/我们可以把这个参数以及下面的同参数，改成CarNumber，但是结果是一样的，只不过名字相同而已
    
17.        void SetCapacity(int Capacity)
    
18.        {
    
19.              this.Capacity=Capacity;
    
20.        }
    
21.         void ShowCapacity()
    
22.        {
    
23.                System.out.println("My Capacity is："+Capacity);
    
24.        }
    
25. }
    
26. class CarDemo
    
27. {
    
28.        public static void main(String[] args)
    
29.        {
    
30.               Bus DemoBus=new Bus();
    
31.               DemoBus.SetNumber(6868);//子类对象调用继承的父类方法，没有重写该方法，所以它只会对父类的this.数据进行操作
    
32.               DemoBus.ShowNumber();
    
33.               DemoBus.SetCapacity(30);
    
34.               DemoBus.ShowCapacity();
    
35.        }
    
36. }
    
37.       
    

复制代码

楼主，针对你的代码，我研究了一下。

1. class A
   
2. {
   
3.         private String name="aaaaa";
   
4. 
   
5.         public String getName()
   
6.         {
   
7.                                 System.out.println(this.getClass());
   
8.                                 System.out.println(this.getClass().getName());                        
   
9.                                 return name;
   
10.         }
    
11. 
    
12.         public void setName(String name)
    
13.         {
    
14.                 this.name = name;
    
15.         }
    
16.         
    
17.         
    
18. }
    
19. class B extends A
    
20. {
    
21.         private String name="bbbb";
    
22.                 //public String getName()
    
23.                 //{
    
24.                 //        return name;
    
25.                 //}
    
26. }
    
27. class ExtendsDemo
    
28. {
    
29.         public static void main(String[] args)
    
30.                 {
    
31.                                 B b = new B();//创建子类对象
    
32.                                 System.out.println(b.getName());
    
33.                 }
    
34. }

复制代码

以下是个人跟舍友的看法：在该子类中，没有对getName方法进行复写，所以，子类中的方法本质是不属于B的，它只是继承了过来，当你通过B调用没有重写的方法时，它只认识父类的this，所以调用的this.getname也只是A的name。

简单说就是，不要让相同的名字变量，影响我们对函数调用的思维。没复写的话getName()方法跟子类的name没关系。你可以把它想成正常的方法调用，只不过因为你没有重写，所以这方法只会回去调用它本类的成员。我重写A类的方法后，结果就是输出bbbb了。你要了解继承之后没复写的父类方法是怎么被调用的。可以看上面的车和巴士的例子

为何我把楼主的代码贴上后,编译可以通过,但是运行的话报错,
然后把第一行的
package baseDemo;   删掉后,编译与运行没错误,得出结果
B
aaaaa

菠萝包丶 发表于 2014-5-5 22:31
楼主，针对你的代码，我研究了一下。

以下是个人跟舍友的看法：在该子类中，没有对getName方法进行复写， ...

我知道一般不要重名，只是好奇哈，return this.name,可是这个this不是代表子类吗？
我在上面输出了this的类名，是子类。不懂:(

有点儿意思，我也开始以为也是返回bbb...在网上查了查：恍然大悟..
虽然子类继承了父类的，如果没有重写，严格意义上来说， 只能说子类能直接访问这个属性或者是方法，但是这个方法还是在父类的里面。子类相当于将整个父类放在了自己的里面。所以在没有重写的情况，由于这个方法还是在父类中间的方法，所以返回的还是父类的属性。
例子如下
1,子类继承父类,会继承父类的所有属性(properties)和方法(methods),包括private修饰的属性和方法,但是子类只能访问和使用非private的,所以可以这么理解: 子类对象的内部 包涵了一个完整父类对象;

2.  new Zi()就是创建一个子类对象,而子类对象内部包涵了父类对象,所以又要先new Fu(), 也就是说
创建子类对象 = 创建父类对象 + 其他
//        Zi() {

//                super(); 这是JVM默认加上去的

//        }


3.子类对象没有重写(Overriding)父类的方法,那么这个方法就还"包涵"在父类对象里,,子类对象用getI()方法,其实质调用的是 子类对象"肚子里的"那个父类对象的方法.

4 return i; JAVA规定,变量前面没有特别说明是谁的变量,那么就适用"就近原则",显然父类对象的属性int i是最近的,下面这个例子可以更好的理解就近原则;

1. <pre class="brush: java" style="color: rgb(0, 0, 0); line-height: 24px; ">public class Test {
   
2. 
   
3.         static int age = 1;
   
4. 
   
5.         public static void main(String[] args) {
   
6. 
   
7.                
   
8. 
   
9.                 System.out.println(age);//输出1     此处没有指明这个age是谁的,适用就近原则,JVM认为age是成员变量static int age;
   
10. 
    
11.                
    
12. 
    
13.                 int age = 2;
    
14. 
    
15.                 System.out.println(age);//输出2        此处没有指明这个age是谁的,适用就近原则,JVM认为age是  局部变量int age;
    
16. 
    
17.                
    
18. 
    
19.                 System.out.println(Test.age);//输出1 此处指明了是类Test的age,JVM就不能再用就近原则了.
    
20. 
    
21.         }
    
22. 
    
23. }</pre>

复制代码

执笔梦 发表于 2014-5-5 22:44
我知道一般不要重名，只是好奇哈，return this.name,可是这个this不是代表子类吗？
我在上面输出了this的 ...

对的，你调用的方法getclass()的确是返回对象所属的类。但是这是B调用Object的方法，该方法返回对象所属的类。而这个方法跟this没有关系，你可以看我二楼给的简单继承例子，你别想太复杂。只不过出现了成员变量重名现象，你就会想的太复杂。