class Collection_Test
{
        public static void main(String[] args)
        {
                Person         p=new Son_1("234");//1
                Son_1 son=new Son_1("234");//2
                System.out.println(p.get());//3
                System.out.println(p.name);//4
                System.out.println(son.get());//5
                                //如果输出的结果是null我就理解了，但是3，4，5结果均为
                //234，我理解的多态是，1中的name是从Person中继承过来的
                //子类并没有name,那p应该要向上转型才对,p.name就
                //跟p.get()是一个性质的，此时我操作的是子类继承过来的
                //name,父类的name并没有被赋值啊。还是说子类继承了name
                //后，并对其赋值，但终究操作的都是父类的name,求解。。。。。。。



                //此时输出的p.name是不是父类的name？？(向上转型)



                Person p3=new Person();
                System.out.println(p3.name);
                //此时输出为123，不理解，
                //子类初始化顺序为
                //隐式初始化--显示初始化--代码块初始化--构造函数初始化
                //一层覆盖一层，最终执行到new Person()时，name="123"被
                //null覆盖才对啊。。。。。。。。求解。。。
        
        }
}

class Person
{
        String name="123";
        int age;
                Person(){}
        public String get()
        {
        return name;
        }
}

class Son_1 extends Person
{
        Son_1()
        {
          super();
        }
        Son_1(String name)
        {
                this.name=name;
        }
        
}

1. class Collection_Test
   
2. {
   
3.         public static void main(String[] args)
   
4.         {
   
5.                 Person p=new Son_1("234");//1  父类引用指向子类对象,调用的是带参数的构造函数,p的成员变量name发生改变,由原来的123变成234
   
6.                 Son_1 son=new Son_1("234");//2  调用的还是带参数的构造函数
   
7.                 System.out.println(p.get());//3  p调用person类的get方法，其实传进去的实参就是234
   
8.                 System.out.println(p.name);//4   p的成员变量name发生改变,由原来的123变成234
   
9.                 System.out.println(son.get());//5 调用从person类继承来的get方法，返回的是构造函数里传入的参数
   
10.                 Person p3=new Person();
    
11.                 System.out.println(p3.name);//重新创建对象,直接返回成员变量的值
    
12.                          }
    
13. }
    
14. 
    
15. class Person
    
16. {
    
17.         String name="123";
    
18.         int age;
    
19.         Person(){}
    
20.         public String get()
    
21.         {
    
22.         return name;
    
23.         }
    
24. }
    
25. 
    
26. class Son_1 extends Person
    
27. {
    
28.         Son_1()
    
29.         {
    
30.           super();
    
31.         }
    
32.         Son_1(String name)
    
33.         {
    
34.                 this.name=name;
    
35.         }
    
36.         
    
37. }
    

复制代码

希望能帮到楼主

1. class Collection_Test
   
2. {
   
3.          public static void main(String[] args)
   
4.          {
   
5.                  Person         p=new Son_1("234");//1
   
6.                  Son_1 son=new Son_1("234");//2
   
7.                  System.out.println(p.get());//3
   
8.                  System.out.println(p.name);//4
   
9.                  System.out.println(son.get());//5
   
10.                                  //如果输出的结果是null我就理解了，但是3，4，5结果均为
    
11.                 //234，我理解的多态是，1中的name是从Person中继承过来的
    
12.                 //子类并没有name,那p应该要向上转型才对,p.name就
    
13.                 //跟p.get()是一个性质的，此时我操作的是子类继承过来的
    
14.                 //name,父类的name并没有被赋值啊。还是说子类继承了name
    
15.                  //后，并对其赋值，但终究操作的都是父类的name,求解。。。。。。。
    
16. 
    
17. 
    
18. 
    
19.                 //此时输出的p.name是不是父类的name？？(向上转型)
    
20. 
    
21. 
    
22. 
    
23.                  Person p3=new Person();
    
24.                  System.out.println(p3.name);
    
25.                  //此时输出为123，不理解，
    
26.                 //子类初始化顺序为
    
27.                 //隐式初始化--显示初始化--代码块初始化--构造函数初始化
    
28.                 //一层覆盖一层，最终执行到new Person()时，name="123"被
    
29.                 //null覆盖才对啊。。。。。。。。求解。。。
    
30.         
    
31.          }
    
32. }
    
33. 
    
34. class Person
    
35. {
    
36.          String name="123";
    
37.          int age;
    
38.                  Person(){}
    
39.          public String get()
    
40.          {
    
41.          return name;
    
42.          }
    
43. }
    
44. 
    
45. class Son_1 extends Person
    
46. {
    
47.          Son_1()
    
48.          {
    
49.            super();
    
50.          }
    
51.          Son_1(String name)
    
52.          {
    
53.                  this.name=name;
    
54.          }
    
55.          
    
56. }

复制代码

是这样子么？？？？？？？？？？？？？