Java：類的構造函數

類的構造函數

 

• 類的構造函數特色：

        1. 構造函數也稱爲構造方法，構造函數名和類名相同。
      2. 構造函數不能有返回值，也不能用void聲明。

　　　 3. 構造函數能夠有參數，也能夠無參數，在一個類中，能夠定義多個構造函數。

    4. 構造函數主要是對類進行初始化，在new的時候調用。

    5. 任何一個類對象被生成時必定會調用該類的構造函數。

    6. 不管一個類中定義了多少個構造函數，在生成類對象時必定只會調用其中的某一個構造函數。

    7. 全部的類都有構造函數，在定義一個類時，若是你不定義構造函數，則系統默認生成一個空的構造函數，若是你本身定義了構造函數，則系統默認的構造函數就失效。

    8. 建立類對象語句：A aa = new A(); 其實new後面的A()就是構造函數。

 

---

• 構造函數的返回值問題：

    1. 在一個類中，能夠定義多個函數名和類名相同但有返回值的函數，返回值能夠爲void或int或String或double等任意類型，這些有返回值的函數只要能知足重載特色，就能夠同時存在一個類中，不過這些有返回值的函數(包括返回值爲void的函數)都不是構造函數，在生成類對象時都不會被調用。

   2. 若是定義了有返回值而且函數名和類名相同的函數，程序並不會報錯，並且這種函數也能夠和普通函數同樣被調用，可是容易產生歧義，最好不要定義這種函數。

1.  1 /**
    2     @author   zst
    3     @version  1.0
    4     
    5 */
    6 public class A{
    7     /*
    8         下面三個函數的函數名都和類名相同，但都不是構造函數
    9         三個函數都知足重載的特色，因此能夠同時存在同一個類中
   10     */
   11     
   12     //不是構造函數,
   13     public void A(){
   14         System.out.println("調用了返回值爲void，函數名爲A的函數");
   15     }
   16     
   17     //不是構造函數
   18     public int A(int i){
   19         System.out.println("調用了返回值爲int，函數名爲A的函數");
   20         return i;
   21     }
   22     
   23     //不是構造函數
   24     public String A(String s){
   25         System.out.println("調用了返回值爲String，函數名爲A的函數");
   26         return s;
   27     }
   28     
   29 }

    1 /**
    2     @author   zst
    3     @version  1.0
    4     
    5 */
    6 public class ConstructorTest{
    7     public static void main(String[] args){
    8         
    9         A aa = new A(); //這裏調用的構造方法是系統默認的爲空的構造方法
   10         
   11         aa.A();
   12         aa.A(0);
   13         aa.A("hello");
   14         
   15     }
   16     
   17 }
   18 /*
   19     輸出：
   20         調用了返回值爲void，函數名爲A的函數
   21         調用了返回值爲int，函數名爲A的函數
   22         調用了返回值爲String，函數名爲A的函數
   23 */

---

• 構造函數調用

    當類中定義了多個構造函數，建立類對象時，只能指定調用某一個構造函數。

1.  1 /**
    2     @author   zst
    3     @version  1.0
    4     
    5 */
    6 public class A{
    7     public A(){
    8         System.out.println("調用了無參構造函數建立對象");
    9         
   10     }
   11     
   12     public A(int i)
   13     {
   14         System.out.println("調用了一個參數的構造函數建立對象");
   15         
   16     }
   17     
   18     public A(int i,int j)
   19     {
   20         System.out.println("調用了兩個參數的構造函數建立對象");
   21     }
   22     
   23     
   24 }
   25 /**
   26     @author   zst
   27     @version  1.0
   28     
   29 */
   30 public class ConstructorTest02{
   31     public static void main(String[] args){
   32         
   33         A aa1 = new A(); 
   34         
   35         A aa2 = new A(0);
   36         
   37         A aa3 = new A(1,2);
   38         
   39     }
   40     
   41 }
   42 /*
   43     輸出：
   44         調用了無參構造函數建立對象
   45         調用了一個參數的構造函數建立對象
   46         調用了兩個參數的構造函數建立對象
   47 */

    

---

• 在建立對象時，數據成員的初始化賦值問題

    1. 若是數據成員在定義時不初始化，當一個對象被建立時，數據成員會被系統默認賦給一個默認值。各類類型的數據成員初始化默認值以下：

數據成員類型	默認初始化
byte	0
short	0
int	0
long	0L
float	0.0F
double	0.0D
char	'\u0000' (表示爲空)
boolean	false
引用類型	null

 

    2. 若是數據成員在定義的同時賦初始值，則這個初始值是有效的，但若是在構造函數中又改變了定義時賦的初值，則該數據成員最終的值就是構造函數中修改以後的那個值，這是由於當調用構造函數建立對象時，會先給數據成員進行初始化，若是數據成員在定義時賦了值，則此時數據成員的初值爲定義時賦給它的值，而後接着執行構造函數裏的賦值語句，從新修改數據成員的初始化值。

1.  1 /**
    2     @author   zst
    3     @version  1.0
    4     
    5 */
    6 public class A{
    7   //沒有初始化的數據成員
    8   private int i;
    9   private String s;
   10   private double d;
   11   
   12   //初始化的數據成員
   13   private float f = 11.1f;
   14   private boolean b = false;
   15   
   16   
   17   //無參構造函數
   18   public A(){
   19   
   20   }
   21   
   22   
   23   public void f(){
   24   
   25     System.out.println("沒有初始化的數據成員，系統賦予默認值");
   26     System.out.println(i);
   27     System.out.println(s);
   28     System.out.println(d);
   29     
   30   }
   31   
   32   public void g(){
   33     System.out.println("初始化的數據成員，初始化的值是有效的");
   34     System.out.println(f);
   35     System.out.println(b);
   36     
   37   }
   38   
   39   //有參構造函數，修改初始化時的值，數據成員最終的值是修改後的值
   40   public A(float f,boolean b)
   41   {
   42         f = f;
   43         b = b;
   44         
   45         System.out.println("在構造函數中修改數據成員的初始化值，數據成員最終的值爲修改後的值");
   46         System.out.println(f);
   47         System.out.println(b);
   48   }
   49   
   50   
   51     
   52 }
   53 /**
   54     @author   zst
   55     @version  1.0
   56     
   57 */
   58 public class ConstructorTest03{
   59     public static void main(String[] args){
   60         
   61         A aa1 = new A(); 
   62         aa1.f();
   63         aa1.g();
   64         
   65         A aa2 = new A(99.9f,true);
   66         
   67         
   68     }
   69     
   70     
   71 }
   72 /*
   73     輸出：
   74         沒有初始化的數據成員，系統賦予默認值
   75         0
   76         null
   77         0.0
   78         初始化的數據成員，初始化的值是有效的
   79         11.1
   80         false
   81         在構造函數中修改數據成員的初始化值，數據成員最終的值爲修改後的值
   82         99.9
   83         true
   84 */

    3. 須要注意的一點：對於一個類的數據成員，若是定義時不初始化，則建立對象時，系統就會自動賦給默認的初始值，但對於局部變量，如在定義時不初始化而直接使用，則編譯時就會報錯，由於Java中要求全部的局部變量在使用以前都必需要初始化。

 1 /**
 2     @author   zst
 3     @version  1.0
 4     
 5 */
 6 public class A{
 7       //沒有初始化的數據成員
 8       private int i;
 9       private String s;
10       private double d;
11       
12       //無參構造函數
13       public A(){
14       
15       }
16       
17       
18       public void f(){
19       
20         System.out.println("沒有初始化的數據成員，系統賦予默認值,能夠直接使用");
21         System.out.println(i);
22         System.out.println(s);
23         System.out.println(d);
24         
25       }
26  
27     public void g()
28     {
29         int i = 100;    //局部變量：在使用以前必需要初始化，不然編譯出錯
30         System.out.println("局部變量使用以前必需要初始化  " + i); 
31     }
32     
33 }
34 /**
35     @author   zst
36     @version  1.0
37     
38 */
39 public class ConstructorTest04{
40     public static void main(String[] args){
41         
42         A aa1 = new A(); 
43         aa1.f();
44         aa1.g();   
45         
46     }
47     
48     
49 }
50 /*
51     輸出：
52         沒有初始化的數據成員，系統賦予默認值,能夠直接使用
53         0
54         null
55         0.0
56         局部變量使用以前必需要初始化  100
57         
58 */

 

---

 

來自爲知筆記(Wiz)