Java--面向对象之继承与多态

一、继承

java 复制代码
class Subclass extends Parentclass{
    field;//属性
    method;//方法
}
1.访问成员变量与方法
java 复制代码
public class Base {
    public int a = 1;
    public int b = 2;
}

class Derived extends Base{
    public int a = 11;
    public int c = 3;

    public void test(){
        System.out.println(super.a);
        System.out.println(this.a);
        System.out.println(this.b);
        System.out.println(this.c);
    }
}

class Test {
    public static void main(String[] args) {
        Derived derived = new Derived();
        derived.test();
    }
}

以上代码输出结果为1 11 2 3,要搞清楚其中的意思,我们需要知道super关键字与this关键字的区别

|----------------|--------------------|
| this | super |
| this.data | super.data |
| this.func | super.func |
| this()访问其他构造方法 | super(a,b)访问父类构造方法 |
| 不能在静态方法中使用 ||

在this中父类与子类都有相同属性时,优先访问子类(就近原则);

访问不同属性时,优先父类,父类有访问父类,无则访问子类;子类有访问子类,子类无则报错。

2.重写

把父类方法在子类中重新实现,方法里的内容可以不同。

特点:方法名相同,参数列表相同,返回值相同。

java 复制代码
public class Animal {
    public String name;
    public int age;

    public void shout(){
        System.out.println("发出动物叫声....");
    }
}

class Dog extends Animal{
    @Override
    public void shout() {
        System.out.println("汪汪汪....");
    }
}

class Cat extends Animal{
    @Override
    public void shout() {
        System.out.println("喵喵喵....");
    }
}

class Test {
    public static void main(String[] args) {
        Dog dog = new Dog();
        dog.shout();
        Cat cat = new Cat();
        cat.shout();
    }
3.子类构造方法

构造子类构造方法前一定要完成父类对象的构造,通过super调用父类构造方法。

java 复制代码
public class Animal {
    public String name;
    public int age;

    public Animal(String name, int age) {
        this.name = name;
        this.age = age;
    }
}

class Dog extends Animal{
    public Dog(String name, int age) {
        super(name, age);
    }
}
4.在继承中的静态代码块与实例代码块
java 复制代码
public class Animal {
    public String name;
    public int age;

    static{
        System.out.println("父类静态代码块执行中....");
    }

    {
        System.out.println("父类实例代码块执行中....");
    }

    public Animal(String name, int age) {
        this.name = name;
        this.age = age;
        System.out.println("父类构造方法执行中....");
    }
}

class Dog extends Animal{
    static {
        System.out.println("子类静态代码块执行中....");
    }

    {
        System.out.println("子类实例代码块执行中....");
    }

    public Dog(String name, int age) {
        super(name, age);
        System.out.println("子类构造方法执行中....");
    }
}

class Test {
    public static void main(String[] args) {
        Dog dog = new Dog("旺财",3);
    }
5.final

被final修饰,证明当前类不能被继承。

二、多态

在了解多态前,我们需要了解向上转型

1.向上转型
1.1直接赋值(父类引用引用子类对象)
java 复制代码
public class Animal {
    public String name;
    public int age;

    public Animal(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public void shout(){
        System.out.println("发出动物叫声....");
    }
}

class Dog extends Animal{
    public Dog(String name, int age) {
        super(name, age);
    }

    @Override
    public void shout() {
        System.out.println(this.name+"汪汪汪....");
    }
}

class Test {
    public static void main(String[] args) {
        Animal animal = new Dog("wangcai",2);
    }
1.2利用参数传递
java 复制代码
public class Animal {
    public String name;
    public int age;

    public Animal(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public void shout(){
        System.out.println("发出动物叫声....");
    }
}

class Dog extends Animal{
    public Dog(String name, int age) {
        super(name, age);
    }

    @Override
    public void shout() {
        System.out.println(this.name+"汪汪汪....");
    }
}

class Test {
    public static void test1(Animal animal){
        
    }

    public static void main(String[] args) {
        Dog dog =new Dog("xiaogou",3);
        test1(dog);
    }
1.3返回值传递
java 复制代码
public class Animal {
    public String name;
    public int age;

    public Animal(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public void shout(){
        System.out.println("发出动物叫声....");
    }
}

class Dog extends Animal{
    public Dog(String name, int age) {
        super(name, age);
    }

    @Override
    public void shout() {
        System.out.println(this.name+"汪汪汪....");
    }
}

class Test {
    public static Animal test2(){
        return new Dog("dog",3);
    }
}
2.动态绑定
java 复制代码
public class Animal {
    public String name;
    public int age;

    public Animal(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public void shout(){
        System.out.println("发出动物叫声....");
    }
}

class Dog extends Animal{
    public Dog(String name, int age) {
        super(name, age);
    }

    @Override
    public void shout() {
        System.out.println(this.name+"汪汪汪....");
    }
}

class Test {
    public static void main(String[] args) {
        Animal animal =new Dog("wangcai",3);
        animal.shout();
    }

当anima(父类)这个引用引用dog对象(子类)后,通过animal这个引用调用自己的成员时,当子类重写了父类的方法,这时调用的是子类的重写方法,这就是动态绑定。

动态绑定的条件:

1.父类引用必须引用子类对象

2.子类重写父类方法

注意:父类被static/final修饰,子类不可重写;父类被private修饰也不行;子类重写父类方法时,子类的访问权限要比父类大。

3.向下转型

向下转型不能直接将父类引用引用子类对象,这里使用强制类型转换,将父类强制转换为子类的类型。

java 复制代码
public class Animal {
    public String name;
    public int age;

    public Animal(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public void shout(){
        System.out.println("发出动物叫声....");
    }
}

class Dog extends Animal{
    public Dog(String name, int age) {
        super(name, age);
    }

    @Override
    public void shout() {
        System.out.println(this.name+"汪汪汪....");
    }
}

class Test {
    public static void main(String[] args) {
        Animal animal = new Dog("wangcai",2);
        Dog dog = (Dog) animal;
    }

但是向下转型不安全,我们通常使用instanceof关键字检查

java 复制代码
public class Animal {
    public String name;
    public int age;

    public Animal(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public void shout(){
        System.out.println("发出动物叫声....");
    }
}

class Dog extends Animal{
    public Dog(String name, int age) {
        super(name, age);
    }

    @Override
    public void shout() {
        System.out.println(this.name+"汪汪汪....");
    }
}

class Test {
    public static void main(String[] args) {
        Animal animal = new Dog("wangcai",2);
        if(animal instanceof Dog) {
            Dog dog = (Dog) animal;
        }
    }

所谓的多态其实就是向上转型加动态绑定

相关推荐
叼烟扛炮1 小时前
[LangChain] 学习笔记(15):为什么你的重试没用——429、抖动、fallback 与熔断
java·服务器·前端
严肃小白兔1 小时前
PHP 8.6 正式发布:部分函数应用、原生 I/O 轮询与新特性实战解析
开发语言·php
郝学胜-神的一滴2 小时前
Effective Python 条款36:优雅拼装迭代器与生成器
开发语言·数据结构·人工智能·python·numpy·scikit-learn
文丑颜不良啊2 小时前
LeetCode3401~3420题目解析
java·leetcode
AvocadoZeroOneOI3 小时前
B4500 [GESP202603 三级] 凯撒密码 详细解题报告
c++·算法
Z21-X3 小时前
云原生运维学习笔记:Kubernetes Volume 与 Secret 实验
运维·笔记·学习·云原生·kubernetes
wuyk5553 小时前
Python办公自动化-第04讲-批量新建Excel
开发语言·python·excel
文丑颜不良啊3 小时前
LeetCode3421~3440题目解析
java·leetcode
code2cat4 小时前
【随笔】Java客户端选了HTTP/3,怎样知道请求实际走了哪个版本
java·开发语言·http