java中構造方法和方法全面解析

       構造方法和方法的區別：         

     構造方法要與類名相同，無返回類型，在類初始化的時候調用。 
     方法最好與類名不一樣，對象調用，靜態方法可用類名.方法（）.

     構造器和方法在下面三個方面區別：修飾符，返回值，命名。

       1。和方法同樣，構造器能夠有任何訪問的修飾： public, protected, private或者沒有修飾（一般被package 和 friendly調用）. 不一樣於方法的是，構造器不能有如下非訪問性質的修飾： abstract, final, native, static, 或者 synchronized。 
        2。返回類型也是很是重要的。方法能返回任何類型的值或者無返回值（void），構造器沒有返回值，也不須要void。 
        3。二者的命名。構造器使用和類相同的名字，而方法則不一樣。按照習慣，方法一般用小寫字母開始，而構造器一般用大寫字母開始。構造器一般是一個名詞，由於它和類名相同；而方法一般更接近動詞，由於它說明一個操做。

    構造方法和方法中this和supper的用法區別： 
   
    "this"的用法 
    構造器和方法使用關鍵字this有很大的區別。方法引用this指向正在執行方法的類的實例。靜態方法不能使用this關鍵字，由於靜態方法不屬於類的實  例，因此this也就沒有什麼東西去指向。構造器的this指向同一個類中，不一樣參數列表的另一個構造器，咱們看看下面的代碼： 

package com.dr.gouzao;

public class Platypus {
    String name;

    Platypus(String input) {
        name = input;
    }

    Platypus() {
        this("John/Mary Doe");
    }

    public static void main(String args[]) {
        Platypus p1 = new Platypus("digger");
        Platypus p2 = new Platypus();
        System.out.println(p1.name + "----" + p2.name);
    }
}

在上面的代碼中，有2個不一樣參數列表的構造器。第一個構造器，給類的成員name賦值，第二個構造器，調用第一個構造器，給成員變量name一個初始值 "John/Mary Doe". 

在構造器中，若是要使用關鍵字this,那麼，必須放在第一行，若是不這樣，將致使一個編譯錯誤。
在一個構造方法中只能調用一次其它的構造方法，而且調用構造方法的語句必須是第一條語句。
 

   "super"的用法 

   構造器和方法，都用關鍵字super指向超類，可是用的方法不同。方法用這個關鍵字去執行被重載的超類中的方法。看下面的例子：

package com.dr.gouzao;

class Mammal {
    void getBirthInfo() {
        System.out.println("born alive.");
    }
}

class Platypus1 extends Mammal {
    void getBirthInfo() {
        System.out.println("hatch from eggs");
        System.out.print("a mammal normally is ");
        super.getBirthInfo();
    }
    }

在上面的例子中，使用super.getBirthInfo()去調用超類Mammal中被重載的方法。 


構造器使用super去調用超類中的構造器。並且這行代碼必須放在第一行，不然編譯將出錯。看下面的例子：

public class SuperClassDemo {
    SuperClassDemo() {
    }
}

class Child extends SuperClassDemo {
    Child() {
        super();
    }
}

在上面這個沒有什麼實際意義的例子中，構造器 Child()包含了 super,它的做用就是將超類中的構造器SuperClassDemo實例化，並加到 Child類中。 

編譯器自動加入代碼 ，當咱們寫一個沒有構造器的類，編譯的時候，編譯器會自動加上一個不帶參數的構造器。

如今具體介紹一下構造方法的幾種用法：
類的繼承機制使得子類可使用父類的功能（即代碼），而且子類也具備父類的類型。下面介紹類在繼承關係上的初始化的順序問題。 
示例1：

 class SuperClass 
{ 
SuperClass() 
{ 
System.out.println("SuperClass constructor"); 
} 
} 
public class SubClass extends SuperClass 
{ 
SubClass() 
{ 
System.out.println("SubClass constructor"); 
} 
public static void main(String[] args) 
{ 
SubClass sub = new SubClass(); 
} 
}

輸出結果： SuperClass constructor 
            SubClass constructor 
　　在子類中只實例化了一個子類對象。從輸出結果上看，程序並非一開始就運行本身的構造方法，而是先運行其父類的默認構造方法。注意：程序自動調用其父類的默認構造方法。
實例2

class SuperClass 
{ 
SuperClass(String str) 
{ 
System.out.println("Super with a string."); 
} 
} 
public class SubClass extends SuperClass 
{ 
SubClass(String str) 
{ 
System.out.println("Sub with a string."); 
} 
public static void main(String[] args) 
{ 
SubClass sub = new SubClass("sub"); 
} 
}

 

在JDK下編譯此程序不能成功。正如上例中說的：程序在初始化子類時先要尋找其父類的默認構造方法，結果沒找到，那麼編譯天然不能經過。

　　解決這個問題有兩個辦法：

　　1．在父類中增長一個默認構造方法。 
　　2．在子類的構造方法中增長一條語句：super(str); 且必須在第一句。

　　這兩種方法都能使此程序經過編譯，但就本程序來講運行結果卻不相同。

　　第1種方法的運行結果是：

　　Sub with a string.

　　第2種方法的運行結果是：

    Super with a string. 
    Sub with a string.
 
　　第2種解決方法其實是指定編譯器不要尋找父類的默認構造方法，而是去尋找帶一個字符串爲參數的構造方法。

　　下面介紹對象的初始化順序問題。

　　示例3： 

class One 
{ 
One(String str) 
{ 
System.out.println(str); 
} 
} 
class Two 
{ 
One one_1 = new One("one-1"); 
One one_2 = new One("one-2"); 
One one_3 = new One("one-3"); 
Two(String str) 
{ 
System.out.println(str); 
} 
} 
public class Test 
{ 
public static void main(String[] args) 
{ 
System.out.println("Test main() start"); 
Two two = new Two("two"); 
} 
}

 

輸出結果： 
Test main() start... 
one-1 
one-2 
one-3 
two 
　　在main()方法中實例化了一個Two類的對象。但程序在初始化Two類的對象時，並不是先調用Two類的構造方法，而是先初始化Two類的成員變量。這裏Two類有3個成員變量，它們都是One類的對象，因此要先調用3次One類的相應的構造方法。最後在初始化Two類的對象。
 即在建立對象時，對象所在類的全部數據成員會首先進行初始化，若是其中的成員變量有對象，那麼它們也會按照順序執行初始化工做。在全部類成員初始化完成後，才調用對象所在類的構造方法建立對象。構造方法做用就是初始化。 



　　示例4：

class One 

{ 
One(String str) 
{ 
System.out.println(str); 
} 
} 
class Two 
{ 
One one_1 = new One("one-1"); 
One one_2 = new One("one-2"); 
static One one_3 = new One("one-3"); 
Two(String str) 
{ 
System.out.println(str); 
} 
} 
public class Test 
{ 
public static void main(String[] args) 
{ 
System.out.println("Test main() start"); 
Two two_1 = new Two("two-1"); 
System.out.println("------------"); 
Two two_2 = new Two("two-2"); 
} 
}

輸出結果： 
Test main() start... 
one-3 
one-1 
one-2 
two-1 
------------ 
one-1 
one-2 
two-2 
　　若是一個類中有靜態對象，那麼它會在非靜態對象前初始化，但只初始化一次。非靜態對象每次調用時都要初始化。
實例5

class One 
{ 
One(String str) 
{ 
System.out.println(str); 
} 
} 
class Two 
{ 
One one_1 = new One("one-1"); 
One one_2 = new One("one-2"); 
static One one_3 = new One("one-3"); 
Two(String str) 
{ 
System.out.println(str); 
} 
3 
} 
public class Test 
{ 
static Two two_3 = new Two("two-3"); 
public static void main(String[] args) 
{ 
System.out.println("Test main() start"); 
Two two_1 = new Two("two-1"); 
System.out.println("------------"); 
Two two_2 = new Two("two-2"); 
} 
}

輸出結果： 
one-3 
one-1 
one-2 
two-3 
Test main() start... 
one-1 
one-2 
two-1 
------------ 
one-1 
one-2 
two-2 
　　程序中主類的靜態變量會在main()方法執行前初始化。結果中只輸出了一次one-3，這也說明：若是一個類中有靜態對象，那麼它會在非靜態對象前初始化，但只初始化一次。非靜態對象每次調用時都要初始化。 

實例6

 class One 
{ 
One(String str) 
{ 
System.out.println(str); 
} 
} 
class Two 
{ 
static int i = 0; 
One one_1 = new One("one-1"); 
static One one_2 = new One("one-2"); 
static One one_3 = new One("one-3"); 
Two(String str) 
{ 
System.out.println(str); 
} 
} 
public class Test 
{ 
public static void main(String[] args) 
{ 
System.out.println("Test main() start"); 
System.out.println("Two.i = "  Two.i); 
} 
}

輸出結果： Test main() start... one-2 one-3 Two.i = 0 　　不只第1次建立對象時，類中全部的靜態變量要初始化，第1次訪問類中的靜態變量（沒有建立對象）時，該類中全部的靜態變量也要按照它們在類中排列的順序初始化。 初始化的順序包括構造方法調用的順序以下： 　　1．主類的靜態成員首先初始化。 　　2．主類的超類的構造方法按照從最高到最低的順序被調用。 　　3．主類的非靜態對象（變量）初始化。 　　4．調用主類的構造方法。