大資料Java基礎DAY8（面向物件——封裝）

目錄

封裝

private關鍵字

this關鍵字

?

構造方法

給成員變數值的賦值方法

類的成員方法

?

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

類的初始化程序

static關鍵字

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

main方法是靜態的

封裝

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

好處：

隱藏實作細節，提供公共的訪問方式

提高了代碼的復用性 提高安全性，

封裝原則：

將不需要對外提供的內容都隱藏起來，

把屬性隱藏，提供公共方法對其訪問，

private關鍵字

private關鍵字：是一個權限修飾符，

可以修飾成員(成員變數和成員方法).

被private修飾的成員只在本類中才能訪問，

private最常見的應用： 把成員變數用private修飾

提供對應的getXxx()/setXxx()方法

一個標準的案例的使用

class Phone{  //定義一個手機類
    private String name;  //用private修飾成員變數
    private int price;
    private String color;
    //提供一個公共的set方法，使外界能給成員變數賦值
    public void setName(String s) {
      name = s;
    }
    //提供一個公共的get方法，使外界能能獲取到成員變數的值
    public String getName() {
        return name;
    }
    public void setPrice(int p){
        price= p;
    }
    public int getPrice(){
        return price;
    }
    public void setColor(String c){
        color=c;
    }
    public String getColor(){
        return color;
    }
    public void show(){//列印所有的成員變數值
        System.out.println("品牌："+name+" 價格:"+price+" 顏色:"+color);
    }
}
public class PrivateTest1 {
    public static void main(String[] args) {
           Phone r=new Phone();
       //呼叫set方法為成員變數賦值
           r.setName("XX手機");
           r.setPrice(9999);
           r.setColor("黑色");
           r.show();
           //呼叫get方法獲取成員變數的值
        System.out.println(r.getName());
        System.out.println(r.getPrice());
        System.out.println(r.getColor());
    }
}

this關鍵字

this:代表所在類的物件參考

記住： 方法被哪個物件呼叫，this就代表那個物件

class Dog{//定義一個狗的類
    //定義狗的成員變數（品種，名字，年齡）
    private String breed;
    private String name;
    private int age;

    public void setBreed(String breed) {
        this.breed = breed;   //使用this參考物件
    }
    public void setName(String name) {
        this.name = name; //這里其實隱藏了一個this，可以不寫，因為就近原則就是物件的成員變數
    }
    public void setAge(int age) {
        this.age = age;
    }
    public String getBreed() {
        return breed;
    }
    public String getName() {
        return name;
    }
    public int getAge() {
        return age;
    }
    public void show(){
        System.out.println("品種："+breed+"名字："+name+"年齡："+age);
    }
}
public class PrivateTest3 {
    public static void main(String[] args) {
        Dog dog=new Dog(); //創建一個狗的物件
        //給成員變數進行賦值
        dog.setBreed("哈士奇");
        dog.setName("大風");
        dog.setAge(4);
        dog.show();
    }
}

構造方法

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

構造方法格式

方法名與類名相同

沒有回傳值型別，連void都沒有

沒有具體的回傳值

無參構造方法：

class Student{  //定義一個學生類
    //定義成員變數
    private String name;
    private int age;

    //定義一個構造方法
    Student(){
        System.out.println("這是一個構造方法");
    }

}
public class StudentTest {
    public static void main(String[] args) {
        //創建Student類的物件
        //呼叫的是無參構造方法創建物件
        Student student=new Student();
    }
}

帶參構造方法：

class Student{  //定義一個學生類
    //定義成員變數
    private String name;
    private int age;

    //定義一個無參構造方法
    Student(){
        System.out.println("這是一個構造方法");
    }

    //定義一個帶引數name的構造方法
    Student(String name){
        System.out.println("這是一個帶引數name的構造方法");
    }

    //定義一個帶引數name和age的構造方法
    Student(String name,int age){
        System.out.println("這是一個帶引數name和age的構造方法");
        this.name=name;
        this.age=age;
    }
    public void show(){
        System.out.println(name+"------"+age);
    }

}
public class StudentTest {
    public static void main(String[] args) {
        //創建Student類的物件
        //呼叫的是無參構造方法創建物件
        Student student=new Student();
             student.show();
        //使用帶一個引數的構造方法創建物件
        Student student1=new Student("小米");
              student1.show();
        //使用帶兩個引數的構造方法創建物件     
        Student student2=new Student("小明",18);
             student2.show();
    }
}

構造方法注意事項

如果你不提供構造方法，系統會給出默認構造方法

如果你提供了構造方法，系統將不再提供

構造方法也是可以多載的

給成員變數值的賦值方法

a.使用無參構造方法+setXxx()方法給成員變數賦值

b.使用帶引數的方法給成員變數賦值，需要與this關鍵字配合使用，

類的成員方法

方法具體劃分：

a.根據回傳值：有明確回傳值的方法

回傳void型別的方法（無回傳值）

b.根據形式引數：無參方法

有參方法

class Function{
    //定義一個無回傳值無引數的方法
    public void Function1(){
        System.out.println("這是一個無回傳值無引數的方法");
    }
    //定義一個無回傳值有引數的方法
    public void Function2(String name){
        System.out.println("這是一個無回傳值有引數的方法"+name);
    }
    //定義一個有回傳值無引數的方法
      public String Function3(){
        return "16年義務教育";
    }
    //定義一個有回傳值有引數的方
    public  String Function4(String s){
        return s+"歡迎你";
    }
}
public class FunctionTest {
    public static void main(String[] args) {
        Function function=new Function();//創建function類的物件
       //無回傳值的方法，直接呼叫輸出結果
        function.Function1();
        function.Function2("User");
        
       //有回傳值的方法，呼叫時，需要用一個變數接收
        String s= function.Function3();
        System.out.println(s);

        String e= function.Function4("User");
        System.out.println(e);
    }
}

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

類的組成：成員變數，成員方法

成員變數：被private修飾

構造方法：一個無參構造方法/一個帶所有引數的構造方法

成員方法：setXxx（...）和getXxx()

show()：列印所有成員變數的值

例：一個手機的標準代碼

class Phone{
    //定義成員變數
    private String brand;
    private int price;
    private String color;
    //定義構造方法（快捷鍵alt +insert選Constructor）
    public Phone() {}

    public Phone(String brand, int price, String color) {
        this.brand = brand;
        this.price = price;
        this.color = color;
    }
    //setXxx()方法和getXxx方法（快捷鍵alt+insert選Getter和Setter）
    public String getBrand() {
        return brand;
    }
    public int getPrice() {
        return price;
    }
    public String getColor() {
        return color;
    }
    public void setBrand(String brand) {
        this.brand = brand;
    }
    public void setPrice(int price) {
        this.price = price;
    }
    public void setColor(String color) {
        this.color = color;
    }
    //定義一個打電話的方法
    public void call(String name){
        System.out.println("給"+name+"打電話");
    }
    //展示所有成員變數的值
    public void show(){
        System.out.println("品牌："+brand+",價格："+price+",顏色："+color);
    }
}
public class PhoneTest {
    public static void main(String[] args) {
        Phone phone=new Phone("華為",9999,"黑色");//呼叫有參構造方法創建物件
        phone.show();
        phone.call("User"); //呼叫打電話的方法
    }
}

類的初始化程序

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

a.加載Student.class檔案進記憶體

b.在堆疊記憶體為s開辟空間

c.在堆記憶體為學生物件開辟空間

d.對學生物件的成員變數進行默認初始化

e.對學生物件的成員變數進行顯示初始化

f.通過構造方法對學生物件的成員變數賦值

g.學生物件初始化完畢，把物件地址賦值給s變數

static關鍵字

可以修飾成員變數和成員方法

static關鍵字特點 :隨著類的加載而加載

優先于物件存在

被類的所有物件共享(這也是我們判斷是否使用靜態關鍵字的條件)

可以通過類名呼叫

例：我們創建一個動物類

class Animal{  //定義一個動物類
    private String name;
    private String color;
    private String kind;

    public Animal(){}

    public Animal(String name, String color, String kind) {
        this.name = name;
        this.color = color;
        this.kind = kind;
    }
     //getXxx()和setXxx(..)方法

    public void show(){
        System.out.println("動物名字："+name+",顏色:"+color+",種類:"+kind);
    }
}
public class AnimalTest {
    public static void main(String[] args) {
           Animal animal=new Animal("老虎","黃色","貓科動物");//用構造方法創建Animal類的物件
                         animal.show();
           Animal animal1=new Animal("獅子","棕色","貓科動物");
                         animal1.show();
           Animal animal2=new Animal("貓","白色","貓科動物");
                         animal2.show();
    }
}

我們可以發現這三種動物都是貓科動物，每次創建新物件時，就會在堆記憶體中開辟空間，如果數量非常多，這樣就造成了浪費，所有我們可以用static改進，

改進后：

class Animal{  //定義一個動物類
    private String name;
    private String color;
    private static String kind;  //使用static修飾kind

    public Animal(){}

    public Animal(String name, String color, String kind) {
        this.name = name;
        this.color = color;
        this.kind = kind;
    }
    public Animal(String name,String color){  //新增構造方法
        this.name = name;
        this.color = color;
    }
     //getXxx()和setXxx(..)方法

    public void show(){
        System.out.println("動物名字："+name+",顏色:"+color+",種類:"+kind);
    }
}
public class AnimalTest {
    public static void main(String[] args) {
           Animal animal=new Animal("老虎","黃色","貓科動物");//用構造方法創建Animal類的物件
                         animal.show();
           Animal animal1=new Animal("獅子","棕色"); //呼叫新的構造方法
                         animal1.show();
           Animal animal2=new Animal("貓","白色");
                         animal2.show();
    }
}

改進前后的輸出結果都是一樣的，改進后的更加節省記憶體

static關鍵字注意事項 : 在靜態方法中是沒有this關鍵字的

靜態方法只能訪問靜態的成員變數和靜態的成員方法

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

a.所屬不同：

靜態變數屬于類，所以也稱為為類變數

成員變數屬于物件，所以也稱為實體變數(物件變數)

b.記憶體中位置不同

靜態變數存盤于方法區的靜態區

成員變數存盤于堆記憶體

c.記憶體出現時間不同

靜態變數隨著類的加載而加載，隨著類的消失而消失

成員變數隨著物件的創建而存在，隨著物件的消失而消失

d.呼叫不同

靜態變數可以通過類名呼叫，也可以通過物件呼叫

成員變數只能通過物件名呼叫

main方法是靜態的

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

a. public 被jvm呼叫，訪問權限足夠大，

b. static 被jvm呼叫，不用創建物件，直接類名訪問

c.void被jvm呼叫，不需要給jvm回傳值

d. main 一個通用的名稱，雖然不是關鍵字，但是被jvm識別