java封裝繼承以及多型(含程式碼)

輕狂書生han發表於2021-07-13
Java封裝繼承多型

封裝

  • 該露的露，該藏的藏
    • 我們程式設計要追求，“高內聚，低耦合”。高內聚就是類的內部資料操作細節自己完成。不允許外部干涉；低耦合：僅暴漏少量的方法給外部使用。
  • 封裝（資料的隱藏）
    • 通常，應禁止訪問一個物件中資料的實際表示，而應通過操作介面來訪問，這稱為資訊隱藏。
  • 記住這句話就夠了：屬性私有，get/set
package com.baidu.oop.demo04;

//類
public class Student {

    //私有屬性
    private String name; //名字
    private int id;//學號
    private char sex;//性別
    private int age;

    //提供一些方法操作和這個屬性的方法！
    //提供一些public的get，set方法

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

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public char getSex() {
        return sex;
    }

    public void setSex(char sex) {
        this.sex = sex;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        if (age>120 || age<0) {//不合法
            this.age = 3;
        }else {
            this.age = age;
        }
    }


}

//測試類

import com.baidu.oop.demo04.Student;

/*
    1.提高程式的安全性，保護資料
    2.隱藏程式碼的實現細節
    3.統一介面
    4.系統可維護增加了
 */
//一個專案應該只存在一個main方法
public class Application {
    public static void main(String[] args) {
        Student s1 = new Student();

        s1.setName("韓鎖");

        //方法名，引數列表
        System.out.println(s1.getName());

        s1.setAge(-1);//不合法
        System.out.println(s1.getAge());
    }

    //alt+insert
}

繼承

  • 繼承的本質是對某一批類的抽象。從而實現對現實世界更好建模
  • extents的意思是“擴充套件”。子類是弗雷的擴充套件。
  • Java中類只有單繼承，沒有多繼承！(一個兒子只能有一個爸爸，但是一個爸爸可以有多個兒子)
  • 繼承是類和類之間的一種關係。除此以外，類和類之間的關係還有依賴，組合，聚合等。
  • 繼承關係的兩個類，一個為子類（派生類），一個為父類（基類）。子類繼承父類，使用關鍵字extends類表示。
  • 子類和父類之間，從意義上講應該具有“is a”的關係
  • object類
  • super
  • 方法重寫
//person類
package com.baidu.oop.demo05;

//在Java中，所有的類，都預設直接或者間接繼承Object類
//Person 人 : 父類
public class Person /*extends Object*/{
    public Person() {
        System.out.println("Person無參執行了");
    }

    //public
    //protected
    //default
    //private
    protected String name = "輕狂書生";

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

}
//teacher類
package com.baidu.oop.demo05;

//Teacher is 人  ：派生類或子類
public class Teacher extends Person{

}
//學生類
package com.baidu.oop.demo05;

//學生 is 人 : 派生類：子類
//子類繼承了父類，就會擁有父類的全部方法！
public class Student extends Person{
    public Student(){
        //隱藏程式碼：呼叫了父類的無參構造
        super();//呼叫父類的構造器，必須要在子類的構造器的第一行
        System.out.println("Student無參構造執行了");
    }

    private String name = "韓鎖";

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

    public void test1(){
        print();//Student
        this.print();//Student
        super.print();//Person
    }

    public void test(String name){
        System.out.println(name);
        System.out.println(this.name);
        System.out.println(super.name);

    }

}
//測試類
package com.baidu.oop.demo05;

public class Application {

    public static void main(String[] args) {

        Student student = new Student();

        //student.test("鎖子哥");
        //student.test1();
    }
}
/*
super注意點：
    1.super呼叫父類的構造方法，必須在構造方法的第一行
    2.super必須只能出現在子類的方法或者構造方法中！
    3.super和this不能同事呼叫構造方法！

VS this：
    1.代表的物件不同
        this：本身呼叫的這個物件
        super： 代表父類物件的應用
    前提
        this： 沒有繼承也可以使用
        super：只能在繼承條件下才可以使用
    構造方法
        this();本類的構造
        super();父類的構造
 */


    //靜態方法和非靜態方法的區別很大
    //靜態方法：方法的呼叫只能和左邊，定義的資料型別有關
    
    //非靜態：重寫
    public static void main(String[] args) {


        A a = new A();
        a.test();//A

        //父類的引用指向子類
        B b = new A();//子類重寫了父類的方法
        b.test();//B
    }

/*
重寫:需要有繼承關係，子類重寫父類的方法！
    1.方法名必須相同
    2引數列表必須相同
    3.修飾符：範圍可以擴大但不能縮小： public>protected>default>private
    4.丟擲異常：範圍，可以被縮小，但不能擴大： ClassNotFoundException--->Exception(大)
重寫，子類的方法和父類必須要一致，方法體不同！

為什麼需要重寫：
    1.父類的功能，子類不一定需要，或者不一定滿足
    Alt + Insert ： override;
    
 */

多型

  • 動態編譯：型別：可擴充套件性
  • 即同一方法可以根據傳送物件的不同而採用多種不同的行為方式
  • 一個物件的實際型別是確定的，但可以只想物件的引用的型別有很多（父類，有關係的類）
  • 多型存在的條件
    • 有繼承關係
    • 子類重寫父類方法
    • 父類引用只想子類物件
  • 注意：多型是方法的多型，屬性沒有多型性
  • instanceof （型別轉換） ~ 引用型別，判斷一個物件是什麼型別~
package com.baidu.oop;

import com.baidu.oop.demo06.Person;
import com.baidu.oop.demo06.Student;

public class Application {

    public static void main(String[] args) {
        //一個物件的實際型別是確定的
        //new Student();
        //new  Person();

        //可以指向的引用型別就不確定了，父類的引用指向子類的型別
        //Student能呼叫的方法都是自己的或者繼承父類的
        Student s1 = new Student();
        //Person 父型別，可以指向子類，但是不能呼叫子類獨有的方法
        Person s2 = new Student();//父類的引用指向子類的型別
        Object s3 = new Student();

        //物件能執行那些方法，主要看物件左邊的型別，和右邊關係不大
        ((Student)s2).eat();//子類重寫了父類的方法，執行了子類的方法
        //s1.eat();

    }


}

package com.baidu.oop.demo06;

public class Student extends Person{
    @Override
    public void run() {
        System.out.println("son");
    }
    public void eat(){
        System.out.println("eat");
    }
}


package com.baidu.oop.demo06;

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



/*
多型注意事項：
1.多型是方法的多型，屬性沒有多型
2.父類和子類，有聯絡  型別轉換異常！ ClassCastException！
3.存在條件：繼承關係，方法需要重寫，父類引用指向子類物件 father f1 = new Son();

    1.static方法，屬於類他不屬於例項
    2.final常量
    3.privat方法
 */


//instanceof和型別轉換
package com.baidu.oop;

import com.baidu.oop.demo06.Person;
import com.baidu.oop.demo06.Student;
import com.baidu.oop.demo06.Teacher;

public class Application {

    public static void main(String[] args) {
        //Object > String
        //Object > Person > Teacher
        //Object > Person > Student
        Object object = new Student();

        //System.out.println(X instanceof Y);//能不能編譯通過

        System.out.println(object instanceof Student);//True
        System.out.println(object instanceof Person);//T
        System.out.println(object instanceof Object);//T
        System.out.println(object instanceof Teacher);//False
        System.out.println(object instanceof String);//F
        System.out.println("--------------------------------------------");
        Person person = new Student();

        System.out.println(person instanceof Student);//True
        System.out.println(person instanceof Person);//T
        System.out.println(person instanceof Object);//T
        System.out.println(person instanceof Teacher);//False
        //System.out.println(person instanceof String);//編譯報錯

        Student student = new Student();
        System.out.println("--------------------------------------------");
        System.out.println(student instanceof Student);//True
        System.out.println(student instanceof Person);//T
        System.out.println(student instanceof Object);//T
        //System.out.println(student instanceof Teacher);//編譯出錯
        //System.out.println(person instanceof String);//編譯報錯
    }


}

import com.baidu.oop.demo06.Person;
import com.baidu.oop.demo06.Student;

public class Application {

    public static void main(String[] args) {
        //型別之間的轉化：父 子

        //高                   低
        Person obj = new Student();
        //Student將這個物件轉換為Student型別，我們就可以使用Student型別的方法了
        Student student = (Student)obj;
        student.go();
        //((Student) obj).go();
    }

相關文章