面向物件（二）-搞定她-搞定程式-有解無憂

面向物件（一）-搞定她-搞定程式

封裝(private)

封裝概述：是指隱藏物件的屬性和實作細節，僅對外提供公共訪問方式，

封裝的好處

隱藏實作細節，提供公共的訪問方式
提高了代碼的復用性
提高安全性，

封裝原則

將不需要對外提供的內容都隱藏起來，
把屬性隱藏，提供公共方法對其訪問，

private關鍵字

是一個權限修飾符，
可以修飾成員(成員變數和成員方法)
被private修飾的成員只在本類中才能訪問，

private最常見的應用

把成員變數用private修飾
提供對應的getXxx()和setXxx()方法

一個標準的案例的使用

/**
    封裝和private的應用：
        A:把成員變數用private修飾
        B:提高對應的getXxx()和setXxx()方法
*/
//定義學生類
class Student {
    //姓名
    private String name;
    //年齡
    private int age;

    //姓名獲取值
    public String getName() {
        return name;
    }

    //姓名設定值
    public void setName(String n) {
        name = n;
    }

    //年齡獲取值
    public int getAge() {
        return age;
    }

    //年齡賦值
    public void setAge(int a) {
        age = a;
    }
}

//測驗類
class StudentTest {
    public static void main(String[] args) {
        //創建學生物件
        Student s = new Student();

        //使用成員變數
        //錯誤：被私有修飾了，外界不能直接訪問了
        //System.out.println(s.name+"---"+s.age);
        System.out.println(s.getName()+"---"+s.getAge());

        //給成員變數賦值
        //s.name = "林青霞";
        //s.age = 27;
        //通過方法給賦值
        s.setName("林青霞");
        s.setAge(27);
        System.out.println(s.getName()+"---"+s.getAge());
    }
}

運行結果：

private關鍵字

this關鍵字

this代表其所在函式所屬物件的參考，換言之，this代本類物件的參考，

當成員變數和區域變數重名，可以用關鍵字this來區分，this就是所在函式所屬物件的參考，

簡單說，哪個物件呼叫了this所在的函式，this就代表哪個物件，一般方法呼叫默認加this，（方法被哪個物件呼叫，this就代表那個物件）

什么時候使用this呢?

區域變數隱藏成員變數
其他用法后面和super一起講解

/**
    我們曾經曰：起名字要做到見名知意，

    this:是當前類的物件參考，簡單的記，它就代表當前類的一個物件，

        注意：誰呼叫這個方法，在該方法內部的this就代表誰，

    this的場景：
        解決區域變數隱藏成員變數

    this:哪個物件呼叫那個方法，this就代表那個物件
*/
class Student {
    private String name;
    private int age;

    public String getName() {
        return name; //這里其實是隱含了this
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

class StudentTest2 {
    public static void main(String[] args) {
        //創建一個物件
        Student s1 = new Student();
        s1.setName("林青霞");
        s1.setAge(27);
        System.out.println(s1.getName()+"---"+s1.getAge());

        //創建第二個物件
        Student s2 = new Student();
        s2.setName("劉意");
        s2.setAge(30);
        System.out.println(s2.getName()+"---"+s2.getAge());
    }
}

運行結果：

this關鍵字

this關鍵字的記憶體圖解：

this關鍵字

構造方法

構造方法作用概述：給物件的資料進行初始化

構造方法格式

方法名與類名相同
沒有回傳值型別，連void都沒有
沒有具體的回傳值

構造方法注意事項

如果你不提供構造方法，系統會給出默認構造方法
如果你提供了構造方法，系統將不再提供
構造方法也是可以多載的

給成員變數賦值有兩種方式

setXxx()
構造方法

PS：

一般函式和建構式什么區別呢？

建構式：物件創建時，就會呼叫與之對應的建構式，對物件進行初始化，
一般函式：物件創建后，需要函式功能時才呼叫，

建構式：物件創建時，會呼叫并且只呼叫一次，
一般函式：物件創建后，可以被呼叫多次，

創建物件都必須要通過建構式初始化，

一個類中如果沒有定義過建構式，那么該類中會有一個默認的空引數建構式，

如果在類中定義了指定的建構式，那么類中的默認建構式就沒有了，

多個建構式是以多載的形式存在的，

/**
    我們一直在使用構造方法，但是，我們確沒有定義構造方法，用的是哪里來的呢?

    構造方法的注意事項:
        A:如果我們沒有給出構造方法，系統將自動提供一個無參構造方法，
        B:如果我們給出了構造方法，系統將不再提供默認的無參構造方法，
            注意：這個時候，如果我們還想使用無參構造方法，就必須自己給出，建議永遠自己給出無參構造方法

    給成員變數賦值有兩種方式：
        A:setXxx()
        B:構造方法
*/

class Student {
    private String name;
    private int age;

    public Student() {
        //System.out.println("我給了，你還給不");
        System.out.println("這是無參構造方法");
    }

    //構造方法的多載格式
    public Student(String name) {
        System.out.println("這是帶一個String型別的構造方法");
        this.name = name;
    }

    public Student(int age) {
        System.out.println("這是帶一個int型別的構造方法");
        this.age = age;
    }

    public Student(String name,int age) {
        System.out.println("這是一個帶多個引數的構造方法");
        this.name = name;
        this.age = age;
    }

    public void show() {
        System.out.println(name+"---"+age);
    }
}

class ConstructDemo2 {
    public static void main(String[] args) {
        //創建物件
        Student s = new Student();
        s.show();
        System.out.println("-------------");

        //創建物件2
        Student s2 = new Student("林青霞");
        s2.show();
        System.out.println("-------------");

        //創建物件3
        Student s3 = new Student(27);
        s3.show();
        System.out.println("-------------");

        //創建物件4
        Student s4 = new Student("林青霞",27);
        s4.show();
    }
}

構造方法和成員變數初始化順序

執行父類靜態代碼執行子類靜態代碼
初始化父類成員變數（我們常說的賦值陳述句）
初始化父類建構式
初始化子類成員變數
初始化子類建構式

類的成員方法

成員方法其實就是我們前面講過的方法

方法具體劃分：

根據回傳值：有明確回傳值方法；回傳void型別的方法
根據形式引數：無參方法；帶參方法

一個基本類的標準代碼寫法

/**
    一個標準代碼的最終版，

    學生類：
        成員變數：
            name，age
        構造方法：
            無參，帶兩個參
        成員方法：
            getXxx()/setXxx()
            show()：輸出該類的所有成員變數值

    給成員變數賦值：
        A:setXxx()方法
        B:構造方法

    輸出成員變數值的方式：
        A:通過getXxx()分別獲取然后拼接
        B:通過呼叫show()方法搞定
*/
class Student {
    //姓名
    private String name;
    //年齡
    private int age;

    //構造方法
    public Student() {
    }

    public Student(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;
    }

    //輸出所有的成員變數值
    public void show() {
        System.out.println(name+"---"+age);
    }
}

//測驗類
class StudentTest {
    public static void main(String[] args) {
        //方式1給成員變數賦值
        //無參構造+setXxx()
        Student s1 = new Student();
        s1.setName("林青霞");
        s1.setAge(27);
        //輸出值
        System.out.println(s1.getName()+"---"+s1.getAge());
        s1.show();
        System.out.println("----------------------------");

        //方式2給成員變數賦值
        Student s2 = new Student("劉意",30);
        System.out.println(s2.getName()+"---"+s2.getAge());
        s2.show();
    }
}

運行結果：

類的成員方法

2.11 類的初始化程序

Student s = new Student();在記憶體中做了哪些事情?

加載Student.class檔案進記憶體
在堆疊記憶體為s開辟空間
在堆記憶體為學生物件開辟空間
對學生物件的成員變數進行默認初始化
對學生物件的成員變數進行顯示初始化
通過構造方法對學生物件的成員變數賦值
學生物件初始化完畢，把物件地址賦值給s變數

類的初始化程序

static關鍵字

static關鍵字可以修飾成員變數和成員方法

static關鍵字特點

隨著類的加載而加載
優先于物件存在
被類的所有物件共享
這也是我們判斷是否使用靜態關鍵字的條件
可以通過類名呼叫

static關鍵字注意事項

在靜態方法中是沒有this關鍵字的
靜態方法只能訪問靜態的成員變數和靜態的成員方法

靜態的記憶體圖

靜態變數和成員變數的區別

main方法是靜態的

public static void main(String[] args) {}

public 被jvm呼叫，訪問權限足夠大，
static 被jvm呼叫，不用創建物件，直接類名訪問
void被jvm呼叫，不需要給jvm回傳值
main 一個通用的名稱，雖然不是關鍵字，但是被jvm識別
String[] args 以前用于接收鍵盤錄入的
靜態什么時候用？

靜態變數

當分析物件中所具備的成員變數的值都是相同時，這時這個成員就可以被靜態修飾，

只要資料在物件中都是不同的，就是物件的特有資料，必須存盤在物件中，是非靜態的，

如果是相同的資料，物件不需要做修改，只需要使用即可，不需要存盤在物件中，定義成靜態的，

靜態函式

函式是否用靜態修飾，就參考一點，就是該函式功能是否需要訪問到物件中的特有資料，

簡單點說，從源代碼看，該功能是否需要訪問非靜態的成員變數，如果需要，該功能就是非靜態的，

如果不需要，就可以將該功能定義成靜態的，當然，也可以定義成非靜態，但是非靜態需要被物件呼叫，

如果沒有訪問特有資料的方法，該物件的創建是沒有意義，

/*
    main方法的格式講解：
        public static void main(String[] args) {...}

        public:公共的，訪問權限是最大的，由于main方法是被jvm呼叫，所以權限要夠大，
        static:靜態的，不需要創建物件，通過類名就可以，方便jvm的呼叫，
        void:因為我們曾經說過，方法的回傳值是回傳給呼叫者，而main方法是被jvm呼叫，你回傳內容給jvm沒有意義，
        main:是一個常見的方法入口，我見過的語言都是以main作為入口，
        String[] args:這是一個字串陣列，值去哪里了?
            這個東西到底有什么用啊?怎么給值啊?
                這個東西早期是為了接收鍵盤錄入的資料的，
                格式是：
                    java MainDemo hello world java
*/
class MainDemo {
    public static void main(String[] args) {
        //System.out.println(args); //[Ljava.lang.String;@175078b
        //System.out.println(args.length); //0
        //System.out.println(args[0]); //ArrayIndexOutOfBoundsException

        //接收資料后
        System.out.println(args);
        System.out.println(args.length);
        //System.out.println(args[0]);
        for(int x=0; x<args.length; x++) {
            System.out.println(args[x]);
        }
    }
}

運行結果：

靜態函式

修飾符

java修飾符

關鍵字

java關鍵字

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

標籤：java

上一篇：Volatile關鍵字(一) 可見性

下一篇：【課程學習】多執行緒基礎應用