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.  /**
        @author   zst
        @version  1.0
   
    */
    public class A{
        /*
            下面三个函数的函数名都和类名相同，但都不是构造函数
            三个函数都满足重载的特点，所以可以同时存在同一个类中
        */
   
        //不是构造函数,
        public void A(){
            System.out.println("调用了返回值为void，函数名为A的函数");
        }
   
        //不是构造函数
        public int A(int i){
            System.out.println("调用了返回值为int，函数名为A的函数");
            return i;
        }
   
        //不是构造函数
        public String A(String s){
            System.out.println("调用了返回值为String，函数名为A的函数");
            return s;
        }
   
    }

    /**
        @author   zst
        @version  1.0
   
    */
    public class ConstructorTest{
        public static void main(String[] args){
   
            A aa = new A(); //这里调用的构造方法是系统默认的为空的构造方法
   
            aa.A();
            aa.A(0);
            aa.A("hello");
   
        }
   
    }
    /*
        输出：
            调用了返回值为void，函数名为A的函数
            调用了返回值为int，函数名为A的函数
            调用了返回值为String，函数名为A的函数
    */

---

• 构造函数调用

    当类中定义了多个构造函数，创建类对象时，只能指定调用某一个构造函数。

1.  /**
        @author   zst
        @version  1.0
   
    */
    public class A{
        public A(){
            System.out.println("调用了无参构造函数创建对象");
   
        }
   
        public A(int i)
        {
            System.out.println("调用了一个参数的构造函数创建对象");
   
        }
   
        public A(int i,int j)
        {
            System.out.println("调用了两个参数的构造函数创建对象");
        }
   
    }
    /**
        @author   zst
        @version  1.0
   
    */
    public class ConstructorTest02{
        public static void main(String[] args){
   
            A aa1 = new A(); 
   
            A aa2 = new A(0);
   
            A aa3 = new A(1,2);
   
        }
   
    }
    /*
        输出：
            调用了无参构造函数创建对象
            调用了一个参数的构造函数创建对象
            调用了两个参数的构造函数创建对象
    */

---

• 在创建对象时，数据成员的初始化赋值问题

    1. 如果数据成员在定义时不初始化，当一个对象被创建时，数据成员会被系统默认赋给一个默认值。各种类型的数据成员初始化默认值如下：

数据成员类型	默认初始化
byte	0
short	0
int	0
long	0L
float	0.0F
double	0.0D
char	'\u0000' (表示为空)
boolean	false
引用类型	null

 

    2. 如果数据成员在定义的同时赋初始值，则这个初始值是有效的，但如果在构造函数中又改变了定义时赋的初值，则该数据成员最终的值就是构造函数中修改之后的那个值，这是因为当调用构造函数创建对象时，会先给数据成员进行初始化，如果数据成员在定义时赋了值，则此时数据成员的初值为定义时赋给它的值，然后接着执行构造函数里的赋值语句，重新修改数据成员的初始化值。

1.  /**
        @author   zst
        @version  1.0
   
    */
    public class A{
      //没有初始化的数据成员
      private int i;
      private String s;
      private double d;
   
      //初始化的数据成员
      private float f = 11.1f;
      private boolean b = false;
   
      //无参构造函数
      public A(){
   
      }
   
      public void f(){
   
        System.out.println("没有初始化的数据成员，系统赋予默认值");
        System.out.println(i);
        System.out.println(s);
        System.out.println(d);
   
      }
   
      public void g(){
        System.out.println("初始化的数据成员，初始化的值是有效的");
        System.out.println(f);
        System.out.println(b);
   
      }
   
      //有参构造函数，修改初始化时的值，数据成员最终的值是修改后的值
      public A(float f,boolean b)
      {
            f = f;
            b = b;
   
            System.out.println("在构造函数中修改数据成员的初始化值，数据成员最终的值为修改后的值");
            System.out.println(f);
            System.out.println(b);
      }
   
    }
    /**
        @author   zst
        @version  1.0
   
    */
    public class ConstructorTest03{
        public static void main(String[] args){
   
            A aa1 = new A();
            aa1.f();
            aa1.g();
   
            A aa2 = new A(99.9f,true);
   
        }
   
    }
    /*
        输出：
            没有初始化的数据成员，系统赋予默认值
            0
            null
            0.0
            初始化的数据成员，初始化的值是有效的
            11.1
            false
            在构造函数中修改数据成员的初始化值，数据成员最终的值为修改后的值
            99.9
            true
    */

    3. 需要注意的一点：对于一个类的数据成员，如果定义时不初始化，则创建对象时，系统就会自动赋给默认的初始值，但对于局部变量，如在定义时不初始化而直接使用，则编译时就会报错，因为Java中要求所有的局部变量在使用之前都必须要初始化。

 /**
     @author   zst
     @version  1.0

 */
 public class A{
       //没有初始化的数据成员
       private int i;
       private String s;
       private double d;

       //无参构造函数
       public A(){

       }

       public void f(){

         System.out.println("没有初始化的数据成员，系统赋予默认值,可以直接使用");
         System.out.println(i);
         System.out.println(s);
         System.out.println(d);

       }

     public void g()
     {
         int i = 100;    //局部变量：在使用之前必须要初始化，否则编译出错
         System.out.println("局部变量使用之前必须要初始化  " + i);
     }

 }
 /**
     @author   zst
     @version  1.0

 */
 public class ConstructorTest04{
     public static void main(String[] args){

         A aa1 = new A();
         aa1.f();
         aa1.g();   

     }

 }
 /*
     输出：
         没有初始化的数据成员，系统赋予默认值,可以直接使用
         0
         null
         0.0
         局部变量使用之前必须要初始化  100

 */

---

 

来自为知笔记(Wiz)