首頁  >  文章  >  Java  >  Java繼承與多型態的概念及實作方法簡介

Java繼承與多型態的概念及實作方法簡介

WBOY
WBOY轉載
2023-04-27 15:46:081407瀏覽

    一、繼承

    1、繼承的概念

    #繼承機制:是物件導向程式設計是程式碼可以重複使用的最重要手段,允許程式設計師在保持原有類特性的基礎上進行擴展,增加新的功能,產生的新類,成為派生類/子類。繼承主要解決的問題是:共性的抽取,實現程式碼的重複使用。

    Java繼承與多型態的概念及實作方法簡介

    2、繼承的語法

    表示類別與類別的繼承關係,需要藉助關鍵字extends,語法如下:

    #修飾符  class  子類/派生類   extends  父類/基類/超類{

           //…………

    }

    • 子類別會將父類別的成員變數或成員方法繼承到子類別中

    • #子類別繼承父類別後,必須新增自己特有的成員,體現與基底類別的不同

    3、父類別成員存取

    (1)子類別中存取父類別的成員變數
    • #不存在同名成員變數時,正常存取就行

    • 存在同名成員變量,使用(super.變數名稱)實作父類別成員變數的存取

    public class Base {
        int a;
        int b;
        int c;
    } 
    public class Derived extends Base{
        int a; // 与父类中成员a同名,且类型相同
        char b; // 与父类中成员b同名,但类型不同
        public void method(){
            a = 100; // 访问父类继承的a,还是子类自己新增的a?
            b = 101; // 访问父类继承的b,还是子类自己新增的b?
            c = 102; // 子类没有c,访问的肯定是从父类继承下来的c
        }
    }
    • 存取成員變數時,優先存取自己的成員變數。即同名成員變數存取時,優先存取子類別的。即:子類別將父類別的成員隱藏了

    • 成員變數存取遵循就近原則,自己有優先自己的,自己沒有則向父類別中查找。

    (2)子類別中存取父類別的成員方法
    • #成員方法名稱不同,正常存取即可

    • #成員方法名字相同,可以透過【super.方法名稱】存取同名父類別方法

    #如果父類別和子類別同名方法的參數清單不同(重載),根據呼叫方法時傳遞的參數選擇適當的方法存取。

    如果父類別和子類別的同名方法原型一致,則存取子類別的

    4、super關鍵字

    super關鍵字的主要作用是:在子類別方法中存取父類別的同名成員。 (只能在非靜態方法中使用)

    public class Base {
        int a;
        int b;
        public void methodA(){
            System.out.println("Base中的methodA()");
        }
        public void methodB(){
            System.out.println("Base中的methodB()");
    }
    public class Derived extends Base{
        int a; 
        char b; 
        // 与父类中methodA()构成重载
        public void methodA(int a) {
            System.out.println("Derived中的method()方法");
        }
        // 与父类中methodB()构成重写
        public void methodB(){
            System.out.println("Derived中的methodB()方法");
        }
        public void methodC(){
            a = 100; // 等价于: this.a = 100;
            b = 101; // 等价于: this.b = 101;
            // 访问父类的成员变量时,需要借助super关键字
            // super是获取到子类对象中从基类继承下来的部分
            super.a = 200;
            super.b = 201;
            methodA(); // 没有传参,访问父类中的methodA()
            methodA(20); // 传递int参数,访问子类中的methodA(int)
            methodB(); // 直接访问,则永远访问到的都是子类中的methodA(),基类的无法访问到
            super.methodB(); // 访问基类的methodB()
        }
    }

    5、子類別建構方法

    子類別物件建構時,需要先呼叫父類別的建構方法,然後執行子類別的建構方法。

    public class Base {
        public Base(){
            System.out.println("Base()");
        }
    }
    public class Derived extends Base{
        public Derived(){
       // super(); // 注意子类构造方法中默认会调用基类的无参构造方法:super(),
       // 用户没有写时,编译器会自动添加,而且super()必须是子类构造方法中第一条语句,
       // 并且只能出现一次
            System.out.println("Derived()");
        }
    }
    • 若父類別顯示定義無參或預設的建構函數,在子類別的建構方法第一行預設有隱含的super()呼叫。

    • 父類別定義帶參數的建構方法時,編譯器不會再給子類別產生預設的建構方法,需要子類別明確定義,並在子類別建構方法中呼叫適當的父類別建構方法

    • 子類別建構方法中,super(……)呼叫父類別建構方法,必須是子類別建構方法的第一個語句

    • super(……)只能在子類別建構方法中出現一次,並且不能和this同時出現

    ##6、super和this

    super和this都可以在成員方法中用來存取成員變數和呼叫其他的成員函數,都可以作為建構方法的第一個語句,那麼它們之間的差異是什麼?

    (1)相同點

    • 都是java的關鍵字

    • 只能在類別的非靜態方法中使用,用來存取非靜態成員方法和屬性

    • 必須作為建構方法中的第一個語句,並且不能同時存在

    (2)不同點

    • this是目前物件的引用,super是子類別物件中從父類別繼承的成員的引用

    • this是非靜態成員方法的一個隱藏參數,super不是隱藏參數

    • 在建構方法中:this()用來呼叫本類別的建構方法,super()用來呼叫父類別建構方法,兩個呼叫不能同時出現在建構方法中

    • 子類別的建構方法中一定會存在super()的調用,但是this()使用者不寫就沒有

    7、程式碼區塊執行順序

    【普通類別】

    • #靜態程式碼區塊先執行,並且只執行一次,在類別載入階段執行

    • 當有物件建立時,才會執行實例程式碼區塊,最後執行建構方法

    • ##【繼承關係上的執行順序】

      父類別靜態程式碼區塊優先於子類別靜態程式碼區塊執行,最早執行
    • 父類別實例程式碼區塊和父類別建構方法緊接著執行
    • 子類別的實例程式碼區塊和建構方法最後執行
    • 第二次實例化子類別物件時,父類別和子類別的靜態程式碼區塊不會再執行

    8、继承方式

    【注】Java中不支持多继承

    Java繼承與多型態的概念及實作方法簡介

    • super只能指代直接父类

    • 继承关系一般不超过三层

    9、final关键字

    • 修饰变量时,表示常量(不能修改)

    • 修饰类:此类不能被继承

    • 修饰方法:表示方法不能被重写

    10、继承和组合

    组合和继承都能实现代码的复用。组合没有涉及到特殊的语法(如extend关键字),仅仅是将一个类的实例作为另一个类的属性。

    • 继承表示对象与对象之间是is-a的关系

    • 组合表示对象与对象之间是has-a的关系

    一般建议:能用组合尽量用组合

    二、多态

    1、向上转型

    通过父类类型的引用调用子类对象,向上转型是安全的

    【发生向上转型的时机】

    • 直接赋值

    • 方法传参

    • 函数的返回值

    public class TestAnimal {
        // 2. 函数传参:形参为父类引用,可以接收任意子类的对象
        public static void eatFood(Animal a) {
            a.eat();
        }
     
        // 3. 作返回值:返回任意子类对象
        public static Animal buyAnimal(String var) {
            if ("狗" == var) {
                return new Dog("狗狗", 1);
            } else if ("猫" == var) {
                return new Cat("猫猫", 1);
            } else {
                return null;
            }
        }
     
        public static void main(String[] args) {
            Animal cat = new Cat("元宝", 2); // 1. 直接赋值:子类对象赋值给父类对象
            Dog dog = new Dog("小七", 1);
        }
    }

    优缺点:

    • 优点:让代码更加灵活

    • 缺点:不能访问到子类特有的方法

    2、重写

    函数名相同、参数列表相同、返回值相同或是【协变类型】(父子类关系)

    【方法重写的规则】

    • 重写的方法访问权限不能比父类中原方法的的权限低;

    • 父类中被static、private、final修饰的方法、构造方法不能被重写;

    • 重写的方法,可以使用 @override 注解来显示指定(帮助我们进行一些合法性的检验)。比如方法名拼写错误,编译会报错;

    • 重写的返回值类型可以不同,但是必须具有父子关系。

    • 被final修饰的方法,叫做密封方法,该方法不能被重写。

    • 外部类只能是public或者默认权限

    【动态绑定和静态绑定】

    • 动态绑定:发生的条件(1、父类引用引用子类对象;2、通过父类引用,可以访问到子类中的方法)。后期绑定,即在编译时不能确定方法的行为,需要等到程序运行时,才能够确定调用哪个类的方法;

    • 静态绑定:前期绑定,编译时,根据用户传递的参数类型确定具体的调用方法(函数重载)

    3、多态

    一个引用调用同一个方法,可以表现出不同的形式,这种思想称为多态。在父类的构造方法中不要调用重写的方法。

    【多态实现的条件】

    • 必须在继承条件下

    • 子类对父类方法进行重写

    • 通过父类引用调用重写的方法

    • 发生了向上转型

    public class Animal(){
        String name;
        int age;
        public Animal(String name, int age){
            this.name = name;
            this.age = age;
        }
        public void eat(){
            System.out.println(name + "吃饭");
            }
    }
    public class Cat extends Animal{
        public Cat(String name, int age){
            super(name, age);
        }
        @Override
        public void eat(){
            System.out.println(name+"吃鱼~~~");
        }
    }
    public class Dog extends Animal {
        public Dog(String name, int age){
            super(name, age);
        }
        @Override
        public void eat(){
            System.out.println(name+"吃骨头~~~");
        }
    }
    public class TestAnimal {
        // 编译器在编译代码时,并不知道要调用Dog 还是 Cat 中eat的方法
       // 等程序运行起来后,形参a引用的具体对象确定后,才知道调用那个方法
       // 注意:此处的形参类型必须时父类类型才可以
        public static void eat(Animal a){
            a.eat();
        }
        public static void main(String[] args) {
            Animal animal1 = new Cat("元宝",2);
            Animal animal2 = new Dog("小七", 1);
            eat(animal1);
            eat(animal2);
        }
    }

    【注】Java中所有的类默认继承Object类

    以上是Java繼承與多型態的概念及實作方法簡介的詳細內容。更多資訊請關注PHP中文網其他相關文章!

    陳述:
    本文轉載於:yisu.com。如有侵權,請聯絡admin@php.cn刪除