JAVA學習之路（六）面向對象之封裝、繼承、多態

時間 2020-02-06

原文原文鏈接

面向對象之封裝、繼承、多態

封裝

將類中的信息進行隱藏在類的內部，不容許外部程序信息直接訪問，而是隻能經過該類的提供的方法來實現對隱藏信息的提供和訪問。

好處

只能隱藏規定的方法和數據
隱藏類的實現細節，方便修改和實現

封裝的實現步驟java

1. 用private等修飾符修飾屬性
2. 建立屬性的getter/setter方法
3. 在getter/setter方法中加入屬性的控制語句

java中的訪問修飾符

java中的訪問修飾符一個有四個，咱們主要學習 private、 protected、 public三個。

java中的this關鍵字

this關鍵字表明當前對象安全

this.屬性 操做當前對象的屬性
this.方法 操做當前對象的方法

封裝對象的屬性的時候會常常使用this關鍵字ide

package com.test.cat; // 定義包

public class Cat {
    int a;
    int b;

    public void send() {
        System.out.print("send");
    }

    public int getA() {
        this.send(); // 調用方法
        return a;
    }
    public void setA(int a) {
        this.a = a;  // 調用屬性
    }
    public int getB() {
        return b;
    }
    public void setB(int b) {
        this.b = b;
    }
    public Cat() {
        System.out.println("Cat 實例化了");
    }
}

java中的內部類

內部類（ Inner Class ）就是定義在另一個類裏面的類。與之對應，包含內部類的類被稱爲外部類。

內部類的主要做用函數

1. 內部類提供了更好的封裝，能夠把內部類隱藏在外部類以內，不容許同一個包中的其餘類訪問該類
2. 內部類的方法能夠直接訪問外部類的全部數據，包括私有的數據
3. 內部類所實現的功能使用外部類一樣能夠實現，只是有時使用內部類更方便

內部類的分類學習

成員內部類
靜態內部類
方法內部類
匿名內部類

先舉個例子

//外部類HelloWorld
public class HelloWorld {
    
    // 內部類Inner，類Inner在類HelloWorld的內部
    public class Inner {
        
        // 內部類的方法
        public void show() {
            System.out.println("welcome to imooc!");
        }
    }
    
    public static void main(String[] args) {
        
        // 建立外部類對象
        HelloWorld hello = new HelloWorld();
        // 建立內部類對象
        Inner i = hello.new Inner();
        // 調用內部類對象的方法
        i.show();
    }
}

java中的成員內部類(普通內部類)

package innerClass;
 
// 外部類
public class Outer {
    private int out; // 外部類成員
    private int b; // 外部的b
    
    public int getOut() {
        return out;
    }
    public void setOut(int out) {
        this.out = out;
    }
    // 外部類構造函數
    public Outer(int _out) {
        this.out = _out;
        System.out.println("外部類實例化中.....");
        // 外部類則沒法訪問內部類的數據
    }
    
    // 內部類
    public class Inner{
        private int in; // 內部類成員
        private int b; // 內部的b
        
        // 內部類構造函數
        public Inner(int _in) {
            this.in = _in;
            System.out.println("內部類實例化中....");
            System.out.println(out); // 內部類能夠訪問外部類中的任何數據
            System.out.println(this.b); // 若是趕上重名，那麼默認是使用內部的變量，若是想要使用外部的變量，可使用this 
        }
    }
    
    public static void main(String [] args) {
        Outer o = new Outer(100);  // 建立一個外部對象
        System.out.println(o.getOut());
        
        Inner i = o.new Inner(200); // 建立一個內部對象
    }
}

注意事項

1. Inner 類定義在 Outer 類的內部，至關於 Outer 類的一個成員變量的位置，Inner 類可使用任意訪問控制符，如 public 、 protected 、 private 等
2. Inner 類中定義的 test() 方法能夠直接訪問 Outer 類中的數據，而不受訪問控制符的影響
3. 定義了成員內部類後，必須使用外部類對象來建立內部類對象，而不能直接去 new 一個內部類對象，即：內部類 對象名 = 外部類對象.new 內部類( );
4. 編譯上面的程序後，會發現產生了兩個 .class 文件
其中，第二個是外部類的 .class 文件，第一個是內部類的 .class 文件，即成員內部類的 .class 文件老是這樣：外部類名$內部類名.class

外部類是不能直接使用內部類的成員和方法滴

若是外部類和內部類具備相同的成員變量或方法，內部類默認訪問本身的成員變量或方法，若是要訪問外部類的成員變量，可使用 this 關鍵字。

Java 中的靜態內部類

靜態內部類是 static 修飾的內部類

特色

1. 靜態內部類不能直接訪問外部類的非靜態成員，但能夠經過 new 外部類().成員 的方式訪問 
2. 若是外部類的靜態成員與內部類的成員名稱相同，可經過「類名.靜態成員」訪問外部類的靜態成員；若是外部類的靜態成員與內部類的成員名稱不相同，則可經過「成員名」直接調用外部類的靜態成員
3. 建立靜態內部類的對象時，不須要外部類的對象，能夠直接建立 內部類 對象名= new 內部類();

package static_inner_class;

public class Outer {
    private int a; // 外部普通成員變量
    static int b = 10; //外部靜態變量
    
    public Outer(int _a) {
        this.a = _a;
        System.out.println("外部類實例化中....");
    }
    
    
    // 內部類
    public static class Inner{
        private int b;
        public Inner(int _b) {
            this.b = _b;
            System.out.println("內部類實例化中....");
        }
        
        public void test() {
            System.out.println("訪問外部類中的b：" + Outer.b); 
            // 訪問外部靜態變量，建議使用class.staticName ，即便這是處理外部類和內部類存在同名變量的狀況下
            System.out.println("訪問內部類中的b：" + b); // 訪問內部變量能夠直接訪問
        }
    }
    
    public static void main(String [] args) {
        Outer o = new Outer(10);
        Inner i = new Inner(20); // 建立內部類能夠直接使用該方法，不用先實例化外部類
        i.test();
    }
}

Java 中的方法內部類

方法內部類就是內部類定義在外部類的方法中，方法內部類只在該方法的內部可見，即只在該方法內可使用。

//外部類
public class HelloWorld {
    
    private String name = "愛慕課";
    
    // 外部類中的show方法
    public void show() { 
        // 定義方法內部類
        class MInner {
            int score = 83;
            public int getScore() {
                return score + 10;
            }
        }
        
        // 建立方法內部類的對象
        MInner mi=new MInner();
        
        // 調用內部類的方法
        int newScore=mi.getScore();
        
        System.out.println("姓名：" + name + "\n加分後的成績：" + newScore);
    }
    
    // 測試方法內部類
    public static void main(String[] args) {
        
        // 建立外部類的對象
        HelloWorld mo=new HelloWorld();
        
        // 調用外部類的方法
        mo.show();
    }
}

繼承

繼承就是類與類之間的一種 is a的關係

java中繼承是單繼承的，也就是隻能由一個父類測試

好處

1. 實現代碼的複用
2. 子類擁有父類的全部屬性和方法
3. 可是private修飾的屬性和方法卻沒法訪問到

語法規則

例子

// Animal.java

package inhert_demo1;

public class Animal {
    public int age;
    public String name;
    public void eat() {
        System.out.println("動物能夠吃東西");
    }
}

// Cat.java
package inhert_demo1;

public class Cat extends Animal{
    // 【方法的重寫】
    public void eat() {
        System.out.println("貓咪能夠吃東西");
    }
}

// test.java

package inhert_demo1;

public class test {
    public static void main(String [] args) {
        Cat c = new Cat();
        c.eat();
    }
}

方法的重寫

若是子類對繼承父類的方法不滿意，是能夠重寫父類的方法的，當調用的時候，優先調用子類的方法

// 規定
1. 返回值相同
2. 參數類型及個數相同
3. 方法名相同

繼承的出發順序

1. 先初始化父類，而後再初始化子類
2. 先執行初始化對象中的屬性，而後再執行構造函數中的初始化

// 執行順序爲
package inhert_demo1;

public class Animal {
    public int age = 10; //【1】 屬性初始化
    public String name;
    
    public Animal() {
        age = 20; // 【2】構造函數中的初始化
    }
    public void eat() {
        System.out.println("動物能夠吃東西");
    }
}

final "最終的"

final能夠修飾類、屬性、方法、變量

final修飾的類，則該類不能被繼承
final修飾的方法，則方法不容許被覆蓋（也就是方法的重寫）
final修飾的屬性： 屬性初始化必須是在屬性初始化或者構造方法中初始化，只能人選其一
final修飾的變量，這個變量就成爲了常量，只能賦值一次

super

super關鍵字代指父類（在對象內部使用、能夠表明父類對象）

// 子類 cat
package inhert_demo1;

public class Cat extends Animal{
    public int age = 20;
    public void eat() {
        System.out.println("貓咪能夠吃東西");
    }
    
    public void meyhod () {
        // super表明父類
        System.out.println(super.age); // 使用父類的屬性
        super.eat(); // 子類中調用父類的方法
    }
}

注意

1. 若是子類中的構造方法沒有顯示的調用父類的構造方法，那麼系統將默認調用父類的無參構造方法

也就是會隱世的調用`super()`

2. 若是父類沒有無參構造方法，而是有有參的構造方法，那麼子類中就必須顯示的調用父類的構造方法。

Object類

Object類是全部類的父類，若是一個類沒有明確的使用 extends來指定繼承一個類，那麼這個類默認繼承Object（Object類中的方法適合子類）

方法1、toString()this

Object中的類方法toString()返回的是一個對象的哈希Code碼（對象的地址引用）

// 咱們則是想使用該方法來返回屬性的值，所以咱們能夠重寫該方法

// cat類中
public String toString() {
    return "Cat [age=" + age + "]";
}


//使用

package inhert_demo1;

public class test {
    public static void main(String [] args) {
        Cat c = new Cat();
        System.out.println(c.toString());
    }
}

方法2、equals()spa

比較對象的引用是否指向同一塊內存地址。

Dog d1 = new Dog();
Dog d2 = new Dog();

d1.d2是兩個地址，是不相同的

// 若是咱們想要用equals來比較兩個對象的值是否相同，這就須要咱們重寫該方法

// cat中重寫

    @Override
    public boolean equals(Object obj) {
        if (this == obj)
            return true;
        if (obj == null)
            return false;
        if (getClass() != obj.getClass())// getClass 獲取到的是類對象
            return false;
        Cat other = (Cat) obj;
        if (age != other.age)
            return false;
        return true;
    }

Cat c = new Cat();
System.out.println(c.toString());
Cat c1 = new Cat();
if(c1.equals(c)) {
    System.out.println("兩個對象的屬性相同");
}

補充 getClass 獲取到的是類對象

多態

多態指的是對象的多種形態

1. 引用多態
   父類的引用能夠指向子類的對象
   父類的引用能夠指向本類的對象
public static void main(String [] args) {
    Animal d1 = new Animal();
    Animal d2 = new Dog();
    Dog d3 = new Animal(); // 報錯了，由於是子類的引用指向了父類的對象
}
2. 方法多態
    建立本類對象時，調用的時本類的方法
    建立子類對象時，調用的方法時子類重寫的方法或者時父類繼承過來的方法
    Animal d1 = new Animal();
    Animal d2 = new Dog();
    d1.eat(); // 調用父類的eat方法
    d2.eat(); // 調用子類重寫的eat方法

多態中的引用類型轉換

1. 向上類型轉換（隱式/自動類型轉換） 小類型 => 大類型
2. 向下類型轉換（強制類型轉換） 大類型 => 小類型
3. instanceof能夠解決引用對象的類型，來避免轉換類型的安全性問題

package polymorphic;

public class test {
    public static void main(String [] args) {
        Dog dog = new Dog();
        Animal animal = dog;  // 小類型 => 大類型
//        Dog dog2 = animal;    // 報錯了，由於大類型 => 小類型 存在風險
        Dog dog2 = (Dog)animal; // 強制類型轉換，就不報錯了
//        Cat cat =(Cat) animal; // 編譯時Cat類型，運行時時Dog類型
        
        if(animal instanceof Dog) {
            
        } else {
            
        }
        
    }
}

抽象類

使用abstract修飾的類成爲抽象類

1. 某一個父類只知道子類應該含有怎樣的方法，可是沒法肯定這個子類的方法如何實現
2. 從多個具備相同特徵的類中抽象出一個抽象類，以這個抽線類做爲子類的模板，從而避免了子類設計的隨意性

使用規則

abstract定義抽象方法，只有聲明、不須要實現
抽象類中能夠有普通方法，也能夠有抽象方法
抽象類不能直接建立，咱們能夠定義引用變量

public abstract class telphone {
    // 定義抽象方法
    public abstract void call();
    public abstract void message();
    // 抽象方法沒有方法體，所以以分號結束
}

實例設計

// Telphone.java
package abstrated;

public abstract class Telphone {
    // 定義抽象方法
    public abstract void call();
    public abstract void message();
    // 抽象方法沒有方法體，所以以分號結束
}

// Cellphone.java

package abstrated;

public class Celltelphone extends Telphone {
    public void call() {
        System.out.println("經過鍵盤打電話");
    }
    public void message() {
        System.out.println("經過鍵盤發短信");
    }
    
}

// smartphone.java
package abstrated;

public class Smarttelphone extends Telphone{
    public void call() {
        System.out.println("經過語音打電話");
    }
    public void message() {
        System.out.println("經過語音發短信");
    }
}

// initial.java
package abstrated;

public class initial {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Telphone t1 = new Celltelphone(); // 使用父類的引用建立子類對象
        t1.call();
        t1.message();
        
        Telphone t2 = new Smarttelphone(); // 使用父類的引用建立子類對象
        t2.call();
        t2.message();
    }

}

接口

接口能夠理解爲時一種特殊的類，由全局常量和公共的抽象方法來組成

它是類的一種具體實現，而接口定義了某一批類所須要遵照的【規範】，接口並不關心這些類的內部實現，也不關心這些類的實現細節，只是規定了這些類的必須實現的某些方法。3d

接口定義

interface A{//定義一個接口

    public static final String MSG = "hello";//全局常量
    public abstract void print();//抽象方法
}

// X.java

package interfaceDemo1;

interface A{
    public static final String MSG = "hello"; // 全局常量
    public abstract void print(); // 抽象方法
}

interface B{
    public static final int a = 10;
    public abstract void get();
}

public class X implements A,B{
    // X實現了兩個接口
    public void print() {
        System.out.println("接口A的抽象方法print()");
    }
    
    public void get() {
        System.out.println("接口B的抽象方法get()");
    }
    
}

// test.java
package interfaceDemo1;

public class test {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        X x = new X(); // 實例化子類
        A a = new X();
        B b = new X();
        
        x.print();
        x.get();
        a.print();
        b.get();
    }

}