问一个关于继承的问题

Question

class Base
{
     public String name = "base"; 
     public void getName(){
         System.out.println(name);
     }
}
class Son extends Base
{
     public String name = "son";
}
class TestExtend
{
public static void main(String [] args){
    Son s = new Son();
    s.getName();
}
}
为什么getName访问的是父类的name？son不是已经集成了getName函数了么？

Answer 1

是啊,son继承了父类的getName(),同时也继承了父类的name。所以可以调用从父类的getName().打出的就是从父类继承来的name.

Answer 2

假如你在子类中重写了getname(),打印出来的才是子类定义的name

Answer 3

s.getName(); 调用的是父类的方法.

Answer 4

class Son extends Base
{
     public String name = "son";
     public void getName(){
         System.out.println(name);
     }}

Answer 5

你的子类没有覆盖父类中的getName()方法，因此s.getName()调用的是父类中的getName()方法
即返回的是父类中的name
除非子类覆盖了父类中的getName()，不然不可能返回子类的name

Answer 6

class Base
{
     public String name = "base"; 
     public void getName(){
         System.out.println(this.name);
     }
}
class Son extends Base
{
     public String name = "son";
}
class TestExtend
{
public static void main(String [] args){
    Son s = new Son();
    s.getName();
}
}
像大家说的son调用的是base(父类)的getName函数，但此时getName中的this应为son的实例，所以应该返回son的name，为什么还是返回Base的name?

Answer 7

同意七楼主的，就算改为this也跟没有改一样（至少在这里）

Answer 8

this出现在那个类里，this就指的那个类的对象。你的this出现在父类中，所以this指的是父类。
你平时写方法的内容时，一般情况下成员名字都是直接的写的，直接写的成员名等价于this.成员名。

Answer 9

可是这个getName() 明明是子类son 调用的呀

Answer 10

这样来理解子类对父类继承：
在子类对象内部包含着一个父类子对象，父类子对象是子类对象的一部分，两者有明确的界线（这就能理解为什么子类为什么可以为两个name了），但是父类子对象做为子类的一部分，子类可以直接访问父类子对象的每个可以访问的成员（有些成员是不可访问的，比如private的成员，虽然这些成员是存在于子类中的父类子对象中的），也可以通过super访问，通常情况下只有在有歧义时才通过super访问，也就是说，如果父类子对象的成员名在整个子类中是唯一的，可以直接访问。注意，上面说的父类子对象只能存在于子类中。于一般的对象不同，所以叫它为子对象。

Answer 11

（这就能理解为什么子类中可以有两个name了）

Answer 12

son继承自base也就继承了父类的属性和方法。如果son对父类的方法getName进行了重写，则s.getName()会调用son的方法。没有的话则调用父类的方法。

Answer 13

class Base
{
     public String name = "base"; 
     public void getName(){
      System.out.println("当前对象所在的类名称"+this.getClass().getName());
         System.out.println(name);
     }
}
class Son extends Base
{
     public String name = "son";
}
public class Test
{
    public static void main(String [] args){
        Son s = new Son();
        s.getName();
        //检查son类的域
        Field[] fields=s.getClass().getFields();
        for(Field field:fields){
         System.out.println("属性名称:"+field.getName());
        }
    }
}

Answer 14

也就是说son有两个name属性，一个是继承来的，一个是自己定义的
当访问name属性的方法在父类里边的时候，访问的name是父类的。
当访问的name属性在子类的时候，访问的name属性是子类的。
下边你把getName移动子类中看看：import com.sun.java_cup.internal.internal_error;import java.util.GregorianCalendar;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
import java.util.ListIterator;
import java.util.PriorityQueue;
import java.util.concurrent.atomic.AtomicInteger;
import java.lang.reflect.*;
class Base
{
     public String name = "base"; }
class Son extends Base
{
     public String name = "son";
     public void getName(){
      System.out.println("当前对象所在的类名称"+this.getClass().getName());
         System.out.println(name);
     }
}
public class Test
{
    public static void main(String [] args){
        Son s = new Son();
        s.getName();
        //检查son类的域
        Field[] fields=s.getClass().getFields();
        for(Field field:fields){
         System.out.println(field.getName());
        }
    }
}
另外，这个this指向的对象是你创建的实际的类型的对象，并不一定是所在类的对象。

Answer 15

哥们，你这个程序报错呀，是不是要引入什么类呀 提示'找不到 field[]'

Answer 16

谢谢 哥们，你这个程序让我明白了很多，我再问下 怎么样把属性的值打印出来？field.getValue()不行呀

Answer 17

System.out.println("属性名称:"+field.getName()+":"+field.get())；
这样也报错

Answer 18

public class Test
{
    public static void main(String [] args)throws Exception{
        Son s = new Son();
        s.getName();
        //检查son类的域
        Field[] fields=s.getClass().getFields();
        for(Field field:fields){
         System.out.println(field.getName());
         System.out.println(field.get(s));
        }
    }
}

Answer 19

调用父类的方法，父类方法getName中调用了自己的name成员变量。
如果想要现在子类的name那么必须在子类中继承父类的方法

Answer 20

楼主的程序是错误的，当然运行不出来了
你如果在Eclipse里面运行的话，会提示你出错·
son.getName();是这样提示的：
The method getName() is undefined for the type Son

Answer 21

大伙写的时候记的别只写GET方法，还的写SET方法，要是在父类中写了SET方法，在子类中用SET方法设属性，这样就好使了。

Answer 22

getName() 是父类对象的方法,它只知道父类对象的属性和其他方法.
他并不知道子类对象的属性地址,所以也就访问不到子类对象的name属性!

Answer 23

class Base
{
     public String name = "base"; 
     public void getName(){
         System.out.println(name);
     }
}
class Son extends Base
{
     public String name = "son";
}
class TestExtend
{
    public static void main(String [] args){
        Son s = new Son();
        s.getName();
    }
}
针对这段程序的执行过程我总结下，大家看对不对：
   "如果在子类中对从父类继承来的成员变量进行重新定义，即出现了子类变量对父类变量的隐藏。所谓隐藏是指子类拥有两个相同名字的变量，一个是继承自父类，另一个是由自己定义的。当子类执行它自己定义的方法时，如果操作该变量，所操作的是它自己定义的变量，而把继承自父类的变量“隐藏”起来。当子类执行从父类继承的操作时，如果操作该变量，所操作的是继承自父类的成员变量"--引用自百度知道
   "ZiSheng" 的程序表明，调用getName()函数的是son类，son类拥有两个name,getName里this是son的实例，所以this.name一定是s的变量，而不是像大家说的是Base的变量
   所以也就是说son调用getName()的时候，其实是调用它自己的函数（很多人说是调用父类的函数，我很不理解），只是它有两个name,未重写getName()函数时，它访问的从父类继承来的那个name，而在重写getName()之后，它调用的才是自身的name
   大家觉得这个执行流程我理解的对么？

Answer 24

子类没有覆写父类的方法，当NEW子类的对象的时候，调用的方法仍然是父类的。如果你用父类引用指向子类对象，这个时候就出现多态了。

Answer 25

class Son extends Base
{
    public String name = "son";
    public void getName(){
        System.out.println(name);
    }} 

Answer 26

class Base
 { 
      public String name = "base"; 
      public void getName()
     { 
         System.out.println(name); 
     }
 }  class Son extends Base 
 { 
       public String name = "son"; 
      public void getName()
     { 
         System.out.println(name); 
     }
  }   class TestExtend 
  { 
     public static void main(String [] args)
     { 
        Son s = new Son(); 
        s.getName(); 
     } 
   }
 建议楼主这样试试，对比一下 旧明白了

Answer 27

没有重写get方法 就只能输出父类的name