JAVA構造函數(方法)示例詳解

 一、什麼是構造函數

Java構造函數,也叫構造方法,是JAVA中一種特殊的函數。與函數名相同,無返回值。

作用:一般用來初始化成員屬性和成員方法的,即new對象產生後,就調用瞭對象的屬性和方法。

在現實生活中,很多事物一出現,就天生具有某些屬性和行為。比如人一出生,就有年齡、身高、體重、就會哭;汽車一出產,就有顏色、有外觀、可以運行等。

這些,我們就可以將這些天然的屬性和行為定義在構造函數中,當new實例化對象時,也就具有這些屬性和方法,不用再去重新定義,從而加快編程效率。

構造函數是對象一建立就運行,給對象初始化,就包括屬性,執行方法中的語句。

而一般函數是對象調用才執行,用 “.方法名” 的方式,給對象添加功能。

 一個對象建立,構造函數隻運行一次。

而一般函數可以被該對象調用多次。  

二、構造函數的特點

1、函數名與類名相同

2、不用定義返回值類型。(不同於void類型返回值,void是沒有具體返回值類型;構造函數是連類型都沒有)

3、不可以寫return語句。(返回值類型都沒有,故不需要return語句)

註:一般函數不能調用構造函數,隻有構造函數才能調用構造函數。

三、示例

1、無參構造函數類中隻定義一個方法。構造器總是伴隨著new操作一起調用. 

new對象時,就調用與之對應的構造函數,執行這個方法。不必寫“.方法名”。

package javastudy;
 
public class ConfunDemo {
    public static void main(String[] args) {
        //輸出Hello World。new對象一建立,就會調用對應的構造函數Confun(),並執行其中的println語句。
        Confun c1=new Confun();            
        
    }
}
class Confun{        
    Confun(){        
        //定義構造函數,輸出Hello World
        System.out.println("Hellow World");
    }
}

輸出:

Hellow World 

 2、有參構造函數,在new對象時,將實參值傳給private變量,相當於完成setter功能。

package javastudy;
 
public class ConfunDemo3 {
    public static void main(String[] args){
        //實例化對象時,new Person()裡直接調用Person構造函數並轉轉實參,相當於setter功能
        Person z = new Person("aerchi",18); 
        z.show();
    }
}
 
class Person{
    private String name;
    private int age;
    //有參數構造函數,實現給private成員變量傳參數值的功能
    public Person(String n,int m){ 
        name=n;
        age=m;        
    }
    //getter                                      
    //實例化對象時,完成瞭sett功能後,需要getter,獲取實參值。
    public String getName(){
        return name;
    }
    public int getAge(){
        return age;
    }
 
    //獲取private值後,並打印輸出
    public void show(){
        System.out.println(name+"\n"+age);
    }
}

輸出:

aerchi

18

 以上代碼,我們也可以將show()方法中的輸出語句直接放在構造函數中,new對象時,即可直接輸出值,如下

package javastudy;
 
public class ConfunDemo3 {
    public static void main(String[] args){
        //實例化對象時,new Person()裡直接調用Person構造函數並轉轉實參,同時執行輸出語句
        Person z=new Person("aerchi", 18);
    }
}
 
class Person{
    private String name;
    private int age;
    //有參數構造函數,實現給private成員變量傳參數值的功能,同時直接輸出值
    public Person(String n,int m){  
        name = n;
        age = m;
        System.out.println(name+"\n"+age);
    }
}

輸出:

aerchi

18

 或

class ConFun
{
    public static void main(String[] args){
        Person a=new Person(18,"aerchi");
        System.out.println(a.getAge() +", " + a.getName());
    }
}
 
class Person
{
    private int age;
    private String name;
    public Person(int x,String y){
        age=x;
        name=y;
    }
    public int getAge(){
        return age;
    }
    public String getName(){        
        return name;
    }
}

3、一個對象建立後,構造函數僅隻運行一次。

如果想給對象的值再賦新的值,就要使用set和get方法,此時是當做一般函數使用

如下:

package javastudy;
 
public class ConfunDemo4 {
    public static void main(String[] args) {
            PersonDemo s=new PersonDemo("張三",18);  //new對象時,即調用對應的構造函數,並傳值。同時,不能new同一個對象多次,否則會報錯。
            s.setName("李四");                       //對象建立後,想變更值時,就要用set/get方法,重新設置新的值
            s.setName("王二麻子");    //並可調用對象多次。
            s.print();
    }
}
class PersonDemo{
    private String name;
    private int age;
    PersonDemo(String n,int m){       //建立有參構造函數,用於給兩個private變量name、age賦值,同時輸出值
        name=n;
        age=m;
        System.out.println("姓名:"+name+"\n"+"年齡:"+age);
    }
    public void setName(String x){     //set方法,用於再次給name賦值
        name=x;        
    }
    public String getName(){          //get方法,用於獲取name的賦值
        return name;
    }
    public void print(){
        System.out.println(name);
    }
}

輸出結果:

姓名:張三

年齡:18

王二麻子

四、默認構造函數

當一個類中沒有定義構造函數時,系統會給該類中加一個默認的空參數的構造函數,方便該類初始化。隻是該空構造函數是隱藏不見的。

如下,Person(){}這個默認構造函數是隱藏不顯示的。

class Person
{  
    //Person(){}
}

當在該類中自定義瞭構造函數,默認構造函數就沒有瞭。

如果仍要構造函數,需要在類中手動添加。

五、構造函數的重載

構造函數也是函數的一種,同樣具備函數的重載(Overloding)特性。

class Person
{  
    private String name;
    private int age;
 
    Person()
    {
        System.out.println("A:name="+name+", age="+age);
    }
 
    Person(String n)
    {
        name = n;
        System.out.println("B:name="+name+", age="+age);
    }
 
    Person(String n,int a)
    {  
        name=n;
        age=a;
        System.out.println("C:name="+name+", age="+age);
    }
 
}
 
class PersonDemo2
{
    public static void main(String[] args)
    {
        Person p1=new Person();
        Person p2=new Person("aerchi");
        Person p3=new Person("aerchi",18);
    }
}

輸出結果:

A:name=null, age=0

B:name=aerchi, age=0

C:name=aerchi, age=18

輸出結果:

class Person
{  
    private String name;
    private int age;
 
    Person()
    {
        System.out.println("A:name="+name+", age="+age);
        cry();
    }
 
    Person(String n)
    {
        name = 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(); 
    }
    void cry()
    {
        System.out.println("Haha ...............");
    }
 
}
 
class PersonDemo2
{
    public static void main(String[] args)
    {
        Person p1=new Person();
        Person p2=new Person("aerchi");
        Person p3=new Person("aerchi",18);
    }
}

A:name=null, age=0

Haha ……………

B:name=aerchi, age=0

Haha ……………

C:name=aerchi, age=18

Haha ……………

六、構造函數的使用

1、子類所有的 構造函數 默認調用父類的無參構造函數(構造函數不會被繼承,隻是被子類調用而已),父類參數是private的,無法直接訪問。需要在父類中使用get方法來調用私有變量值。

package javastudy;
 
public class ConfunDemo5 {
    public static void main(String[] args) {
        Pupil z=new Pupil();
        z.show();
    }
}
class Student{                //父類Student
    private String name;
    private int height;
    public Student()
    {
        this.name="";
        this.height=0;
    }
    public String getName(){
        return name;
    }
    public int getHeight(){
        return height;
    }
}
class Pupil extends Student{    //子類Pupil
    private int score;
    public Pupil(){                //無參構造函數Pupil()直接繼承瞭父類中的無參構造函數Student(),但是父類中的name、height是private的
        score=0;
    }
    public void show(){
        System.out.print("姓名:"+getName()+"\n身高:"+getHeight()+"\n分數:"+score);  //輸出時,直接用get方法名。
    }
}

2、使用super調用父類的構造函數

super 必須寫在方法的首行

package javastudy;
 
public class ConfunDemo5 {
    public static void main(String[] args) {
        Pupil z=new Pupil("王二麻子",100,200);
        z.show();
        
        Pupil w=new Pupil();
        w.show();
    }
}
class Student{                //父類Student
    public String name;
    public int height;
    public Student()
    {
        this.name="";
        this.height=0;
    }
    public Student(String n,int m)
    {
        name=n;
        height=m;
    }
}
class Pupil extends Student{    //子類Pupil
    private int score;
    public Pupil(){                
        super("劉德花",501);    //使用super調用父類Student(String n,int m)方法,同時傳遞實際數值。super必須寫在方法的首行。如果這裡寫super(),則調用的是父類中的Student()方法。
        score=0;
    }
    public Pupil(String x,int y,int z){        //
        super(x,y);              //使用super調用父類Student(String n,int m)方法,其中super中的參數名稱必須與構造函數中的參數名稱一致。
        score=z;
    }
    public void show(){
        System.out.println("姓名:"+name+"\n身高:"+height+"\n分數:"+score);
    }
}

 輸出:

姓名:王二麻子

身高:100

分數:200

姓名:劉德花

身高:501

分數:0

構造函數的特點

構造函數的主要作用是完成對象的初始化工作,(如果寫的類裡面沒有構造函數,那麼編譯器會默認加上一個無參數且方法體為空的構造函數).它能夠把定義對象時的參數傳給對象的域。意即當創建一個對象時,這個對象就被初始化.如果這時構造函數不為空,則會在創建對象時就執行構造函數裡面的代碼:   

                                    

構造函數的名稱必須與類名相同,包括大小寫;

構造函數沒有返回值,也不能用void修飾.  如果不小心給構造函數前面添加瞭返回值類型,那麼這將使這個構造函數變成一個普通的方法,在運行時將產生找不到構造方法的錯誤。

一個類可以定義多個構造方法,如果在定義類時沒有定義構造方法,則編譯系統會自動插入一個無參數的默認構造器,這個構造器不執行任何代碼。

構造方法可以重載,以參數的個數,類型,順序。

總結

到此這篇關於JAVA構造函數(方法)的文章就介紹到這瞭,更多相關JAVA構造函數(方法)內容請搜索WalkonNet以前的文章或繼續瀏覽下面的相關文章希望大傢以後多多支持WalkonNet!

推薦閱讀: