JAVA物件導向基礎--封裝繼承多型

月亮警察發表於2024-03-11

一、封裝

該顯示的顯示，該隱藏的隱藏
程式設計追求“高內聚，低耦合”
- 高內聚：類的內部資料操作細節自己完成，不允許外部干涉
- 低耦合：僅暴露少量的方法給外部使用
封裝即資料的隱藏，通常應禁止直接訪問一個物件中資料的實際表示，而透過操作介面來訪問，這稱為資訊隱藏
屬性私有，透過get/set方法運算元據

1、封裝的特點

提高程式的安全性，保護資料
隱藏程式碼的實現細節
統一介面
增加系統的可維護性

2、舉例

建立一個Student類

//private : 私有
public class Student02 {
    //屬性私有
    private String name;//姓名
    private int age;//年齡
    private char sex;//性別

    //提供一些可以操作這些屬性的方法
    //get/set方法

    //get方法：獲取這個資料
    public String getName(){
       return this.name;
}
    //set方法：給這個資料設定值
    public void setName(String name){
        this.name = name;
    }
}

透過呼叫get，set方法賦值獲取

public class Appliance {
    public static void main(String[] args) {
        Student02 s1 = new Student02();
        s1.setName("張三");
        System.out.println(s1.getName());//輸出張三
    }
}

注意：當屬性前新增了private時，在main方法中直接使用s1.name,如圖：

注意：快捷鍵Alt+Insert(Fn+Alt+Insert)，可以自動生成get set方法，步驟如下：

按下Alt+Insert-->選擇Getter and Setter

選擇需要的屬性

3、封裝的好處--判斷輸入合法性

//private : 私有
public class Student02 {
    //屬性私有
    private int age;//年齡

    //get方法：獲取這個資料
    public int getAge() {
        return age;
    }
    //set方法：設定這個資料的值
    public void setAge(int age) {
        //進行合法性判斷
        if(age<120 && age>0){
            this.age = age;
        }else {
            this.age = 3;
        }
    }
}

public class Appliance {
    public static void main(String[] args) {
        Student02 s1 = new Student02();
        //s1.setAge(130);//錯誤資料
        //System.out.println(s1.getAge());//輸出3
        s1.setAge(18);//有效資料
        System.out.println(s1.getAge());//輸出18
    }
}

二、繼承

1、什麼是繼承？

繼承的本質是對某一批類的抽象，從而實現對現實世界更好的建模
繼承關係的兩個類，一個為子類（派生類），一個為父類（基類）。
- 子類繼承父類，使用關鍵字extends來表示
- extends的意思是“擴充套件”，子類是父類的擴充套件
- 子類和父類之間，從意義上來講具有”is a“的關係
繼承是類和類之間的一種關係。除此之外，類和類之間的關係還有依賴、組合、聚合等
Java中類只有單繼承，沒有多繼承(即子類只能有一個父類，一個父類可以有多個子類)

例項如下：

先建立一個Person類作為父類

//父類
public class Person {
    //私有屬性
    private String name;
    //方法
    public void say(){
        System.out.println("在說話！");
    }

    //get set方法
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
}

(注意：get/set方法請檢視封裝介紹)

建立一個Student類和Teacher類作為子類

//Person的子類:子類繼承父類的屬性和方法
public class Student extends Person {

}

//Person的子類:子類繼承父類的屬性和方法
public class Teacher extends Person {
    
}

再建立一個帶有main方法的Application類

Student類中什麼也沒有，但是繼承了父類中的name屬性和方法，可以使用

public class Application {
    public static void main(String[] args) {
        Student student = new Student();
        student.setName("張三");//獲取父類中的屬性name
        System.out.print(student.getName());//輸出張三
        student.say();//呼叫父類中的say()
    }
}

2、Object類

快捷鍵Ctrl+H：檢視類之間的父子類關係
注意：需把滑鼠停留在某個類中，再按快捷鍵
圖例如下：

注意：我們發現最上層有一個Object類，是Person類的父類

每一個類預設直接或間接的以Object類作為父類！！！！

例如：

public class Person /*extends Object*/ {
    //什麼也沒寫
}

public class Application {
    public static void main(String[] args) {
        Person person = new Person();
        //person物件還是可以點出很多方法，這些方法都是Object類的方法
        person.toString();
        person.equals();
        person.getClass();
    }
}

以下均為Object類中的方法：

3、super

用於呼叫父類中的方法和屬性

例項：

Person類(父類)

public class Person /*extends Object*/ {
    //protected:受保護的
    protected String name = "張三";

    //print方法
    public void print(){
        System.out.println("Person");
    }
}

Student類(子類)

//Person的子類
public class Student extends Person {
    private String name = "李四";

    //test方法
    public void test(String name){
        //this.name中的name表示Student類中的name屬性
        //等號右邊的name表示test方法的引數name
        this.name = name;
        //super.name中的name表示父類Person類中的name屬性
        super.name = name;
        System.out.println(this.name);
        System.out.println(super.name);
    }

    //print方法
    public void print(){
        System.out.println("Student");
    }
    //方法呼叫也是一樣
    public void test_2(){
        print();//呼叫本類的print方法，輸出Student
        this.print();//呼叫本類的print方法，輸出Student
        super.print();//呼叫父類的print方法，輸出Person
    }
}

Application類，包含main方法

public class Application {
    public static void main(String[] args) {
        Student student = new Student();
        student.test("王五");
        System.out.println("================");
        student.test_2();
    }
}

執行結果如下圖：

注意點：

super呼叫父類的構造方法，必須在構造方法的第一個
super必須且只能出現在子類的方法或構造方法中

public class Person {
    
    public Person() {
        System.out.println("Person類的無參執行了！");
    }
}

public class Student extends Person {
    //無參構造
    public Student() {
        System.out.println("Student類的無參執行了！");
    }
}

public class Application {
    public static void main(String[] args) {
        Student student = new Student();//只new了一個物件，其他操作不做
    }
}

執行結果如下：Person類(父類)的構造方法先執行了，之後才執行了Student類(子類)的構造方法！！！！

原因如下：Student類中的無參構造有一句隱藏程式碼super(),呼叫了父類的無參構造

注意：super();必須放在構造器中的第一行位置，其他位置會報錯無法呼叫

public class Student extends Person {
    //無參構造
    public Student() {
        //隱藏程式碼：呼叫了父類的無參構造(程式碼如下：)
        super();//呼叫父類的構造器必須放在子類構造器的第一行
        System.out.println("Student類的無參執行了！");
    }
}

super和this不能同時呼叫構造方法

Student類修改如下：

public class Student extends Person {
    //無參構造
    public Student() {
        //隱藏程式碼：呼叫了父類的無參構造(程式碼如下：)
        super();//呼叫父類的構造器必須放在子類構造器的第一行
        
        this();//呼叫本類的有參構造 //報錯！！！
        
        System.out.println("Student類的無參執行了！");
    }
    //有參構造
    public Student(String name) {
    }
}

報錯:報錯內容即‘this()'必須放在構造器的第一行，即super和this無法同時呼叫

當父類只有有參構造器，沒有無參構造器時，子類的無參構造中必須呼叫父類的有參構造，否則子類無法定義無參構造

注意：當父類的無參構造器顯示定義時即有無參，super()不會報錯！！

public class Person {
    //有參構造
    public Person(String name) {
        System.out.println("Person類的無參執行了！");
    }
}

public class Student extends Person {
    //無參構造
    public Student() {
        //隱藏程式碼：呼叫了父類的無參構造(程式碼如下：)
        super();//報錯！！！！！
        //原因：父類沒有無參構造
        System.out.println("Student類的無參執行了！");
    }
}

報錯原因：父類沒有無參構造
**解決辦法：利用super("張三")；呼叫父類的有參構造器如下：
```
super("張三");
```

super 與 this

代表的物件不同：

this：本身呼叫者這個物件
super：代表父類物件的應用

使用前提：

this：沒有繼承也可以使用
super：只有在繼承條件下才可以使用

構造方法：

this()：本類的構造
super()：父類的構造

三、重寫

重寫都是對方法的重寫，與屬性無關

靜態方法和非靜態方法的差別很大！！！

注意：父子類需是同一種方法，即均為靜態或均為非靜態

1、靜態方法：

方法的呼叫只和左邊定義的資料型別有關

//父類
public class B {
    //靜態方法
    public static void test(){
        System.out.println("B=>test()");
    }
}

//子類
public class A extends B {
    //靜態方法
    public static void test(){
        System.out.println("A=>test()");
    }
}

public class Application {
    public static void main(String[] args) {
        A a = new A();
        a.test();//輸出A=>test();
        
        B b = new A();//父類的引用(b)指向了A類
        b.test();//輸出B=>test();!!!!
    }
}

2、非靜態方法：

重寫

注意：重寫的方法不能是私有的方法（即private的方法）

//父類
public class B {
    //非靜態方法
    public  void test(){
        System.out.println("B=>test()");
    }
}

//子類
public class A extends B {
    //非靜態方法
    //子類重寫了B(父類)的方法，那麼就是執行子類的方法
    public  void test(){
        System.out.println("A=>test()");
    }
}

public class Application {
    public static void main(String[] args) {
        A a = new A();
        a.test();//輸出A=>test();
        B b = new A();
        b.test();//輸出A=>test();!!!!!
    }
}

快速重寫父類方法：

在子類中按快捷鍵Alt+Insert（Fn+Alt+Insert），選擇Override Methods...

點選後會自動生成以下程式碼

//@Override：重寫
@Override  //註解：有功能的註釋
//子類重寫了B(父類)的方法，那麼就是執行子類的方法
//沒有重寫則呼叫父類的方法
public void test() {
    //內容可自行修改
    System.out.println("A=>test()");
    //super.test();//自動生成，super用於呼叫父類的方法
}

3、小結：

重寫需要有繼承關係，子類重寫父類的方法！

方法名必須相同
引數列表必須相同
修飾符：範圍可以擴大但不能縮小
- public>Protected>Default>private
丟擲的異常：範圍可以被縮小但不能擴大
- 例如：ClassNotFoundException(小) --->Exception(大)
子類的方法和父類的方法必須一致，但方法體不同
方法重寫快捷鍵：Alt+Insert

為什麼要重寫？

父類的功能，子類不一定需要或者不一定滿足

四、多型

多型：即同一方法可以根據傳送物件的不同而採用多種不同的行為方式

一個物件的實際型別是確定的，但可以指向物件的引用型別有很多(父類，有關係的類)

1、情況一：無重寫

//父類
public class Person {
    public void run(){
        System.out.println("run");
    }
}

//父類
public class Person {
    public void run(){
        System.out.println("run");
    }
}

//子類
public class Student extends Person {
    public void say(){
        System.out.println("say");
    }
}

//測試類
public class Applicaton {
    public static void main(String[] args) {
        //一個物件的實際型別是確定的
        //new Student(); 或者 new Person();
        //但一個物件可以指向的引用型別是不確定的：父類的引用可以指向子類

        //Studnet子類：可以呼叫自己的方法或者繼承父類的方法
        Student s1 = new Student();

        //Person父類：引用物件可以指向子類，但無法呼叫子類獨有的方法
        Person s2 = new Student();
        Object s3 = new Student();

        //物件可以執行哪些方法，主要是看物件左邊的型別，和右邊關係不大！！
        s1.run();//子類呼叫父類的方法，輸出run
        s2.run();//輸出run
        
        //s2.say();//錯誤！！！父類引用物件無法呼叫子類獨有的方法
        //((Student)s2).say();//強制型別轉換即可呼叫
    }
}

2、情況二：重寫

Student類重寫了父類的say()方法：

//子類
public class Student extends Person {

    //重寫父類方法：會執行子類的方法
    @Override
    public void run() {
        System.out.println("run_02");
    }

    public void say(){
        System.out.println("say");
    }
}

測試類和Person類不變：

//父類
public class Person {
    public void run(){
        System.out.println("run");
    }
}

//測試類
public class Applicaton {
    public static void main(String[] args) {
        
        //Studnet子類：可以呼叫自己的方法或者繼承父類的方法
        Student s1 = new Student();

        //Person父類：引用物件可以指向子類，但無法呼叫子類獨有的方法
        Person s2 = new Student();
        Object s3 = new Student();

        s1.run();//輸出run_02
        s2.run();//重寫父類方法：會執行子類的方法  輸出run_02!!!!
    }
}

3、注意事項：

多型是方法的多型，屬性沒有多型
多型的使用需要類之間有父子類關係
型別轉換異常會報錯：ClasCastException
多型存在條件：

需要有父子類關係(繼承關係)
方法需要重寫
父類的引用指向子類物件
- Father f1 = new Son();
無法被重寫的方法有：
- static方法：靜態方法屬於類和類一起載入，不屬於例項，無法被重寫
- final 常量
- private 方法

五、instanceof

判斷兩個類是否相似,是否可以比較轉換（型別轉換），相似返回true，不相似返回false,語法如下：

注意：有關係的兩個類才能進行比較

System.out.println(X instanceof Y);

public class Application {
    public static void main(String[] args) {

        //instanceof 二者有關係才能進行判斷

        //Object > String
        //Object > Person > Student
        //Object > Person > Teacher
        Object obj = new Student();
        System.out.println(obj instanceof Person);//True
        System.out.println(obj instanceof Student);//True
        System.out.println(obj instanceof Object);//True
        System.out.println(obj instanceof Teacher);//False; //Student類和Teacher類是同級
        System.out.println(obj instanceof String);//False;  //String是Object的子類
        System.out.println("==============================");

        Person person = new Student();
        System.out.println(person instanceof Person);//True
        System.out.println(person instanceof Student);//True
        System.out.println(person instanceof Object);//True
        System.out.println(person instanceof Teacher);//False;
        //System.out.println(person instanceof String);//編譯報錯 //Person與String沒有聯絡無法比較
        System.out.println("==============================");

        Student student = new Student();
        System.out.println(student instanceof Person);//True
        System.out.println(student instanceof Student);//True
        System.out.println(student instanceof Object);//True
        //System.out.println(student instanceof Teacher);//編譯報錯 //Student類和Teacher類沒有聯絡無法比較
        //System.out.println(person instanceof String);//編譯報錯

    }
}

1、強制型別轉換

//父類
public class Person {
    public void to(){
        System.out.println("to");
    }
}

//子類
public class Student extends Person {
    public void go(){
        System.out.println("go");
    }
}

//測試類
public class Application {
    public static void main(String[] args) {
        //型別轉換：父類  子類

        Student s1 = new Student();
        s1.go();//子類方法
        //子類轉為父類，可能會丟失自己本來的一些方法
        //子類可以直接轉為父類
        Person s2 = s1;
        s2.to();//父類方法

        //父類需強制轉換為子類
        Person p1 = new Person();
        //p1.go();//報錯，父類無法使用子類的方法，需要強制轉換
        //強制轉換
        Student p2 = (Student) p1;
        p2.go();//子類方法
        //以上兩句合為一句如下：
        ((Student)p1).go();
    }
}

2、小結：

父類引用指向子類的物件‘
向上轉型：把子類轉為父類
向下轉型：把父類轉為子類（強制轉換）
強制轉換的作用：
- 方便方法的呼叫，減少重複程式碼

【Java】瘋狂Java基礎（一）——物件導向的特徵：繼承、封裝和多型
2018-03-28
Java物件特徵繼承封裝多型
[JAVA] Java物件導向三大特徵：封裝、繼承、多型
2020-04-01
Java物件特徵封裝繼承多型
物件導向三大特性-----封裝、繼承、多型
2019-07-23
物件封裝繼承多型
物件導向三大特徵（封裝/繼承/多型）
2022-01-15
物件特徵封裝繼承多型
物件導向基礎(1)--繼承多型重構
2014-03-14
物件繼承多型
java核心思想物件導向三大特性（封裝，繼承，多型）
2020-11-04
Java物件封裝繼承多型
物件導向的三個基本特徵是：封裝、繼承、多型
2015-08-27
物件特徵封裝繼承多型
go物件導向思想:封裝、繼承、多肽
2020-12-30
Go物件封裝繼承
物件導向:封裝,多型
2019-08-06
物件封裝多型
java物件導向繼承
2020-11-27
Java物件繼承
js:物件導向程式設計，帶你認識封裝、繼承和多型
2017-06-08
JS物件程式設計封裝繼承多型
專案過程中如何使用物件導向的特徵：繼承，封裝，多型，介面
2013-06-28
物件特徵繼承封裝多型
物件導向的三大特徵，封裝、繼承、多型的個人理解以及程式碼分析
2019-05-29
物件特徵封裝繼承多型
如何講清楚 Java 物件導向的問題與知識？（類與物件，封裝，繼承，多型，介面，內部類...）
2021-01-28
Java物件封裝繼承多型
物件導向:繼承
2019-08-05
物件繼承
物件導向--繼承
2019-01-19
物件繼承
物件導向-繼承
2020-10-22
物件繼承
php物件導向多繼承實現
2018-01-21
PHP物件繼承
Java入門教程九(封裝繼承多型)
2019-06-09
Java封裝繼承多型
java封裝繼承以及多型(含程式碼)
2021-07-13
Java封裝繼承多型
Java的三大特性：封裝、繼承、多型
2020-11-09
Java封裝繼承多型
[.net 物件導向程式設計基礎] (12) 物件導向三大特性——繼承
2015-06-06
物件程式設計繼承
Java基礎之淺談繼承、多型
2022-04-03
Java繼承多型
java 的四個基本特性 ——封裝繼承多型抽象
2020-05-01
Java封裝繼承多型抽象
5-Java物件導向-繼承(下)
2021-09-09
Java物件繼承
java學習——物件導向之繼承
2020-12-07
Java物件繼承
JAVA物件導向高階一：繼承
2024-03-23
Java物件繼承
Golang物件導向_繼承
2018-09-14
Golang物件繼承
物件導向之繼承
2018-05-24
物件繼承
php物件導向--繼承
2016-07-26
PHP物件繼承
Java物件導向--多型
2020-11-17
Java物件多型
JAVA（一）JAVA基礎/物件導向基礎/高階物件導向
2014-02-08
Java物件
java-物件導向程式設計--繼承
2018-03-20
Java物件程式設計繼承
物件導向之封裝（Java）
2020-12-19
物件封裝Java
~~核心程式設計（五）：物件導向——多繼承~~
2019-07-17
程式設計物件繼承
物件導向之_繼承概念
2019-01-01
物件繼承
Javascript物件導向與繼承
2018-04-06
JavaScript物件繼承
Java基礎-物件導向基礎
2018-05-12
Java物件

JAVA物件導向基礎--封裝 繼承 多型