2. 程式人生 > 其它 >封裝 繼承 多型

封裝 繼承 多型

阿新 • • 發佈：2021-11-27

封裝

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

//類     private：私有
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;
    }

    //alt + insert

    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;
        }
    }
}

 
package com.oop;

import com.oop.demo04.Student;
/*
    1. 提高程式的安全性，保護資料
    2. 隱藏程式碼的實現細節
    3. 統一介面
    4. 系統可維護增加了
 */
public class Application {
    public static void main(String[] args) {
        Student s1 = new Student();

        s1.setName("思源");

        System.out.println(s1.getName());

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

}

判斷一個類的兩個方法是否相同 主要參考兩個東西：方法名；引數列表

繼承

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

import com.oop.demo05.Person;

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


        Person person = new Person();

    }
}

 
package com.oop.demo05;

//在Java中，所有的類，都預設直接或者間接繼承object
//Person 人 ： 父類
public class Person /*extends object*/{

    //public
    //protected
    //default
    //private
    private int money = 10_0000_0000;

    public void say(){
        System.out.println("說了一句話");
    }

    public int getMoney() {
        return money;
    }

    public void setMoney(int money) {
        this.money = money;
    }
}

package com.oop.demo05;

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

package com.oop.demo05;

//學生    is  人 ： 派生類，子類
//子類繼承父類，就會繼承父類的全部方法！
public class Student extends Person{

    //Ctrl + H
}
  • object (在Java中，所有的類，都預設直接或者間接繼承object)
  • super

super注意點：

  1. super呼叫父類的構造方法，必須在構造方法的第一個
  2. super 必須只能出現在子類的方法或者構造方法中！
  3. super 和 this 不能同時呼叫構造方法！

Vs this：

​ 代表的物件不同：

​ this：本身呼叫著這個物件

​ super：代表父類物件的應用

​ 前提

​ this：沒有繼承也可以使用

​ super：代表父類物件的應用

​ 構造方法

​ this()：本類的構造

​ super()：父類的構造！

package com.oop;

import com.oop.demo05.Student;

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


        Student student = new Student();
        //student.test("思源");
        //student.test1();

    }
}

package com.oop.demo05;

//學生    is  人 ： 派生類，子類
//子類繼承父類，就會繼承父類的全部方法！
public class Student extends Person{

    public Student() {
        //隱藏程式碼： 呼叫了父親類的無參構造
        super("name");//呼叫父親的構造器，必須要在子類構造器的第一行
        System.out.println("Student無參執行了");
    }

    private String name = "siyuan";

    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);//siyuan
        System.out.println(super.name);//lin
    }
}

package com.oop.demo05;

//在Java中，所有的類，都預設直接或者間接繼承object
//Person 人 ： 父類
public class Person /*extends object*/{

    public Person(String name){
        System.out.println("Person無參執行了");
    }

    protected String name = "lin";

    //私有的東西無法被繼承！
    public void print(){
        System.out.println("Person");
    }
}
  • 方法重寫：重點--->多型
package com.oop;

import com.oop.demo05.A;
import com.oop.demo05.B;

public class Application {

    //靜態的方法和非靜態的方法區別很大！
        //靜態方法：方法的呼叫只和左邊，定義的資料型別有關

        //非靜態：重寫
    public static void main(String[] args) {


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

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

    }
}

package com.oop.demo05;

//繼承
public class A extends B{

    //Override 重寫
    @Override//註解：有功能的註解！
    public void test() {
        System.out.println("A=>test");
    }
}

package com.oop.demo05;

//重寫都是方法的重寫，和屬性無關
public class B {
    public void test(){
        System.out.println("B=>test");
    }
}

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

  1. 方法名必須相同
  2. 引數列表必須相同
  3. 修飾符：範圍 可以擴大，但不能縮小： public>protect>default>private
  4. 丟擲的異常：範圍 可以縮小，但不能擴大：ClassNotFoundException --> Exception(大)

重寫，子類的方法和父類必須一致，方法體不同！

為什麼需要重寫：

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

​ Alt + Insert : override;

多型

  • 即同一方法可以根據傳送物件的不同而採用多種不同的行為方式。
  • 一個物件的實際型別是確定的，但可以指向物件的引用型別有很多（父類，有關係的類）
  • 多型存在的條件
    • 有繼承關係
    • 子類重寫父類方法
    • 父類引用指向子類物件
  • 注意：多型是方法的多型，屬性沒有多型性
  • instanceof （型別轉換） 引用型別
package com.oop;

import com.oop.demo06.Person;
import com.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.oop.demo06;

public class Person {

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

package com.oop.demo06;

public class Student extends Person{

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

多型注意事項：

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

不能被重寫的（就更不可能實現多型）：

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

筆記出處——狂神老師

相關推薦

面向物件三大特性 封裝 繼承 多型

1 繼承 1：定義 繼承描敘的是兩個類之間的關係，一個類可以直接使用另一個類中已定義的方法和屬性;

封裝繼承多型

封裝繼承多型 封裝 封裝（資料的隱藏）禁止直接訪問一個物件中 資料的直接表示，而應通過操作介面訪問，稱為資訊隱藏。屬性私有 get/set

Java 封裝繼承多型

this 在每個類的內部，都有一個隱含的成員變數，該類的型別就是該類的型別，該成員變數的名稱是this，this是一個引用，指向自身的物件。

JS使用面向物件思想的示例_封裝繼承多型_class_extend_ES6語法使用

使用JS輸出以下語句： 1只 灰色 的 灰鴨 發著 嘎嘎聲 用翅膀飛行1只 紅色 的 紅頭鴨 沉默著 用翅膀飛行1只 黃色 的 橡皮鴨 發著 嘎嘎聲 用意念飛行1只 白色 的 棉花鴨 是不能飛的啞巴

Day11-封裝-繼承-多型

簡單小結 封裝 高內聚，低耦合 高內聚就是類的內部資料操作細節自己完成，不允許外部干涉。

C++封裝繼承多型的理解

封裝：也就是把客觀事物封裝成抽象的類，並且類可以把自己的資料和方法只讓可信的類或者物件操作，對不可信的進行資訊隱藏。封裝是面向物件的特徵之一，是物件和類概念的主要特性。

封裝 繼承 多型

封裝 該露的露，該藏的藏 我們程式設計要追求”高內聚，低耦合“。高內聚就是類的內部資料操作細節自己完成，不允許外部干涉；低耦合：僅暴露少量的方法給外部使用。

面向物件的三大特徵 封裝 繼承 多型

封裝： 高內聚，低耦合 高內聚：類的內部資料操作細節自己已完成，不允許外部干涉；

封裝繼承多型的複習

來自韓順平，點選此處開始學習！ super關鍵字 定義：super代表父類引用，用於引用父類的屬性和方法。

面向物件三大特性（Java）：封裝繼承多型——

封裝 該露的露，該藏的藏 我們程式設計要追求\"高內聚，低耦合\"。高內聚就是類的內部資料操作細節自己完成，不允許外部干涉；低耦合：僅暴露少量的方法給外部使用。

python 面向物件-繼承、封裝和多型

1、面向物件的三大特性： 繼承、封裝和多型 2、繼承 語法：class Student(父類)：

中繼承父類實現父類方法的快捷鍵_封裝，多型，繼承

技術標籤：中繼承父類實現父類方法的快捷鍵 封裝，多型，繼承 [TOC] 1.封裝 面向物件三大特徵：封裝、繼承、多型。

構造方法可以重寫嗎_C#學習筆記09--構造方法/析構方法/繼承/多型/封裝

技術標籤：構造方法可以重寫嗎 一.構造方法 當建立一個類時, 系統會自動建立一個預設的無參構造方法, 這個方法和類同名, 在建立物件的時候自動呼叫. 預設的構造方法裡面什麼也沒有, 重寫之後就可以在建立物件的

Java繼承、封裝與多型

面向物件的三大核心特性 面向物件開發模式更有利於人們開拓思維，在具體的開發過程中便於程式的劃分，方便程式設計師分工合作，提高開發效率。面向物件程式設計有以下優點。

面向物件(2)__繼承多型1

1.簡單的繼承 class Animal(): def __init__(self): pass def run(self): print(\'animal is running\') class Dog(Animal):

Python面向物件：封裝和多型

一、封裝 封裝是隱藏物件的屬性和實現細節，僅對外公開介面，控制在程式中屬性的讀取和修改的訪問級別。

PHP面向物件 基礎語法 構造方法 析構方法 繼承 多型

面向物件介紹 概述 面向物件是一個程式設計思想。程式設計思想有面向過程和麵向物件

繼承多型與虛擬函式

技術標籤：c++ 1、多型性 1.1多型性是面向物件程式設計的關鍵技術之。若程式設計語言不支援多型性，不能稱為面向物件的語言。利用多型性技術，可以呼叫同一個函式名的函式，實現完全不同的功能。 在C+ +中有中兩

03C++複習.繼承/多型

面向物件的三個基本特徵是：封裝、繼承、多型。其中，封裝可以隱藏實現細節，使得程式碼模組化；繼承可以擴充套件已存在的程式碼模組（類）；它們的目的都是為了——程式碼重用。而多型則是為了實現另一個目的——介

python面向物件(封裝、多型、反射)

目錄 面向物件之封裝 @property 面向物件之多型 面向物件之反射 面向物件之封裝 含義