一些JavaSE學習程序中的思路整理(一)（主觀性強，持續更新中...）-有解無憂

一些JavaSE學習程序中的思路整理(一)（主觀性強，持續更新中...）
- Java書寫規范
- IDEA的一些常用快捷鍵
- Java類中作為成員變數的類
- Java源檔案中只能有一個public類
- Java中如何直接列印陣列
- 關于在Main方法中呼叫其它方法
- Java成員變數和區域變數的對比
- 區域變數不能使用訪問修飾符
- 用二維陣列列印楊輝三角
- 初始化塊與靜態初始化塊
- 關于不允許使用靜態建構式
- 關于private static與public static
- 通過繼承創建子類的程序中發生了什么(有些疑惑望解答)
- 訪問權限修飾符的那些事

一些JavaSE學習程序中的思路整理(一)（主觀性強，持續更新中...）

未經作者允許，不可轉載，如有錯誤，歡迎指正o(￣▽￣)o

Java書寫規范

類名大駝峰，識別符號小駝峰，關鍵字、右括號、右花括號后加空格，方法與方法之間加一個空行，

IDEA的一些常用快捷鍵

ctrl + shift + f10快速編譯運行當前java檔案
對于報錯（紅色曲線）alt + enter查看詳細錯誤資訊以及推薦解決方案
alt + insert（alt + shift + 小鍵盤0）對一個類進行快速創建構造器訪問器toString等方法
要查看某個類介面等的具體實作，ctrl+滑鼠左鍵進入

Java類中作為成員變數的類

Scanner in = new Scanner(System.in);

Java類中的成員變數可以是一個類，其實String就是一個類，這下懂了吧，所以System.in是一個InputStream型別的靜態物件，而Scanner in = new Scanner(System.in)是呼叫了Scanner類的構造方法實體化一個對輸入流的掃描儀物件，

Java源檔案中只能有一個public類

一個Java源檔案中最多只能有一個public類，當有一個public類時，源檔案名必須與之一致，否則無法編譯，如果源檔案中沒有一個public類，則檔案名與類中沒有一致性要求，

Java中如何直接列印陣列

int A[] = {9, 4, 2, 1, 8, 5, 6, 3, 7, 10};
System.out.println("直接列印A陣列");
System.out.println(A);
System.out.println("通過Arrays.toString()方法列印A");
System.out.println(Arrays.toString(A));

輸出結果：

直接列印A陣列
[I@58ceff1
通過Arrays.toString()方法列印A
[9, 4, 2, 1, 8, 5, 6, 3, 7, 10]

由于陣列物件沒有重寫Object類的toString方法，所以直接列印會列印出原始定義的格式的結果，其中在Object類中的toString為：

getClass().getName() + '@' + Integer.toHexString(hashCode())

關于在Main方法中呼叫其它方法

main方法是靜態方法，只能訪問自身的靜態方法和靜態欄位，如果要使用非靜態成員欄位或者非靜態方法，需要先在main函式中初始化一個其他的類，再通過打點呼叫該類的非靜態方法或者非靜態欄位
非靜態方法可以通過類名訪問類的靜態欄位以及靜態方法，但在類的內部不可以直接呼叫

Java成員變數和區域變數的對比

成員變數在方法外宣告，區域變數在方法外宣告
成員變數隨著物件的創建而創建，隨著物件的消失而消失，區域變數：隨著方法的呼叫而存在，隨著方法呼叫結束而消失
成員變數如果沒有人為初始化由默認構造器進行初始化，而區域變數必須人為初始化，
區域變數名可以與成員變數名相同，遵循就近原則，若不是在構造器中用this.value = https://www.cnblogs.com/YLTFY1998/p/value這種情況，為了避免歧義與不易閱讀，盡量避免同名

區域變數不能使用訪問修飾符

由于區域變數的生命周期，可以理解為區域變數本身就是由訪問權限設定的，它僅提供本方法在呼叫時使用，并不提供給其他方法和類使用，所以不需要訪問權限修飾符

用二維陣列列印楊輝三角

int[][] C = new int[5][5];
C[0][0] = 1;
System.out.println(Arrays.toString(C[0]));
for (int i = 1; i < C.length; i++) {
    for (int j = 0; j <= i; j++) {
        if (j == 0) C[i][j] = 1;
        else C[i][j] = C[i-1][j] + C[i-1][j-1];
    }
    System.out.println(Arrays.toString(C[i]));
}
System.out.println(Arrays.toString(C));

輸出結果：

[1, 0, 0, 0, 0]
[1, 1, 0, 0, 0]
[1, 2, 1, 0, 0]
[1, 3, 3, 1, 0]
[1, 4, 6, 4, 1]
[[I@58ceff1, [I@7c30a502, [I@49e4cb85, [I@2133c8f8, [I@43a25848]

這里最后一句輸出對應結果是由于Array.toString以二維陣列為引數，底層將每個一維陣列作為一個物件直接呼叫Object類的原始toString方法導致

初始化塊與靜態初始化塊

這里要提及三種初始化類中成員變數欄位的方法：（摘自Java核心技術卷一）

在構造器中設定值
在宣告中直接賦值
通過初始化塊賦值

關于初始化執行順序：

1.如果構造器第一行呼叫另一個構造器，則基于所提供的引數執行第二個構造器

2.否則，所有欄位初始化為默認值（0，false，null），按照在類宣告中出現的順序，執行所有欄位初始化方法和初始化塊

3.執行構造器主體部分代碼（這里指的是構造器剩余部分的代碼）

注意：在類第一次加載的時候，將會進行靜態欄位的初始化，除非將靜態欄位顯式設定為其他值，否則也按照默認值進行初始化（0，false，null），所有靜態欄位初始化方法以及靜態初始化塊都將依照類宣告中的出現順序執行，

以下是關于初始化程序撰寫的一個測驗程式

public class Test1 {
    public static void main(String[] args) {
        Person person = new Person("構造器初始化", 5);
        System.out.println(person.getName() + person.getAge());
    }
}

class Person {
    private String name = "直接在宣告中給非靜態欄位賦值";
    private int age = 3;
    private static String name2 = "直接在宣告中給靜態欄位賦值";
    private static int age2 = 1;

    static
    {
        System.out.println(name2 + age2);
        name2 = "靜態初始化塊";
        age2 = 2;
        System.out.println(name2 + age2);
    }

    {
        System.out.println(name + age);
        name = "普通初始化塊";
        age = 4;
        System.out.println(name + 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;
    }

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

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

輸出結果：

直接在宣告中給靜態欄位賦值1
靜態初始化塊2
直接在宣告中給非靜態欄位賦值3
普通初始化塊4
構造器初始化5

可以看到通過不同的初始化方法，其執行的先后有明顯的不同，簡單總結為：宣告中為靜態欄位賦值 > 靜態初始化塊 > 宣告中為欄位賦值 > 初始化塊 > 構造器初始化

關于不允許使用靜態建構式

看到一種說法比較令我信服：靜態屬于類，而建構式屬于物件，具體說就是靜態方法、靜態初始化塊、靜態成員變數屬于該類，而構造器屬于具體的實體物件，在用new運算子創建實體時呼叫，由于建構式不是類屬性，因此有理由認為它不能是靜態的，

上文出處：https://www.cnblogs.com/java-friend/p/11750671.html

補充：不考慮訪問修飾符，可以記憶：靜態方法只能呼叫靜態，而非靜態方法都可以呼叫，公用的大家都能用而自己的只能自己用

關于private static與public static

出于對欄位資料的封裝，由private修飾的成員變數只能由本類的公共方法供其他類呼叫修改該private欄位的資料，因此：

private static修飾的欄位：要在此基礎上增加static的限制，被private static修飾的成員變數（就像是由類私有的變數）只能靜態方法呼叫，或者本類中的非靜態方法呼叫，在外部由這個類創建的物件，或者直接使用這個類去打點訪問都是非法的（這時對于其他類來說必須要用該類公開的方法去呼叫該private static修飾的欄位值）
public static修飾的欄位：常用的是為該類提供對外暴露即可以被類名直接呼叫的靜態常量（不需要經過該類的方法去訪問），用于修飾工具方法或者工具常量

通過繼承創建子類的程序中發生了什么(有些疑惑望解答)

首先，通過繼承，創建一個子類物件的時候，會默認先創建一個父類物件，并對成員欄位賦予默認值（0，false，null），如果此時子類是由構造器創建的，并且構造器內部第一行呼叫了父類的構造器，那么整個程序可以分為三步：

1.首先默認創建一個父類物件實體，對其成員變數賦予默認值

2.呼叫子類構造器，構造器中呼叫父類構造器為父類物件實體進行初始化（這里與第一步操作的是同一個物件實體）

3.由于子類構造方法中沒有別的步驟，則子類的成員欄位被賦予默認值

下面是一個測驗demo，用上述提到的步驟進行初始化

public class Demo {
    public static void main(String[] args) {
        Son son = new Son(15, "父親");
        System.out.println("后創建兒子：" + son.getMoney() + son.getName());
        //Father father = new Father();
    }
}

class Son extends Father {
    private int money;
    private String name;

    public Son(int money, String name) {
        super(money, name);
    }

    @Override
    public int getMoney() {//如果子類重寫父類的方法打點呼叫的是自己的方法
        return money;       //否則呼叫的是父類的方法
    }

    @Override
    public void setMoney(int money) {
        this.money = money;
    }

    @Override
    public String getName() {
        return name;
    }

    @Override
    public void setName(String name) {
        this.name = name;
    }
}

class Father {
    private int money;
    private String name;

    {
        System.out.println("先創建了父親1：" + money + name);
    }

    public Father(int money, String name) {
        this.money = money;
        this.name = name;
        System.out.println("子類呼叫父類的構造方法后，父類的成員欄位值為：" + money + name);
    }

    public Father() {
        System.out.println("先創建了父親2：" + money + name);
    }

    public int getMoney() {
        return money;
    }

    public void setMoney(int money) {
        this.money = money;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

輸出結果：

先創建了父親1：0null
子類呼叫父類的構造方法后，父類的成員欄位值為：15父親
后創建兒子：0null

補充：值得注意的是，上述步驟1提到的默認先創建一個父類物件的參考，并賦予默認值，是根據成員欄位型別直接賦予（0，false，null），測驗結果，程序中并未呼叫父類無參構造器（是這樣嗎？）

若父類重寫了無參構造器，則子類構造器必須呼叫父類某個構造器，如果父類沒有重寫，或者重寫后依舊保留默認構造器，則子類可以不必在構造器中呼叫父類構造器（這么做的目的猜測是因為創建子類物件之前會先默認創建父類的一個物件，要確保有一個構造器能用，但是上述代碼我測驗的結果是并未在父類物件初始化階段自動呼叫父類的無引數構造器，矛盾？）
子類的構造方法中，可以通過super訪問父類的構造方法和普通方法
子類的普通方法，只能通過super訪問父類的普通方法

訪問權限修飾符的那些事

小貼士：Typora快速創建markdown表格 ctrl + t

	同一個類中	不同包中	同一包中	子類（不同包）
public	可以訪問	可以訪問	可以訪問	可以訪問
protected	可以訪問	不可以訪問	可以訪問	可以訪問
默認修飾符	可以訪問	不可以訪問	可以訪問	不可以訪問
private	可以訪問	不可以訪問	不可以訪問	不可以訪問

簡單來說：public > protected > 默認修飾符 > private，每次剝奪一個權限，這里可以訪問指的是可以直接訪問，并非考慮間接的情況

轉載請註明出處，本文鏈接：https://www.uj5u.com/houduan/249310.html

標籤：Java

上一篇：IntelliJ IDEA啟動界面的秘密：當編程遇到藝術

下一篇：Java高級特性之反射