在毕老师的视频讲解中，说道关于抽象类在创建对象上的问题：抽象类不可用new创建对象，因为调用抽象方法没有意义（抽象方法为类中成员）。看下面一段代码：

1. <font size="1">/*
   
2. 问题：关于抽象类不能创建对象，但能创建数组的测试
   
3. */
   
4. 
   
5. //抽象类Person
   
6. abstract class Person
   
7. {
   
8.    private String name;
   
9.    public Person(String name)
   
10.    {
    
11.       this.name = name;
    
12.    }
    
13.    //抽象方法：对人的描述，但对每种人的描述是不清楚的，所以用抽象方法
    
14.    public abstract String getDescription();
    
15. 
    
16.    public String getName()
    
17.    {
    
18.       return name;
    
19.    }
    
20. }</font>
    
21. <font size="1">
    
22. //Student继承父类Person
    
23. class Student extends Person
    
24. {
    
25.    public Student(String name)
    
26.    {
    
27.       super(name);
    
28.    }
    
29.    //复写超类的抽象方法，对学生进行具体描述
    
30.    public String getDescription()
    
31.    {
    
32.       return "I'm a student.";
    
33.    }
    
34. }
    
35. //Worker继承父类Person
    
36. class Worker extends Person
    
37. {
    
38.    public Worker(String name)
    
39.    {
    
40.       super(name);
    
41.    }
    
42.    //复写超类的抽象方法，对工人进行具体描述
    
43.    public String getDescription()
    
44.    {
    
45.       return "I'm a worker.";
    
46.    }
    
47. }
    
48. //测试
    
49. class PersonText
    
50. {
    
51.    public static void main(String[] args)
    
52.    {
    
53.       Person[] p = new Person[2];//用抽象类创建数组
    
54.       //再创建两个对象
    
55.       p[0] = new Student("Sun");
    
56.       p[1] = new Worker("Wu");
    
57.       System.out.println(p[0].getName() + ":" + p[0].getDescription());
    
58.       System.out.println(p[1].getName() + ":" + p[1].getDescription());
    
59.    }
    
60. }</font>

复制代码

数组也是对象，只不过有些特殊而已，既然有new存在，就说明在内存中创建了对象，为其开辟了一片空间，但是抽象类不能实例化。那么new出来的Person数组放在哪了呢？内存中又是怎么分配的呢？
是不是说抽象类不可以创建对象，但是又可以创建数组，就有些矛盾呢？
求解答，最好有图并分好步骤的解释，谢谢。

陈科宇 发表于 2013-2-5 15:31
对，针对你这个，我刚才还特意写了一篇关于数组的日志。我再讲个例子，你或许就更明白了。int是基本类型 ...

基本上理解了，十分感谢你的帮助

对于这个问题，我看了这两位朋友的热心帮助，我基本有些清晰了，我把自己的理解在这里整理一下：
在这里，Person[] p = new Person[2]只是创建了两个数组类型的元素，并不是Person类对象，在这里只是一种引用。而下面的new Student和new Worker才真正创建了两个对象，分别赋值给数组中的两个元素，或者说是两个变量。
再次感谢两位朋友。

黄玉昆 发表于 2013-2-5 15:28
我不是急躁，只是不明白他们之间的赋值过程。你说的给它规定了类型，我差不多有些明白了。谢谢你的解答 ...

对，针对你这个，我刚才还特意写了一篇关于数组的日志。我再讲个例子，你或许就更明白了。int是基本类型对吧。但是int[]却是引用类型。你不能说 int[] a=new int[2]是创建了两个基本类型的变量吧，这是不是矛盾了呢。其实没有矛盾，是认识误区。

吴在强 发表于 2013-2-5 15:12
这个是图像，刚刚那个图像没显示！自己慢慢体会！

谢谢你的图解

陈科宇 发表于 2013-2-5 15:24
你应该仔细看我给你的回复。不要急躁。我已经说过了，Person[] p=new  Person[2]是在堆内存中创建了两个 ...

我不是急躁，只是不明白他们之间的赋值过程。你说的给它规定了类型，我差不多有些明白了。谢谢你的解答

黄玉昆 发表于 2013-2-5 15:18
虽然是null，但是还是赋值了啊，只不过是空而已，是对对象更确切地说是数组，初始化了而已。既然可以Pers ...

不要把Person p=new Person[2]理解为创建两个Person对象。这是你认识上的误区。

吴在强 发表于 2013-2-5 15:11
你认真看看你代码，你自己创建的代码如下：
//问题：关于抽象类不能创建对象，但能创建数组的测试

怎么又涉及到了多态了呢（多态还没学到）？你说的”实现类的对象“是什么意思啊？你说的这个“是数组对象而不是Person对象啊 ，这个数组只能保存Person类型的对象！”数组中存放的不是对象的值吗？你说Person类型不能创建对象，哪里来Person类型的对象啊？还有，你传的图片，我看不到啊。

黄玉昆 发表于 2013-2-5 15:18
虽然是null，但是还是赋值了啊，只不过是空而已，是对对象更确切地说是数组，初始化了而已。既然可以Pers ...

你应该仔细看我给你的回复。不要急躁。我已经说过了，Person[] p=new  Person[2]是在堆内存中创建了两个数组元素，而不是Person对象。只是给它规定了类型，它只能存放或指向Person对象。

陈科宇 发表于 2013-2-5 12:09
朋友，你的Person[] p = new Person[2]，只是确定了数组的类型为Person，长度为2，而此时并没有Per ...

虽然是null，但是还是赋值了啊，只不过是空而已，是对对象更确切地说是数组，初始化了而已。既然可以Person[] p = new Person[2]这样写，就说明在堆内存中是存在的，我目前知道的是，堆内存中只有对象，那么这个所谓的不能创建对象，到底是怎么回事，我只是不太明白在堆内存中的分配情况。

这个是图像，刚刚那个图像没显示！自己慢慢体会！

你认真看看你代码，你自己创建的代码如下：
//问题：关于抽象类不能创建对象，但能创建数组的测试


//抽象类Person
abstract class Person
{
   private String name;
   public Person(String name)
   {
      this.name = name;
   }
   //抽象方法：对人的描述，但对每种人的描述是不清楚的，所以用抽象方法
   public abstract String getDescription();

   public String getName()
   {
      return name;
   }
}

//Student继承父类Person
class Student extends Person
{
   public Student(String name)
   {
      super(name);
   }
   //复写超类的抽象方法，对学生进行具体描述
   public String getDescription()
   {
      return "I'm a student.";
   }
}
//Worker继承父类Person
class Worker extends Person
{
   public Worker(String name)
   {
      super(name);
   }
   //复写超类的抽象方法，对工人进行具体描述
   public String getDescription()
   {
      return "I'm a worker.";
   }
}
//测试
public class PersonText
{
   public static void main(String[] args)
   {
      Person[] p = new Person[2];//用抽象类创建数组
      //再创建两个对象
      p[0] = new Student("Sun");
      p[1] = new Worker("Wu");
      System.out.println(p[0].getName() + ":" + p[0].getDescription());
      System.out.println(p[1].getName() + ":" + p[1].getDescription());
   }
}


Person[] p = new Person[2];这个创建出来的就是数组对象，而不是Person对象。
下面两个是java的多态，父类指向子类对象
p[0] = new Student("Sun");
p[1] = new Worker("Wu");
所有过程都没有直接创建抽象类的对象啊，p[0] = new Student("Sun");p[0]指向的是实现类的对象
抽象类是创建不了对象滴
但是可以有实现类的对象
创建的地址指向过程是 这样的：
C:\\tuxian.PNG

换句话说，是数组对象而不是Person对象啊 ，这个数组只能保存Person类型的对象！应该能明白了吧！

        朋友，你的Person[] p = new Person[2]，只是确定了数组的类型为Person，长度为2，而此时并没有Person对象产生。只有当你赋值给p[0],p[1]时数组的两个元素才不为null。希望我的解答对你有帮助。

      朋友，你这里有个误解。以为Person[] p = new Person[2]创建了两个person对象。看了下面的代码就明白了。
      public class PersonTest
{
public static void main(String[] args)
{
    Person[] p = new Person[2];//用抽象类创建数组
    System.out.println("p[0]==null:"+(p[0]==null));
    System.out.println("p[1]==null:"+(p[1]==null));

    //再创建两个对象
    p[0] = new Student("Sun");
    p[1] = new Worker("Wu");
    System.out.println(p[0].getName() + ":" + p[0].getDescription());
    System.out.println(p[1].getName() + ":" + p[1].getDescription());
    /*
     * p[0]==null:true
     * p[1]==null:true
     *Sun:I'm a student.
     *Wu:I'm a worker.
     *
     */
}
}