javaSE-----继承和多态

🕗 发布于 2024-03-08 16:44 java 开发语言

一.初识继承：

1.1什么是继承，为什么需要继承：

1.2继承的概念与语法：

一.初识继承：

1.1什么是继承，为什么需要继承：

Java中使用类对现实世界中实体来进行描述，类经过实例化之后的产物对象，则可以用来表示现实中的实体，但是现实世界错综复杂，事物之间可能会存在一些关联，那在设计程序是就需要考虑。👌👌👌

那具体来说是怎么样的呢？🧐🧐🧐举个例子，比如猫狗，他们都是一个动物：

用Java语言来描述就是：

class Cat{
    public String name;
    public int age;

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

     public void eat(){
         System.out.println(this.name+"正在吃！");
     }
 }

 class Dog{
     public String name;
     public int age;

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

     public void eat(){
         System.out.println(this.name+"正在吃！");
     }
 }
 
public class Test1 {
    public static void main(String[] args){
        Dog dog = new Dog("小黄",5);
        dog.eat();
        Cat cat = new Cat("小花",6);
        cat.eat();
    }
}

通过观察，我们可以发现，其中有诸多的地方重复，但是两个对象都从属于动物，那能否将这些共性抽取呢？面向对象思想中提出了继承的概念，专门用来进行共性抽取，实现代码复用。😀😀😀

1.2继承的概念与语法：

继承(inheritance)机制：是面向对象程序设计使代码可以复用的最重要的手段，它允许程序员在保持原有类特性的基础上进行扩展，增加新功能，这样产生新的类，称派生类。继承呈现了面向对象程序设计的层次结构，体现了由简单到复杂的认知过程。继承主要解决的问题是：共性的抽取，实现代码复用。🧐🧐🧐🧐

语法实现：

修饰符 class 子类 extends 父类 {
// ... 
}

具体来说：


class Animal{
    public String name;
    public int age;

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

    public void eat(){
        System.out.println(this.name+"正在吃！");
    }
}
//子类会继承父类的内容，所以子类无需自己定义其他内容
class Dog extends Animal {

    public Dog(String name, int age) {
        super(name, age);
                        //当子类继承父类之后，要先帮助父类进行成员的初始化
    }                    //此时需要通过super关键字来实现
    public void bark(){//子类中特有的方法
        System.out.println(this.name+"正在汪汪汪~");
    }
}
 class Cat extends Animal{

     public Cat(String name, int age) {
         super(name, age);//当子类继承父类之后，要先帮助父类进行成员的初始化
     }                    //此时需要通过super关键字来实现

     public void miaomiao(){//子类中特有的方法
         System.out.println(this.name+"正在喵喵叫~");
     }
 }
 //测试方法
public class Test1 {
    public static void main(String[] args){
        Dog dog = new Dog("小黄",5);
        dog.eat();//dog类中并没有定义任何成员变量，name和age属性肯定是从父类Animal中继承下来的
        dog.bark();
        System.out.println("=======================================");
        Cat cat = new Cat("小花",6);
        cat.eat();//cat类中并没有定义任何成员变量，name和age属性肯定是从父类Animal中继承下来的
        cat.miaomiao();
    }
}

输出结果：

注意：

🐻子类会将父类中的成员变量或者成员方法继承到子类中了

🐻子类继承父类之后，必须要新添加自己特有的成员，体现出与基类的不同，否则就没有必要继承了

🐻当子类继承父类之后，要先帮助父类进行成员的初始化，此时需要通过super关键字来实现。（后面介绍super关键字）

二.成员的访问：

在继承体系中，子类将父类中的方法和字段继承下来了，那在子类中能否直接访问父类中继承下来的成员呢？🧐🧐🧐答案是可以的，这时就需要用到super关键字：

2.1super关键字

🐻super.data:访问父类的成员变量

🐻super.func()：访问父类的方法

🐻super():访问父类的构造方法

class Base{
    protected int a;
    protected int b;
    protected int c;
    protected int d;

    public Base(int a, int b, int c, int d) {
        this.a = a;
        this.b = b;
        this.c = c;
        this.d = d;
    }
    public void methodA(){
        System.out.println("父类的方法!");
    }
}
class Drived extends Base{
    int c;
    int d;

    public Drived(int a, int b, int c, int d) {
        super(a, b, c, d);//访问父类的构造方法
    }

    @Override
    public String toString() {
        return "Drived{" +
                "a=" + a +
                ", b=" + b +
                ", c=" + c +
                ", d=" + d +
                '}';
    }

    public void method(){
        super.a = 10;
        super.b = 20;//supr.data直接访问父类成员变量
        d = 30;//访问从父类继承下来的d
        this.c = 40;
        this.a = 20;//覆盖了刚才调用的父类成员变量
    }
    public void methodB(){
        super.methodA();//调用父类的方法
        System.out.println("子类的方法！");
    }

}
public class Test1 {
    public static void main(String[] args){
        Drived d = new Drived(0,0,0,0);
        d.methodB();
        d.method();
        System.out.println(d);
    }
}

运行结果：

🐻 其中成员的访问顺序是：先看子类有没有，子类有，优先访问子类的成员，子类没有，去父类中找，父类中也没有，就报错。

2.2this和super的区别：

super 和 this 都可以在成员方法中用来访问：成员变量和调用其他的成员函数，都可以作为构造方法的第一条语句，那他们之间有什么区别呢？

相同点：

1.😺 都是 Java 中的关键字

2.😺 只能在类的非静态方法中使用，用来访问非静态成员方法和字段

3. 😺 在构造方法中调用时，必须是构造方法中的第一条语句，并且不能同时存在

不同点：

1. 🐻this 是当前对象的引用，当前对象即调用实例方法的对象， super 相当于是子类对象中从父类继承下来部分成员的引用

2. 🐻 在非静态成员方法中， this 用来访问本类的方法和属性， super 用来访问父类继承下来的方法和属性

3. 🐻 在构造方法中： this(...) 用于调用本类构造方法， super(...) 用于调用父类构造方法，两种调用不能同时在构造方法中出现

4. 🐻 构造方法中一定会存在 super(...) 的调用，用户没有写编译器也会增加，但是 this(...) 用户不写则没有

三.再谈初始化:

在对成员变量进行初始化的过程中，我们会用到静态代码块，实例代码块和构造方法，那在实际的运行过程中，他们的运行次序是怎样的呢？我们先看以下代码：

class Animal {
    public String name;
    public int age;
    public String color;

    static {
        System.out.println("父类的静态代码块，Animal::static{}");
    }

    {
        System.out.println("父类的实例代码块，Animal::{}");
    }

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

    public void eat() {
        System.out.println(this.name +" 正在吃饭！");
    }
}
class Dog extends Animal{
    static {
        System.out.println("子类的静态代码块，Dog::static{}");
    }
    {
        System.out.println("子类的实例代码块,Dog::{}");
    }
    public Dog() {
        super("haha",10,"黄色");//虽然 调用了父类的构造方法 ，
        System.out.println("子类的构造方法，Dog()"); // 但是 并没有产生父类对象，此时 只是帮你进行初始化父类的成员
    }
    public void bark() {
        System.out.println(this.name +" 正在汪汪汪！");
    }
}

public class Test1 {
    public static void main(String[] args) {
        Dog dog1 = new Dog();
        System.out.println("==============");
        Dog dog2 = new Dog();
    }
}

运行结果：

由此，我们可以得出（执行顺序的）结论：

1.父类的静态代码块，子类的静态代码块

2.父类的实例代码块，父类的构造方法

3.子类的实例代码块，子类的构造方法

----------》静态代码块在整个程序中只执行一次

小结：

继承的好处：
1.提高了代码的复用性（多个类相同的成员可以放在同一个类中）
2.提高了代码的维护性（如果方法的代码需要修改，只修改一处即可）
继承的坏处：
1.继承让类与类建立了关系，类的耦合性增强
2.当父类发生变化时，子类实现也不得不跟着变化，削弱了子类的独立性

四.初识多态：

4.1多态的概念：

通俗来说，就是多种形态，具体点就是去完成某个行为，当不同的对象去完成时会产生出不同的状态。🧐🧐🧐🧐

举例来说就是我们日常生活中的打印机，分为黑白打印和彩印，完成打印这个行为，黑白打印机和彩印机所展现的打印状态完全不同。或则上面的猫狗完成吃东西这个行为，不同的动物也会导致吃东西的状态不同。

4.2多态的实现条件：

在 java 中要实现多态，必须要满足如下几个条件，缺一不可：

1. 必须在继承体系下

2. 子类必须要对父类中方法进行重写

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

4.2.1那么什么是重写？😺

重写 (override) ：也称为覆盖。重写是子类对父类非静态、非 private 修饰，非 final 修饰，非构造方法等的实现过程进行重新编写, 返回值和形参都不能改变 。 即外壳不变，核心重写！ 重写的好处在于子类可以根据需要，定义特定于自己的行为。也就是说子类能够根据需要实现父类的方法。

简单总结重写就是：

1.方法名相同

2.方法的参数列表相同（个数，顺序，类型）

3.方法的返回值类型相同

4.2.2那什么是向上转型？

向上转型：实际就是创建一个子类对象，将其当成父类对象来使用

语法格式：父类类型对象名 = new 子类类型 ()

animal 是父类类型，但可以引用一个子类对象，因为是从小范围向大范围的转换。

实现多态的代码：

class Shape {

    public void draw() {
        System.out.println("画图形！");
    }
}

class Rect extends Shape {
    @Override
    public void draw() {
        System.out.println("画一个矩形！");//重写父类方法
    }
}
class Cycle extends Shape{
    @Override
    public void draw() {
        System.out.println("画一个圆圈！");
    }
}

class Triangle extends Shape {
    @Override
    public void draw() {
        System.out.println("画一个三角形！");
    }
}

class Flower extends Shape {
    @Override
    public void draw() {
        System.out.println("画一朵花！");
    }
}

public class Test1 {

    public static void drawMaps1() {
        Rect rect = new Rect();//通过父类的引用调用重写的方法-》向上转型
        Shape shapeCycle = new Cycle();//通过父类的引用调用重写的方法-》向上转型
        Triangle triangle = new Triangle();//通过父类的引用调用重写的方法-》向上转型
        Flower flower = new Flower();//通过父类的引用调用重写的方法-》向上转型

        Shape[] shapes = {shapeCycle,rect,rect,
                shapeCycle,triangle,flower};
        for(Shape shape : shapes) {
            shape.draw();//调用同一个方法，不同的对象会有不同的结果
        }
    }
    //测试方法
    public static void main(String[] args) {
        drawMaps1();
    }
}

运行结果（这里调用了同一个方法，但是不同的对象会产生不同的结果）：

小结：

1，多态是方法的多态，不是属性的多态（多态和属性无关）

2，多态的存在要有3个必要的条件：继承 | 接口的实现，方法重写，父类引用指向子类对象。

3，父类引用指向子类对象后，用该父类引用调用子类重写的方法（父类类型引用名 = new 子类类型（）；），此时多态就出现了。

结语： 写博客不仅仅是为了分享学习经历，同时这也有利于我巩固自己的知识点，总结该知识点，由于作者水平有限，对文章有任何问题的还请指出，接受大家的批评，让我改进。同时也希望读者们不吝啬你们的点赞+收藏+关注，你们的鼓励是我创作的最大动力！

原文地址：https://blog.csdn.net/2302_79862386/article/details/136520380

免责声明：本站文章内容转载自网络资源，如本站内容侵犯了原著者的合法权益，可联系本站删除。更多内容请关注自学内容网（zxcms.com）！

上一篇：代码随想录算法训练营第54天| Leetcode 392.判断子序列、Leetcode 115.不同的子序列
下一篇：Java中SpringBoot四大核心组件是什么

【设计模式系列】原型模式（十一）
原型模式（Prototype Pattern）是一种创建型设计模式，它使得一个对象可以复制自身，从而创建一个与自己属性一致的新对象，而无需知晓对象创建的细节。（例如，涉及复杂的初始化过程）。
阅读更多2024-11-05
2024 CSS - 保姆级系列教程三 - 选择器与布局详解
CSS 选择器是 CSS 规则的第一部分。它是元素和其他部分组合起来告诉浏览器哪个 HTML 元素应当是被选为应用规则中的 CSS 属性值的方式。选择器所选择的元素，叫做“选择器的对象”。
阅读更多2024-11-05
河北冠益荣信科技公司洞庭变电站工程低压备自投装置的应用
（1）在正常运行模式下，2QF和5QF闭合，而3QF和4QF断开，此时由#2站用变供电给两段母线，#1站作为紧急备用电源，手动操作，1QF通常断开。（1）正常运行时，#1站用变进线带I段母线，#2站用
阅读更多2024-11-05
Flutter学习笔记（二）------ 第一个flutter项目
dart语法较为简单，学过python和c++后发现大同小异。不过多介绍1.函数可变参数可以类比*args, **kwargs，与之不同的是dart中，*args **kwargs不能同时存在。
阅读更多2024-11-05
大数据导论第八章作业
答：数据通常是枯燥乏味的，利用数据可视化平台，枯燥乏味的数据可转变为丰富生动的视觉效果，不仅有助于简化人们的分析过程，还可在很大程度上提高分析数据的效率。数据可视化技术的基本思想是将数据库中每一个数据
阅读更多2024-11-05
矩阵压缩格式转换：COO转换CSC（C++）
主要对稀疏矩阵COO格式转换CSC格式进行介绍和C++代码实现，方便将矩阵市场的mtx文件内容转换为CSC格式的矩阵
阅读更多2024-11-05
PowerBI 根据条件选择获得不同的表格因为IF和SWITCH只能返回标量而不能返回表格 Power BI
PowerBI 根据条件选择返回不同的表格因为IF和SWITCH只能返回标量而不能返回表格 Power BI自定义日期筛选套件。
阅读更多2024-11-05
【Java SpringIOC与ID随感录】基于 XML 的 Bean 装配
也就是说，对象的创建和依赖关系的维护从程序员的手中转移到 BeanFactory 我们将这个现象称之为控制反转(IOC)，在 BeanFactory 工厂中负责注入每一个依赖关系的这种行为称之为(ID
阅读更多2024-11-05
RabbitMQ最全教程-Part1(基础使用)
消息队列中间件是分布式系统中重要的组件，主要解决应用解耦，异步消息，流量削锋等问题，实现高性能，高可用，可伸缩和最终一致性架构。
阅读更多2024-11-05
Topaz Video AI for Mac 视频无损放大软件安装教程【保姆级，操作简单轻松上手】
Topaz Video AI for Mac 视频无损放大软件安装教程【保姆级，操作简单轻松上手】
阅读更多2024-11-05

javaSE-----继承和多态

一.初识继承：

1.1什么是继承，为什么需要继承：

1.2继承的概念与语法：

二.成员的访问：

2.1super关键字

2.2this和super的区别：

三.再谈初始化:

小结：

四.初识多态：

4.1多态的概念：

4.2多态的实现条件：

相关文章