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)