構建語言生態的優勢，彌補其存在短板，始終是程式語言的一個演進方向。

1999年，美國太空總署（NASA）的火星任務失敗：在這次任務中，火星氣候探測者號上的飛行系統軟體使用公制單位牛頓計算推進器動力，而地面人員輸入的方向校正量和推進器引數則使用英制單位磅力，導致探測器進入大氣層的高度有誤，最終瓦解碎裂。

2.1 關於命名

• 蛇形命名法（snake case）：又叫下劃線命名法，使用下劃線，單詞小寫，比如：my_system;
• 駝峰命名法（camel case）：按照單詞首字母區分大小寫，又可細分為大駝峰命名法和小駝峰命名法，比如：MySystem，mySystem;
• 匈牙利命名法（HN case）：屬性+型別+描述，比如：nLength，g_cch,hwnd；
• 帕斯卡命名法（Pascal case）：全部首字母大寫，等同於大駝峰命名法，比如：MySystem；
• 脊柱命名法（spinal case）：使用中劃線，比如：my-system；
• 自由命名法（studly caps）：大小寫混雜，無簡明規則，比如：mySYSTEM，MYSystem；

2.1.1 命名字典

2.1.2 命名實踐

1. 專案名全部小寫；
2. 包名全部小寫；
3. 類名首字母大寫,其餘組成詞首字母依次大寫；
4. 變數名,方法名首字母小寫,如果名稱由多個單片語成,除首字母外的每個單詞首字母都要大寫；
5. 常量名全部大寫；

1. 自帶混淆功能的變數名：String zhrmghg = "極致縮寫型";
2. 沒有意義的萬能變數名：String a,b,c="愛誰誰型";
3. 長串拼音變數名：String HuaBuHua = "考古型";
4. 各種符號混用：String $my_first_name_ = "打死記不住型";
5. 大小寫，數字，縮寫混亂：String waitRPCResponse1 = "極易出錯型";

    public <PropertyType> get<PropertyName>();    public void set<PropertyName>(<PropertyType> p)

    public boolean is<PropertyName>();    public void set<PropertyName>(boolean p)

• 一類是同一個jar包出現了多個不同的版本。應用選擇了錯誤的版本導致jvm載入不到需要的類或者載入了錯誤版本的類；（藉助maven管理工具相對容易解決）
• 另一類是不同的jar包出現了類路徑相同的類，同樣的類出現在不同的依賴jar裡，由於jar載入的先後順序導致了JVM載入了錯誤版本的類；（比較難以解決）

public class SkuKey implements Serializable {    @JsonProperty(value = "sn")    @ApiModelProperty(name = "stationNo", value = " 門店編號", required = true)    private Long stationNo;    @JsonProperty(value = "si")    @ApiModelProperty(name = "skuId", value = " 商品編號", required = true)    private Long skuId;    // 省略get/set方法}

2.2 關於註釋

2.2.1 好的註釋

1. 系統註釋：透過README.md檔案體現宏觀的功能和架構實現；
2. 包註釋：透過package-info檔案體現模組職責邊界，另外該檔案也支援宣告友好類，包常量以及為標註在包上的註解（Annotation）提供便利；
3. 類註釋：主要體現功能職責，版本支援，作者歸屬，應用示例等相關資訊；
4. 方法註釋：關注入參，出參，異常處理宣告，使用場景舉例等相關內容；
5. 程式碼塊和程式碼行註釋：主要體現邏輯意圖，閉坑警示，規劃TODO，放大關注點等細節內容；

2.2.2 壞的註釋

1. 冗餘式：如果一個函式，讀者能夠很容易的就讀出來程式碼要表達的意思，註釋就是多餘的；
2. 錯誤式：如果註釋地不清楚，甚至出現歧義，那還不如不寫；
3. 簽名式：類似“add by liuhuiqing 2023-08-05”這種註釋，容易過期失效而且不太可信（不能保證所有人每次都採用這種方式註釋），其功能完全可以由git程式碼管理工具來實現；
4. 長篇大論式：程式碼塊裡，夾雜了大篇幅的註釋，不僅影響程式碼閱讀，而且維護困難；
5. 非本地註釋：註釋應該在離程式碼實現最近的地方，比如：被呼叫的方法註釋就由方法本身來維護，呼叫方無需對方法做詳細的說明；
6. 註釋掉的程式碼：無用的程式碼應該刪除，而不是註釋。歷史記錄交給git等程式碼管理工具來維護；

2.3 關於分層

2.3.1 系統分層

2.3.2 軟體伸縮性

軟體伸縮性指的是軟體系統在面對負載壓力時，能夠保持原有效能並擴充套件以支援更多工的能力。

伸縮性可以有兩個方面，垂直伸縮性和水平伸縮性，垂直伸縮性是透過在同一個業務單元中增加資源來提高系統的吞吐量，比如增加伺服器cpu的數量，增加伺服器的記憶體等。水平伸縮性是透過增加多個業務單元資源，使得所有的業務單元邏輯上就像是一個單元一樣。比如ejb分散式元件模型，微服務元件模型等都屬於此種方式。

2.4 小結

3.1 類定義

3.1.1 常量定義

public enum Color { RED, GREEN, BLUE;}

public class MyClass { public static final int MAX_VALUE = 100;}

3.1.2 工具類

public abstract class ObjectHelper {    public static boolean isEmpty(String str) {        return str == null || str.length() == 0;    }}

3.1.3 JavaBean

public class Person { private String name; private int age;
 public Person(String name, int age) { this.name = name; this.age = age; }
 public String getName() { return name; }
 public void setName(String name) { this.name = name; }
 public int getAge() { return age; }
 public void setAge(int age) { this.age = age; }}

import lombok.Data;
@NoArgsConstructor@Data@Accessors(chain = true)public class Person {    private String name;    private int age;}

3.1.4 不可變類

public final class String implements Serializable, Comparable<String>, CharSequence {
}

java.lang.Stringjava.lang.Mathjava.lang.Booleanjava.lang.Characterjava.util.Datejava.sql.Datejava.lang.Systemjava.lang.ClassLoader

3.1.5 匿名內部類

1. 直接作為引數傳遞給方法或建構函式；

2. 用於實現某個介面或抽象類的匿名例項；

public class Example {    public static void main(String[] args) {        // 建立一個匿名內部類        Runnable runnable = new Runnable() {            @Override            public void run() {                System.out.println("Hello, World!");            }        };        // 呼叫匿名內部類的方法        runnable.run();    }}

3.1.6 宣告類

• AutoCloseable：表示實現了該介面的類可以被自動關閉，通常用於資源管理。
• Comparable：表示實現了該介面的類可以與其他實現了該介面的物件進行比較。
• Callable：表示實現了該介面的類可以作為引數傳遞給執行緒池，並返回結果。
• Cloneable：表示實現了該介面的類可以被克隆。
• Enum：表示實現了該介面的類是一個列舉型別。
• Iterable：表示實現了該介面的類可以迭代。
• Runnable：表示實現了該介面的類可以作為執行緒執行。
• Serializable：表示實現了該介面的類可以被序列化和反序列化。
• interface：表示實現了該介面的類是一個介面，可以包含方法宣告。
• Annotation：表示實現了該介面的類是一個註解，可以用於後設資料描述。

3.1.7 Record 類

/** * 關鍵定義的類是不可變類 * 將所有成員變數透過引數的形式定義 * 預設會生成全部引數的構造方法 * @param name * @param age */public record Person(String name, int age) {    public Person{        if(name == null){            throw new IllegalArgumentException("提供緊湊的方式進行引數校驗");        }    }    /**     * 定義的類中可以定義靜態方法     * @param name     * @return     */    public static Person of(String name) {        return new Person(name, 18);    }}

Person person = new Person("John", 30);// Person person = Person.of("John");String name = person.name();int age = person.age();

public List<Person> sortPeopleByAge(List<Person> people) {
    record Data(Person person, int age){};
    return people.stream()                .map(person -> new Data(person, computAge(person)))                .sorted((d1, d2) -> Integer.compare(d2.age(), d1.age()))                .map(Data::person)                .collect(toList());}public int computAge(Person person) {    return person.age() - 1;}

3.1.8 密封類

1. final修飾類，這樣類就無法被繼承了；
2. package-private類，可以控制只能被同一個包下的類繼承；

sealed class SealedClass permits SubClass1, SubClass2 {
}
class SubClass1 extends SealedClass {
}
class SubClass2 extends SealedClass {
}

3.2 方法定義

3.2.1 構造方法

public class MyClass {    private int myInt;    private String myString;
    // 構造方法    public MyClass(int myInt, String myString) {        this.myInt = myInt;        this.myString = myString;    }}

3.2.2 方法重寫

class Animal {    public void makeSound() {        System.out.println("Animal is making a sound");    }}
class Cat extends Animal {    @Override    public void makeSound() {        System.out.println("Meow");    }}
public class Main {    public static void main(String[] args) {        Animal myCat = new Cat();        myCat.makeSound(); // 輸出 "Meow"    }}

3.2.3 方法過載

public class Calculator {    public int add(int a, int b) {        return a + b;    }
    public double add(double a, double b) {        return a + b;    }}
public class Main {    public static void main(String[] args) {        Calculator calculator = new Calculator();        int result1 = calculator.add(2, 3);        double result2 = calculator.add(2.5, 3.5);        System.out.println(result1); // 輸出 5        System.out.println(result2); // 輸出 6.0    }}

3.2.4 匿名方法

public static void main(String args[]) {    List<String> names = Arrays.asList("hello", "world");    // 使用 Lambda 表示式作為引數傳遞給 forEach 方法    names.forEach((String name) -> System.out.println("Name: " + name));
    // 使用 Lambda 表示式作為獨立表示式使用    Predicate<String> nameLengthGreaterThan5 = (String name) -> name.length() > 5;    boolean isLongName = nameLengthGreaterThan5.test("John");    System.out.println("Is long name? " + isLongName);}

3.3 物件定義

3.3.1 單例物件

1. 控制資源的使用：透過執行緒同步來控制資源的併發訪問。
2. 控制例項產生的數量：達到節約資源的目的。
3. 作為通訊媒介使用：也就是資料共享，它可以在不建立直接關聯的條件下，讓多個不相關的兩個執行緒或者程式之間實現通訊。

public enum Singleton { INSTANCE;  public void someMethod() { // ...其他程式碼... }}

3.3.2 不可變物件

1. 將物件的狀態儲存在不可變物件中：String、Integer等就是內建的不可變物件型別；
2. 將物件的狀態儲存在final變數中：final變數一旦被賦值就不能被修改；
3. 將物件的所有屬性都設為不可變物件：這樣就可以確保整個物件都是不可變的；

Collections.unmodifiableList(new ArrayList<>());

3.3.3 元組物件

public class Pair<A,B> {    public final A first;    public final B second;
    public Pair(A a, B b) {        this.first = a;        this.second = b;    }
    public A getFirst() {        return first;    }
    public B getSecond() {        return second;    }}

public class Triplet<A,B,C> extends Pair<A,B>{    public final C third;
    public Triplet(A a, B b, C c) {        super(a, b);        this.third = c;    }
    public C getThird() {        return third;    }
    public static void main(String[] args) {        // 表示姓名，性別，年齡        Triplet<String,String,Integer> triplet = new Triplet("John","男",18);        // 獲得姓名        String name = triplet.getFirst();    }
}

public class Tuple<E> {    private final E[] elements;
    public Tuple(E... elements) {        this.elements = elements;    }
    public E get(int index) {        return elements[index];    }
    public int size() {        return elements.length;    }    public static void main(String[] args) {        // 表示姓名，性別，年齡        Tuple<String> tuple = new Tuple<>("John", "男", "18");        // 獲得姓名        String name = tuple.get(0);    }}

1. 儲存多個資料元素：Tuple可以儲存多個不同型別的資料元素，這些元素可以是基本型別、物件型別、陣列等；
2. 簡化程式碼：Tuple可以使程式碼更加簡潔，減少重複程式碼的編寫。透過Tuple，我們可以將多個變數打包成一個物件，從而減少了程式碼量；
3. 提高程式碼可讀性：Tuple可以提高程式碼的可讀性。透過Tuple，我們可以將多個變數打包成一個物件，從而使程式碼更加易讀；
4. 支援函式返回多個值：Tuple可以支援函式返回多個值。在Java中，函式只能返回一個值，但是透過Tuple，我們可以將多個值打包成一個物件返回；

NamedTuple namedTuple = Tuples.named("person", "name", "age");

3.3.4 臨時物件

1. 儘量重用物件。由於系統不僅要花時間生成物件，以後可能還需花時間對這些物件進行垃圾回收和處理，因此，生成過多的物件將會給程式的效能帶來很大的影響，重用物件的策略有快取物件，也可以針對具體場景進行定向最佳化，比如使用StringBuffer代替字串拼接的方式；
2. 儘量使用區域性變數。呼叫方法時傳遞的引數以及在呼叫中建立的臨時變數都儲存在棧中，速度較快。其他變數，如靜態變數、例項變數等，都在堆中建立，速度較慢；
3. 分代收集。分代垃圾回收策略，是基於這樣一個事實：不同的物件的生命週期是不一樣的。因此，不同生命週期的物件可以採取不同的收集方式，以便提高回收效率；

3.3.5 Valhalla

• 效能增強透過展平物件圖和移除間接來解決。這將獲得更高效的記憶體佈局和更少的分配和垃圾回收。

• 當用作泛型類型時，原語和物件具有更相似的行為，這是更好的抽象。