一、java中方法間的值傳遞相關

1、常量值傳遞

public static void main(String[] args) {
    int num1 = 10;
    int num2 = 20;

    swap(num1, num2);

    System.out.println("num1 = " + num1);
    System.out.println("num2 = " + num2);
}

public static void swap(int a, int b) {
    int temp = a;
    a = b;
    b = temp;

    System.out.println("a = " + a);
    System.out.println("b = " + b);
}

• 結果

a = 20
b = 10
num1 = 10
num2 = 20

2、數據傳遞

public static void main(String[] args) {
    int[] arr = { 1, 2, 3, 4, 5 };
    System.out.println(arr[0]);
    change(arr);
    System.out.println(arr[0]);
}

public static void change(int[] array) {
    // 將數組的第一個元素變為0
    array[0] = 0;
}

• 結果

1
0

3、對象傳遞，并修改對象屬性值

public static void main(String[] args) {
    Student student = new Student("小張");
    System.out.println(student.getName());
    changgeName(student);
    System.out.println(student.getName());
}

public static void changgeName(Student student) {
    student.setName("小五");
}

• 結果

小張
小五

4、對象傳遞，讓對象參數引用一個新的對象(結果：不可修改)

public static void main(String[] args) {
    // TODO Auto-generated method stub
    Student s1 = new Student("小張");
    Student s2 = new Student("小李");
    Test.swap(s1, s2);
    System.out.println("s1:" + s1.getName());
    System.out.println("s2:" + s2.getName());
}

public static void swap(Student x, Student y) {
    Student temp = x;
    x = y;
    y = temp;
    System.out.println("x:" + x.getName());
    System.out.println("y:" + y.getName());
}

• 結果

x:小李
y:小張
s1:小張
s2:小李

總結

• Java 程序設計語言對對象采用的不是引用調用，實際上，對象引用是按 值傳遞的

• Java 中方法參數的使用情況：

  • 一個方法不能修改一個基本數據類型的參數（即數值型或布爾型）
  • 一個方法可以改變一個對象參數的狀態
  • 一個方法不能讓對象參數引用一個新的對象

二、構造器

1、不可別重寫

• Constructor 不能被 override（重寫）,但是可以 overload（重載）,所以你可以看到一個類中有多個構造函數的情況

2、在 Java 無參構造器的作用

Java 程序在執行子類的構造方法之前，如果沒有用 super()來調用父類特定的構造方法，則會調用父類中“沒有參數的構造方法”。因此，如果父類中只定義了有參數的構造方法，而在子類的構造方法中又沒有用 super()來調用父類中特定的構造方法，則編譯時將發生錯誤，因為 Java 程序在父類中找不到沒有參數的構造方法可供執行。解決辦法是在父類里加上一個不做事且沒有參數的構造方法。

3、構造器的作用

• 主要作用是完成對類對象的初始化工作
• 如果一個類不定義構造器，也會有一個默認的無參構造器
• 如果我們添加的構造器（無論是有參構造器，還是無參構造器），java就不會再添加默認無參構造器

4、構造器的特性

• 名字與類名相同
• 沒有返回值，但不能用 void 聲明構造函數
• 生成類的對象時自動執行，無需調用

public Student() {

}

public Student(String name) {
    this.name = name;
}

三、成員變量與局部變量的區別

1、區別

• 成員變量可以被 public,private,static 等修飾符所修飾

• 局部變量不能被訪問控制修飾符及 static 所修飾

• 成員變量和局部變量都能被 final 所修飾

• 從變量在內存中的存儲方式來看:如果成員變量是使用static修飾的，那么這個成員變量是屬于類的，如果沒有使用static修飾，這個成員變量是屬于實例的。而對象存在于堆內存，局部變量則存在于棧內存

• 從變量在內存中的生存時間上看:成員變量是對象的一部分，它隨著對象的創建而存在，而局部變量隨著方法的調用而自動消失。

• 成員變量如果沒有被賦初值:則會自動以類型的默認值而賦值（一種情況例外:被 final 修飾的成員變量也必須顯式地賦值），而局部變量則不會自動賦值。

四、對象

1、創建與存儲

• new 創建對象實例（對象實例在堆內存中）

• 對象引用指向對象實例（對象引用存放在棧內存中）

• 一個對象引用可以指向 0 個或 1 個對象（一根繩子可以不系氣球，也可以系一個氣球）

• 一個對象可以有 n 個引用指向它（可以用 n 條繩子系住一個氣球）

2、對象的比較

• 對象的相等，比的是內存中存放的內容是否相等

• 引用相等，比較的是他們指向的內存地址是否相等

五、面向對象三大特征

1、封裝

• 把一個對象的狀態信息（也就是屬性）隱藏在對象內部，不允許外部對象直接訪問對象的內部信息

• 提供一些可以被外界訪問的方法來操作屬性

2、繼承

不同類型的對象，相互之間經常有一定數量的共同點，同時，每一個對象還定義了額外的特性使得他們與眾不同

• 使用繼承，可以提高代碼的重用，程序的可維護性，節省大量創建新類的時間 ，提高我們的開發效率

• 子類擁有父類對象所有的屬性和方法（包括私有屬性和私有方法），但是父類中的私有屬性和方法子類是無法訪問只是擁有

• 子類可以擁有自己屬性和方法，即子類可以對父類進行擴展

• 子類可以用自己的方式實現父類的方法

3、多態

一個對象具有多種的狀態。具體表現為父類的引用指向子類的實例。特點如下：

• 對象類型和引用類型之間具有繼承（類）/實現（接口）的關系

• 引用類型變量發出的方法調用的到底是哪個類中的方法，必須在程序運行期間才能確定

• 多態不能調用“只在子類存在但在父類不存在”的方法

• 如果子類重寫了父類的方法，真正執行的是子類覆蓋的方法，如果子類沒有覆蓋父類的方法，執行的是父類的方法

六、靜態方法

• 由于靜態方法可以不通過對象進行調用，因此在靜態方法里，不能調用其他非靜態變量，也不可以訪問非靜態變量成員

• 在外部調用靜態方法時，可以使用"類名.方法名"的方式，也可以使用"對象名.方法名"的方式而實例方法只有"對象名.方法名"這種方式。也就是說，調用靜態方法可以無需創建對象

public class Student {

    public static String name() {
        return "同學";
    }
}

public class Test {
    public static void main(String[] args) {
        System.out.println(s1.name());
        System.out.println(Student.name());
    }
}

同學
同學

七、String、StringBuffer、StringBuilder

1、是否可變

• String不可變：

String 類中使用 final 關鍵字修飾字符數組來保存字符串，private final char value[]，所以String 對象是不可變的。

• StringBuilder 與 StringBuffer 可變：

StringBuilder 與 StringBuffer 都繼承自 AbstractStringBuilder 類，在 AbstractStringBuilder 中也是使用字符數組保存字符串char[]value 但是沒有用 final 關鍵字修飾，所以這兩種對象都是可變的。

在 Java 9 之后，String 、StringBuilder 與 StringBuffer 的實現改用 byte 數組存儲字符串 private final byte[] value

2、線程安全

• String 中的對象是不可變的，也就可以理解為常量，String線程安全

• StringBuffer 線程安全， StringBuilder 不是線程安全

AbstractStringBuilder 是 StringBuilder 與 StringBuffer 的公共父類,StringBuffer 對方法加了同步鎖或者對調用的方法加了同步鎖，所以是線程安全的。StringBuilder 并沒有對方法進行加同步鎖，所以是非線程安全的。

3、性能

• 每次對 String 類型進行改變的時候，都會生成一個新的 String 對象，然后將指針指向新的 String 對象（操作少量的數據: 適用String）

• StringBuffer 每次都會對 StringBuffer 對象本身進行操作，而不是生成新的對象并改變對象引用（多線程操作字符串緩沖區下操作大量數據: 適用StringBuffer）

• 相同情況下使用 StringBuilder 相比使用 StringBuffer 僅能獲得 10%~15% 左右的性能提升，但卻要冒多線程不安全的風險（單線程操作字符串緩沖區下操作大量數據: 適用StringBuilder）

4、replace、replaceAll注意事項

<replace、replaceAll方法執行后必須要有String對象去接，因為String實質上是final類型，所以直接使用name.replaceAll("\r|\n", "")時，并不會修改name自身的值信息，而是生成一個新的String

public static void main(String[] args) {
    String name = "412201207017303龍井市\r智新鎮衛生院\n折騰";

    System.out.println(name);

    // name.replaceAll("\r|\n", ""); 如果只是這樣寫，不生效
    name = name.replaceAll("\r|\n", "");

    System.out.println(name);
}

八、try-catch-finally

1、基本作用

• try塊：用于捕獲異常。其后可接零個或多個 catch 塊，如果沒有 catch 塊，則必須跟一個 finally 塊。

• catch塊：用于處理 try 捕獲到的異常。

• finally 塊：無論是否捕獲或處理異常，finally 塊里的語句都會被執行。當在 try 塊或 catch 塊中遇到 return 語句時，finally 語句塊將在方法返回之前被執行，即，放回結果為finally中的return信息

public class Test {
    public static int f(int value) {
        try {
            return value * value;
        } finally {
            if (value == 2) {
                return 0;
            }
        }
    }
}

如果調用 f(2)，返回值將是 0，因為 finally 語句的返回值覆蓋了 try 語句塊的返回值

2、finally 塊不會被執行

• 在 try 或 finally 塊中用了 System.exit(int)退出程序。但是，如果 System.exit(int) 在異常語句之后，finally 還是會被執行

• 程序所在的線程死亡

• 關閉 CPU

其他情況下都會執行finally中的信息