一、封裝（Encapsulation）

封裝也稱信息隱藏，是指利用抽象數據類型把數據和基於數據的操作封裝起來，使其成為一個不可分割的整體，數據隱藏在抽象數據內部，盡可能的隱藏數據細節，只保留一些接口使其與外界發生聯系

封裝性的思想：

• 將類的屬性私有化
• 提供公共的方法（setter & getter）來實現調用

package com.yyx.pratice;

/**
 * JavaBean
 */
public class Person {
    private String name;
    private Integer age;

    public
 
 Person() {
        super();
    }

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

    /*
     * 封裝屬性
     */
    public String getName() {
        return name;
    }

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

    
 
public Integer getAge() {
        return age;
    }

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

二、繼承（Inheritance）

繼承是從已有的類中派生出新的類，新的類能吸收已有類的數據屬性和行為，並能擴展新的能力

繼承所表達的就是一種對象類之間的相交關系，它使得某類對象可以繼承另外一類對象的數據成員和成員方法。

若類B繼承類A，則屬於B的對象便具有類A的全部或部分性質(數據屬性)和功能(操作)，我們稱被繼承的類A為基類、父類或超類，而稱繼承類B為A的派生類或子類

註意：java中類的繼承性只支持單繼承：一個類只能繼承一個父類。反之，一個父類可以有多個子類；一個接口可以有多個父類，也就是接口可以是多繼承

子類實例化對象會先創建父類的對象

package com.yyx.pratice;

public class Person {
    private String name;
    private Integer age;

    public Person() {
        super();
        System.out.println("我是父類的空參構造器");
    }

    public Person(String name, Integer age) {
        super();
        this.name = name;
        this.age = age;
        System.out.println("我是父類的有參構造器");
    }

    public String getName() {
        return name;
    }

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

    public Integer getAge() {
        return age;
    }

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

    public void eat() {
        System.out.println("吃飯!");
    }

    public void walk() {
        System.out.println("走路!");
    }
}

package com.yyx.pratice;

public class Student extends Person {
    private String stuNo;

    public Student() {
        super();
    }

    public Student(String name, Integer age, String stuNo) {
        super(name, age);
        this.stuNo = stuNo;
    }

    public String getStuNo() {
        return stuNo;
    }

    public void setStuNo(String stuNo) {
        this.stuNo = stuNo;
    }

    @Override
    public void eat() {
        super.eat();// 顯示調用父類的eat()方法
        System.out.println("我重寫了父類的eat()方法");
    }

    public void study() {
        System.out.println("子類自己的study()方法");
    }
}

package com.yyx.pratice;

public class JavaPratice {
    public static void main(String[] args) {
        Student student=new Student();
        student.eat();
        student.walk();
        student.study();
        
        Student stu=new Student("李四", 23, "1232");
        stu.eat();
        stu.walk();
        stu.study();
    }
}

運行結果：

我是父類的空參構造器
吃飯!
我重寫了父類的eat()方法
走路!
子類自己的study()方法
我是父類的有參構造器
吃飯!
我重寫了父類的eat()方法
走路!
子類自己的study()方法

三、多態（Polymorphism）

多態性，可以理解為一個事物的多種表型形態。 兩種表現形式：1）方法的重載與重寫 2）子類對象的多態性

子類對象的多態性即父類的引用指向子類對象，父類引用只能調用父類中存在的方法和屬性，不能調用子類的擴展部分，因為父類引用指向的是堆中子類對象繼承的父類；

但是如果強制把超類轉換成子類的話，就可以調用子類中新添加而超類沒有的方法了；同時，父類中的一個方法只有在父類中定義而在子類中沒有重寫的情況下，才可以被父類類型的引用調用；

對於父類中定義的方法，如果子類中重寫了該方法，那麽父類類型的引用將會調用子類中的這個方法，這就是動態連接

子類對象的多態性使用的前提：①要有類的繼承或實現②要有子類對父類方法的重寫

程序運行分為編譯狀態和運行狀態。對於多態性來說，編譯時，"看左邊"，將此引用變量理解為父類的類型；運行時，"看右邊",關註於真正對象的實體：子類的對象。那麽執行的方法就是子類重寫的

package com.yyx.pratice;

public class JavaPratice {
    public static void main(String[] args) {
        Person person = new Student();
        person.eat();// 只能調用子類已經重寫的父類Person的eat()方法
        if (person instanceof Student) {
            Student stu1 = (Student) person;
            /*
             * 調用子類才有的方法
             */
            stu1.study();
            stu1.walk();
        }

        Behavior behavior = new Student();
        behavior.walk();// 只能調用子類已經重寫的接口Behavior的walk()方法
        if (behavior instanceof Student) {
            Student stu2 = (Student) behavior;
            /*
             * 調用子類才有的方法
             */
            stu2.study();
            stu2.eat();
        }
    }
}

class Student extends Person implements Behavior {

    @Override
    public void eat() {
        super.eat();
    }

    @Override
    public void walk() {
        System.out.println("人都要走路");
    }

    public void study() {
        System.out.println("學生要學習");
    }

}

class Person {
    public void eat() {
        System.out.println("人都要吃飯");
    }
}

interface Behavior {
    void walk();
}

Java面向對象的三大特征詳解