JAVA構造函數(方法)

一、什么是構造函數

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

作用：一般用來初始化成員屬性和成員方法的，即new對象產生后，就調用了對象了屬性和方法。

在現實生活中，很多事物一出現，就天生具有某些屬性和行為。比如人一出生，就有年齡、身高、體重、就會哭；汽車一出產，就有顏色、有外觀、可以運行等。這些，我們就可以將這些天然的屬性和行為定義在構造函數中，當new實例化對象時，也就具有這些屬性和方法了，沒必要再去重新定義了，從而加快了編程效率。

 

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

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

 

 一個對象建立，構造函數只運行一次。

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

  

 

二、構造函數的特點

1、函數名與類名相同

2、不用定義返回值類型。（不同於void類型返回值，void是沒有具體返回值類型；構造函數是連類型都沒有）

3、不可以寫return語句。（返回值類型都沒有，也就不需要return語句了）

 

注：一般函數不能調用構造函數，只有構造函數才能調用構造函數。

 

 三、示例

1、無參構造函數中只定義了一個方法。new對象時，就調用與之對應的構造函數，執行這個方法。不必寫“.方法名”。 

package javastudy;

public class ConfunDemo {
    public static void main(String[] args) {
        Confun c1=new Confun();            //輸出Hello World。new對象一建立，就會調用對應的構造函數Confun()，並執行其中的println語句。
    }
}
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){
        Person z=new Person("zhangsan",3);        //實例化對象時，new Person()里直接調用Person構造函數並轉轉實參，相當於setter功能
        z.show();
    }
}

class Person{
    private String name;
    private int age;
    public Person(String n,int m){                //有參數構造函數，實現給private成員變量傳參數值的功能
        name=n;
        age=m;        
    }
    //getter                                      //實例化對象時，完成了sett功能后，需要getter，獲取實參值。
    public String getName(){
        return name;
    }
    public int getAget(){
        return age;
    }
    public void show(){                           //獲取private值后，並打印輸出
        System.out.println(name+"\n"+age);
    }
}

輸出：
zhangsan
3

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

package javastudy;

public class ConfunDemo3 {
    public static void main(String[] args){
        Person z=new Person("zhangsan",3);        //實例化對象時，new Person()里直接調用Person構造函數並轉轉實參，同時執行輸出語句
    }
}

class Person{
    private String name;
    private int age;
    public Person(String n,int m){                //有參數構造函數，實現給private成員變量傳參數值的功能，同時直接輸出值
        name=n;
        age=m;
        System.out.println(name+"\n"+age);
    }
}

輸出：
zhangsan
3

 或

class ConFun
{
    public static void main(String[] args){
        Person z=new Person(20,"zhangsan");
        System.out.println(z.getAge()+z.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("李三",33);        //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+"年齡："+age);
    }
    public void setName(String x){            //set方法，用於再次給name賦值
        name=x;        
    }
    public String getName(){                //get方法，用於獲取name的賦值
        return name;
    }
    public void print(){
        System.out.println(name);
    }
}

輸出結果：

姓名：李三年齡：33
阿爾法狗

 

 

四、默認構造函數

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

如下，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("lishi");
        Person p3=new Person("lishi",10);
    }
}

輸出結果：
A:name=null:::age=0
B:name=lishi:::age=0
C:name=lishi:::age=10

 

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("Cry...............");
    }
 
}
 
class PersonDemo2
{
    public static void main(String[] args)
    {
        Person p1=new Person();
        Person p2=new Person("lishi");
        Person p3=new Person("lishi",10);
    }
}

輸出結果：
A:name=null:::age=0
Cry...............
B:name=lishi:::age=0
Cry...............
C:name=lishi:::age=10
Cry...............

 

六、構造函數的繼承

>>>>>點擊這里<<<<<