構造方法

構造方法(構造器)

回顧對象的創建: 

Person p = new Person();

在右側Person後面出現的小括號, 其實就是在調用構造方法 !


特點: 

    所有的Java類中都會至少存在一個構造方法 , 
    如果一個類中沒有明確的編寫構造方法,  則編譯器會自動生成一個無參的構造方法, 方法中沒有任何的代碼 !

重點: 如果自行編寫了任意一個構造器, 則編譯器, 不會再幫我們生成無參的構造器!

定義的格式: 

與普通方法基本相同, 區別在於:  方法名稱必須與類名相同, 沒有返回值類型的聲明 !

    public class Demo3{
        public static void main(String[] args){
            Person p = new Person();
            p = new Person();
            p = new Person();
            p = new Person();
        }
    }
    class Person{
        public Person(){
            System.out.println("對象創建時,此方法調用");
        }
    }


構造方法,  在創建對象時,自動調用 ! 

構造方法的作用是: 給對象初始化 !   

案例:

嘗試使用特殊的構造方法, 去創建一個對象, 並給它的屬性賦值

    public class Demo3{
        public static void main(String[] args){
            Person p = new Person("小明",18);
            p.say();
        }
    }
    class Person{
        String name;
        int age;
        public Person(String p_name,int p_age){
            name = p_name;
            age = p_age;
        }

        void say(){
            System.out.println("我是:"+name+",我今年"+age+"歲了");
        }
    }

構造方法的重載

一個類, 可以存在多個構造方法 : 

    參數列表的長度或類型不同即可完成構造方法的重載 ~ 

構造方法的重載 ,可以讓我們在不同的創建對象的需求下, 調用不同的方法來完成對象的初始化! 


例如:  

    class Person{
        int age;
        int id;
        String name;
    }

我們可以提供:  僅對id進行初始化的構造器, 也可以提供僅對年齡進行初始化的構造器,

案例: 
    class Person{
        int age;
        int id;
        String name;
        //構造方法1 , 通過這個構造方法創建的對象, 需要傳遞一個年齡
        Person(int p_age){
            age = p_age;
        }
        //構造方法2. 通過這個構造方法,  可以創建出一個所有屬性都傳遞的對象
        Person(int p_age,int p_id,String p_name){
            age = p_age;
            id = p_id;
            name = p_name;
        }
        /*構造方法3. 通過這個構造方法創建的對象,  需要傳遞一個編號(id)
        Person(int p_id){//錯誤的
            id = p_id;
        }*/

    }


在創建對象時, 我們只需要按照方法的參數列表傳遞不同的參數, 即可自動識別調用的構造方法: 


    例如使用上述的Person類: 

    當出現 new Person(整型值): 調用了一個int參數的構造器;

    當出現 new Person(整型值,整型值,字符串): 調用了: Person(int p_age,int p_id,String p_name)

構造方法的設計

建議自定義無參構造方法，不要對編譯器形成依賴，避免錯誤發生。
當類中有非常量成員變量時，建議提供兩個版本的構造方法，一個是無參構造方法，一個是全屬性做參數的構造方法。
當類中所有成員變量都是常量或者沒有成員變量時，建議不提供任何版本的構造。

方法的重載

方法的重載: 

        方法名稱相同, 參數類型或參數長度不同, 可以完成方法的重載 !  方法的重載與返回值無關!




正確案例: 


    void a(int a ,String b){
        return 1;
    }

    void a(double a, String b){

    }


規範: 

    -   方法的重載雖然與返回值類型無關, 但是建議統一返回值類型 !

    方法名  也屬於 標識符 , 方法名最好能見名知意 ! 
    方法的重載中, 所有相同方法名的方法 , 那麼它們應表達的 或者說 執行的 是大致相同的含義 !  那麼它們的返回值也應設計的完全相同 




    int sum(int a ,int b){}

    void sum(int a,int b,int c)

變量的分類

1.  基本數據類型變量
2.  引用數據類型變量


1.  成員變量
2.  局部變量



成員變量 和 局部變量的名稱可以重複 

在一個方法中使用變量 去運算時, 如果沒有編寫this關鍵字,  且局部變量名稱與成員變量名稱相同, 那麼永遠找的都是局部變量  (就近原則)



class Person{
//成員變量
    String name;

            //局部變量
    Person(String name){
        name = name;
    }

}

this關鍵字 (當前對象)

其實之前編寫的代碼, 自動的省略了一部分的內容: 

例如: 

class Person{
    String name;
    int age;
    Person(String p_name,int p_age){
        name = p_name;
        age = p_age;
    }
}

class Demo{
    public static void main(String[] args){
        Person p1 = new Person("小明",18);
        Person p2 = new Person("小帆",18);
    }
}



把省略了部分內容加上: 
class Person{
    String name;
    int age;
    Person(String p_name,int p_age){
        this.name = p_name;
        this.age = p_age;
    }
}



學習了this關鍵字後, 我們可以直接通過this這個引用, 找到當前的對象中的屬性. 那麼案例應這樣去寫: 


public class Demo8{
    public static void main(String[] args){
        Person p = new Person("小明",18);

    }
}

class Person{
    String name;
    int age;

    Person(String name,int age){
        this.name = name;
        this.age = age;
    }

    void say(){
        System.out.println("我是"+this.name+",我今年"+this.age+"歲了~");
    }
}

構造方法之間的互相調用:

構造方法之間的調用 必須存在一個出口 !
對於this的調用, 必須放到構造器的第一句代碼!

舉例: 

class HaHaInt{
    int a;
    int b;
    int c;
    int d;
    int e;  
    HaHaInt(){

    }
    HaHaInt(int a ){
        this.a = a;
    }
    HaHaInt(int a,int b ){
        this.a = a;
        this.b = b;
    }
    HaHaInt(int a,int b ,int c){
        this.a = a;
        this.b = b;
        this.c = c;
    }
    HaHaInt(int a,int b ,int c,int d){
        this.a = a;
        this.b = b;
        this.c = c;
        this.d = d;
    }
    HaHaInt(int a,int b ,int c,int d,int e){
        this.a = a;
        this.b = b;
        this.c = c;
        this.d = d;
        this.e = e;
    }


}

---------------對比 --------------------------------------


class HaHaInt{
    int a;
    int b;
    int c;
    int d;
    int e;  
    HaHaInt(){
        this(0);
    }
    HaHaInt(int a ){
        this(a,0);
    }
    HaHaInt(int a,int b ){       //new HaHaInt(1,2);
        this(a,b,0);
    }
    HaHaInt(int a,int b ,int c){
        this(a,b,c,0);
    }
    HaHaInt(int a,int b ,int c,int d){
        this(a,b,c,d,0);
    }
    HaHaInt(int a,int b ,int c,int d,int e){
        this.a = a;
        this.b = b;
        this.c = c;
        this.d = d;
        this.e = e;
        this();

        //無論用戶調用哪個構造方法,  那麼這個方法一定會執行 !
        //  那麼我們就可以在這裏加入一些, 共性的代碼!
    }

}


public class Demo7{
    public static void main(String[] args){
        Person p = new Person();
        p.say();
        p.say(1);
        p.say("...");
        p.say(2,"...");
    }
}

class Person{
    String name;
    int age;
    void say(){
        System.out.println("哈哈哈");
    }

    void say(int a){
        System.out.println("嘿嘿嘿"+a);
    }

    void say(String text){
        System.out.println("呵呵呵"+text);
    }

    void say(int a,String text){
        System.out.println("6666666"+a+text);
    }
}

常量

int a = 10;

final(最終的) 修飾符

經過final修飾的變量 ,就成了常量!  

常量的特點就是 值無法改變 !

經過final修飾的變量 只能 賦值一次 !


例如: 

    final int a = 0;

    a = 1;


    0--------------------


    final int a ;

    a = 10;

引用數據類型的默認值爲null

引用數據類型,  尚未賦值時,  不可調用其方法與屬性: 

    例如 : 


    Person p = null;

    p.say();


    出現了錯誤: NullPointerException


    例如: 

    Person p = new Person();

    p = null;

    p.say();

    出現了錯誤: NullPointerException