黑马程序员技术交流社区

标题: ]构造函数、构造代码块、静态代码块对类和对象的初始化区别？ [打印本页]

---

作者: 余耀明    时间: 2012-4-17 21:57
标题: ]构造函数、构造代码块、静态代码块对类和对象的初始化区别？
构造函数、构造代码块、静态代码块对类和对象的初始化区别？

---

作者: 胡元    时间: 2012-4-17 22:43
构造函数、构造代码块、静态代码块对类和对象的初始化区别？
静态代码块是先于对象存在的，类一加载就会在内存中产生，随着类的加载而加载，生命周期最长，
一般作为共享数据来用！
构造代码块是对所有对象做的初始化，不包含特有数据，比如人，人都有胳膊腿，这就可以用构造代码块
优先级高于构造函数！
构造函数对虾昂创建时给对象属性初始化，比如人，人各有个的名字，创建对象的时候通过构造函数
初始化对象的特有属性！

---

作者: liuyang    时间: 2012-4-17 22:46
构造函数

特点:

1、函数名与类名相同

2、不用定义返回值类型

3、不可以写return语句

作用:

给对象进行初始化。

注意：

1、默认构造函数的特点。

2、多个构造函数是以重载的形式存在的。





对象一建立就会调用与之对应的构造函数。



构造函数的作用：可以用于给对象进行初始化。

当在堆内存中产生一个对象的时候需要一个初始化动作

对象为什么要进行初始化呢？

现实生活中的事物很多他只要一出现就具备了一些基本的特性：比如产生一个人，这人一出生他就会哭这个行为，这个行为就是他的初始化行为。



构造函数的小细节：

当一个类中没有定义构造函数时，那么系统会默认给该类加入一个空参数的构造函数。



当在类中自定义了构造函数后，默认的构造函数就没有了。



构造函数和一般函数在写法上有不同。



在运行上也有不同。

构造函数是在对象一建立就运行，给对象初始化。

而一般函数是对象调用才执行，是给对象添加对象具备的功能



一个对象建立，构造函数只运行一次。

而一般方法可以被该对象调用多次。



什么时候定义构造函数呢？

当分析事物时，该事物存在具备一些特性或者行为，那么将这些内容定义在构造函数中。



构造函数在定义过程中要分析是否需要未知内容参与运算，这些内容是什么数据类型，这一点与一般函数相同。



注意：如果把类中的所有构造函数都私有private，那么该类所有的对象都不能初始化成功，会报错。





class Person

{

// Person( ){ }//系统默认添加的构造函数，方便对象初始化，否则对象是建立不出来的。



Person( )

{

    System.out.println("Person run");

}



      

private String name;

private int age;





构造代码块：

作用：给对象进行初始化。

对象一建立就运行，而且优先于构造函数执行。

构造代码块和构造函数的区别：

构造代码块是给所有对象进行统一初始化，定义不同对象共性初始化内容：比如每个孩子生出来都会哭。

而构造函数是给对应的对象初始化。



｛

    //System.out.println("person code run);

    cry( );

｝





Person( )

{

    System.out.println("A: name="+name+",,age="+age);

  cry( );

}



Person( String n)

{

System.out.println("B: name="+name+",,age="+age);

cry( );

}



Person( String n,int a)

{

name=n;

age=a;

System.out.println("C: name="+name+",,age="+age);

cry( );

}



public void getName（）

｛

          return name；

｝

public void setName（String n）

｛

          name=n；

｝





public void cry( )

        {

System.out.println("cry.......");

        }   





｝

class PersonDemo

{

public static void main(String[ ] args)

    {

   

Person p1=new Person( );

//打印结果:A:name=null,,age=0  cry.....



p1.cry( );

//打印结果:cry.....





Person p2=new Person( "lisi");

//打印结果:A:name=lisi,,age=0   cry......



System.out.println( p2.getName( ) );//打印结果:lisi



lisi认为这个名字太难听，想改名为libusi，但是我们不能这样写

// Person p2=new Person( "lisi");

因为这样写就又新建了一个对象叫libusi

应该这样写：

p2.setName(libusi);



System.out.println( p2.getName( ) );//打印结果:libusi





Person p1=new Person("wangwu",10 );

//打印结果:A:name=wangwu,,age=10   cry.....



    }

}

---

作者: zhaishuang    时间: 2012-4-19 01:14
构造函数的作用是在创建对象时对其进行初始化，当然对象要基于类才能创建；
构造代码块是对所有对象进行初始化，也就是说只要创建了对象，就会运行构造代码块中的内容；
静态代码块，只要是静态的都是优先于对象存在，随着类的加载而加载，可以想象成是把他和类绑在了一起；同生共死的。静态代码块的作用一般是初始化静态成员变量的。还有就是静态代码块里可以持有某一类的引用而使用一般的方法。

---

作者: 韩新凯    时间: 2012-4-19 08:51


被JVM装载->先以后面描述的方式之后执行父类的相关代码->如果有静态初始化，先执行静态初始化，且只执行一次，以后即使有该类实例化，也不会再执行->如果有静态代码块（以与静态初始化一样的方式执行）->如果有new语句带来的实例化，先为成员变量分配空间，并绑定参数列表，隐式或显式执行super()，即父类的构造方法，->执行非静态代码块-〉执行本类的构造函数-〉其他代码,
构造代码块总是会执行的

---

作者: 张超超    时间: 2012-4-19 09:13
Java初始化顺序:

1在new B一个实例时首先要进行类的装载。（类只有在使用New调用创建的时候才会被java类装载器装入）2，在装载类时，先装载父类A，再装载子类B
3，装载父类A后，完成静态动作（包括静态代码和变量，它们的级别是相同的，安装代码中出现的顺序初始化）
4，装载子类B后，完成静态动作
类装载完成，开始进行实例化
1，在实例化子类B时，先要实例化父类A
2，实例化父类A时，先成员实例化（非静态代码）
3，父类A的构造方法
4，子类B的成员实例化（非静态代码）
5，子类B的构造方法



先初始化父类的静态代码--->初始化子类的静态代码-->初始化父类的非静态代码--->初始化父类构造函数--->初始化子类非静态代码--->初始化子类构造函数



测试代码：


abstract class base
{         
    public int age=getNumber(100);        
    static{         
        System.out.println("base static block");      
    }
      
    {         
        System.out.println("base nonstatic block");        
    }   
    static int sage=getNumber(50);   
    base(){      
        System.out.println(age);      
        System.out.println("base start");
        draw();//会调用子类覆盖后的方法，这儿是0！(方法的重载)        
        System.out.println("base end");           
    }   
    static int getNumber(int base){      
        System.out.println("base.getNumber int"+base);
        return base;   
    }   
    public  void draw(){      
        System.out.println("base.draw");   
        }
}

public class initializeOrder extends base{   
    public int age=getNumber(1001);   
    private int _radius=getNumber(10);   
    static int sage=getNumber(250);   
    static{      
        System.out.println("subclass static block");   
    }   
    {      
        System.out.println("subclass nonstatic block");
    }
    initializeOrder(int radius){      
        _radius=radius;      
        System.out.println(age);
        draw();//这儿是1000
        System.out.println("initializeOrder initialized");   
    }   
    public void draw(){
        System.out.println("initializeOrder.draw "+_radius);   
        }     
    public static void main(String[] args) {        // TODO Auto-generated method stub      
        new initializeOrder(1000);   

    }

}

输出为：

base static block
base.getNumber int50
base.getNumb

er int250
subclass static block
base.getNumber int100
base nonstatic block
100
base start
initializeOrder.draw 0
base end
base.getNumber int1001
base.getNumber int10
subclass nonstatic block
1001
initializeOrder.draw 1000
initializeOrder initialized

希望对你有帮助

---

作者: 王德升    时间: 2012-4-19 13:08


1在new B一个实例时首先要进行类的装载。（类只有在使用New调用创建的时候才会被java类装载器装入）2，在装载类时，先装载父类A，再装载子类B
3，装载父类A后，完成静态动作（包括静态代码和变量，它们的级别是相同的，安装代码中出现的顺序初始化）
4，装载子类B后，完成静态动作
类装载完成，开始进行实例化
1，在实例化子类B时，先要实例化父类A
2，实例化父类A时，先成员实例化（非静态代码）
3，父类A的构造方法
4，子类B的成员实例化（非静态代码）
5，子类B的构造方法

先初始化父类的静态代码--->初始化子类的静态代码-->初始化父类的非静态代码--->初始化父类构造函数--->初始化子类非静态代码--->初始化子类构造函数

测试代码：

abstract class base
{         
    public int age=getNumber(100);        
    static{         
        System.out.println("base static block");      
    }
      
    {         
        System.out.println("base nonstatic block");        
    }   
    static int sage=getNumber(50);   
    base(){      
        System.out.println(age);      
        System.out.println("base start");
        draw();//会调用子类覆盖后的方法，这儿是0！(方法的重载)        
        System.out.println("base end");           
    }   
    static int getNumber(int base){      
        System.out.println("base.getNumber int"+base);
        return base;   
    }   
    public  void draw(){      
        System.out.println("base.draw");   
        }
}

public class initializeOrder extends base{   
    public int age=getNumber(1001);   
    private int _radius=getNumber(10);   
    static int sage=getNumber(250);   
    static{      
        System.out.println("subclass static block");   
    }   
    {      
        System.out.println("subclass nonstatic block");
    }
    initializeOrder(int radius){      
        _radius=radius;      
        System.out.println(age);
        draw();//这儿是1000
        System.out.println("initializeOrder initialized");   
    }   
    public void draw(){
        System.out.println("initializeOrder.draw "+_radius);   
        }     
    public static void main(String[] args) {        // TODO Auto-generated method stub      
        new initializeOrder(1000);   

    }

}

---

作者: 余耀明    时间: 2012-4-19 14:11

liuyang 发表于 2012-4-17 22:46
构造函数

特点:

清楚了！！:)

---

欢迎光临 黑马程序员技术交流社区 (http://bbs.itheima.com/)

黑马程序员IT技术论坛 X3.2