谁帮我解释下子类对象实例化过程,越详细越好,要是有图文讲解就更棒了,:lol

1. 先加载父类的class文件，进入方法区
    父类中有静态的话，静态进到静态区  
    父类中，如果有静态代码块，这个时候，静态代码块就运行了
2. 加载子类的class 文件，进入方法区
    子类中有静态的话，静态进到静态去
    子类中如果有静态代码块，静态代码块就运行了
    子类继承父类了，class进方法去的时候，会在子类上打一个表示 super
3. 建立子类对象的时候 new Zi();
    开辟内存空间。运行父类的构造代码块
    运行父类的构造函数  (如果需要赋值的话，这时就赋值了)
    运行子类的构造代码块
    运行子类的构造函数(如果需要赋值的话，这时就赋值了)
    构造代码块，和构造函数运行完毕后，将对象的内存地址
    赋值给函数中的局部引用型变量
当子类建立对象的时候,如果子类没有调用对应的父类的构造函数,编译失败

我说一下我的见解啊！！什么是类，人类是类，你我不是人类，我们是实例化的人类，我们是人。
人类是抽象，而人是非抽象的。人类这个类定义了一些人的基本属性和行为。比如说吃饭，学习，走路啊这些都是行为。而身高，体重这些都是属性。

似水像火 发表于 2013-3-31 21:23
我说一下我的见解啊！！什么是类，人类是类，你我不是人类，我们是实例化的人类，我们是人。
人类是抽象， ...

哥们 你说的是 类 与 对象 的关系吧 ~~~

1.类加载器将.class文件加载到内存
2.静态代码块对类进行初始化（如果有的话）
3.在堆内存中开辟空间分配内存地址
4.在堆内存中，建立对象特有属性并进行默认初始化
5.对属性进行显示初始化
6.对对象进行构造代码块初始化
7.对对象进行对应的构造函数初始化
8.将内存地址分配给栈内存中的引用变量

首先创建一个类，通过这个类说明，对象的初始化过程：
class Person{
        private String name;//默认初始化值为null；
        private int age;//默认初始化值为0；
       
        private String test = "hello";//hello是显示初始化的值；
       
        public static String country = "cn";//静态成员变量。
       
       
       
        {//构造代码块
                System.out.println(name+"......."+age+"....."+test);
        }
       
        Person(String name,int age){//构造函数
                this.name = name;
                this.age = age;
        }
       
        public void setName(String name){
                this.name= name;
        }
        public void show(String name,int age){
                System.out.println("name:"+name+"......age:"+age);
        }
        public static void showCountry(){
                System.out.println("country:"+country);
        }
}

public class Demo12 {
        public static void main(String[] args) {
                Person p = new Person("zhangsan",29);
        }
}
通过执行Person p = new Person("zhangsan",29) 这一句代码，讲述对象初始化的过程
1，new 用到了Person.class文件，会先找到Person.class文件，然后将Person.class这个文件加载到内存中；

2，执行Person类中的静态代码块，对Person类进行初始化（在方法区创建一个Person类的空间，并将country和showCountry的数据存入方法区）；

3，在堆内存中开辟空间，给对象分配内存地址。

4，在堆内存中建立对象的特有属性（name，age），并进行默认初始化（name=null，age=0，test=null）；

5，对属性进行显示初始化（显示初始化后test=hello）；

6，对对象进行构造代码块初始化（会打印name=null，age=0，test=hello）；

7，对对象进行对应的构造函数初始化（name=“张三”，age=29）；

8，将内存地址赋给栈内存的中的p变量。

程媛媛 发表于 2013-3-31 21:36
首先创建一个类，通过这个类说明，对象的初始化过程：
class Person{
        private String name;//默认初始化值 ...

姐们,没有子类哦,我加你好友了.

类是一个抽象的概念，而对象是按照类的形式产生的具体存在，比如，人类(是类),而你(是对象),对象是类的具体实现，对象拥有类定义的所有实现。看个例子程序public class Person {//人类     public String name;     public void showMe() {          System.out.println("我的名字叫" + name);     } }public class Test {      public static void main(String[] args) {               //Person是类，me是一个Pseron类的对象               Person me = new Person();//创建一个类的对象的过程叫实例化               me.name = "听"; //me就是对象，对象拥有类定义的属性，name               me.showMe();//对象拥有类定义的行为(方法)，showMe()       }}输出：我的名字叫 听最后解释，类是抽象的概念，我们无法让概念去做一件事情，但是却可以让这个概念的实际存在去做。就好像，人类是可以问问题的，我们无法让 "人类"(对人的定义，是概念)去这么做，却可以让  "听" 这个属于 人'类' 的具体存在去提问题。希望这么说你理解了

自己运行下代码应该就清楚了

1. public class Demo01 {
   
2.         public static void main(String[] args) {
   
3.                 Zi zi = new Zi();
   
4.                 System.out.println("子类的姓："+zi.xing);
   
5.                 System.out.println("子类的名："+zi.ming);
   
6.         }
   
7. }
   
8. class Fu{
   
9.         public String xing = "fu";        //相当于父亲的姓
   
10.         public String ming = "fu";        //相当于父亲的名
    
11.         public Fu(){
    
12.                 System.out.println("父类构造方法");
    
13.         }
    
14. }
    
15. class Zi extends Fu {
    
16.         public String ming = "zi";        //子类有自己的名，但是姓必须要跟父姓啊 - -
    
17.         public Zi(){
    
18.                 System.out.println("子类构造方法");
    
19.         }
    
20. }

复制代码

康嘉 发表于 2013-3-31 21:16
1. 先加载父类的class文件，进入方法区
    父类中有静态的话，静态进到静态区  
    父类中，如果有静态代 ...

技术交流  多多益善  

luguoyuanf 发表于 2013-3-31 21:41
姐们,没有子类哦,我加你好友了.

子类的实例化过程和对象的实例化过程差不多一样的，只不过在加载子类之前先加载父类的.class文件。