Java继承和多态

最新推荐文章于 2023-08-13 19:53:36 发布
最新推荐文章于 2023-08-13 19:53:36 发布
阅读量225 收藏
点赞数 1
分类专栏： JavaSE初学 文章标签： java jvm 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_62905847/article/details/126470827
版权

文章目录

一、继承

在我们日常写代码时，不难发现在定义的类中常常会有很多重复变量，因此提出了继承的概念，专门用来进行共性抽取，实现代码复用。

继承的概念:
它允许程序员在保持原有类特性的基础上进行扩展，增加新功能，这样产生新的类，称派生类。
继承主要解决的问题是：共性的抽取，实现代码复用。

1.继承的语法

在Java中如果要表示类之间的继承关系，需要借助extends关键字，具体如下：

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

以猫，狗为例:

class Animal{
    String name = "阿黄";
    int age = 3;

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

    public void sleep() {
        System.out.println(name + "正在睡觉");
    }
}
 class Dog extends Animal {
    void bark(){
        System.out.println(name+"，汪汪叫");
    }
}

public class test{

    public static void main(String[] args) {
        Dog dog = new Dog();

        System.out.println(dog.name);
        System.out.println(dog.age);

        dog.bark();
    }

}

在这里插入图片描述

2.父类成员访问

(1)子类与父类不存在相同成员名

class DogFather{
    String name = "大黄";
    int age1 = 3;
}
 class Dog extends DogFather {
    int age2 ;
    public void New(){
        name = "小黄";    //访问从父类中继承下来的名字并更改
        age2 = 1;    //访问子类自己的年龄
        System.out.println(name + "今年" + age2 + "岁");
    }
    void bark(){
        System.out.println(name+"，汪汪叫");
    }
}

public class test{
    public static void main(String[] args) {
        Dog dog = new Dog();
        dog.New();
        dog.bark();
    }

}

在这里插入图片描述

2.子类与父类有相同成员名

class DogFather{
    String name = "大黄";
    int age = 3;
    int heavy = 60;
}
 class Dog extends DogFather {
     int age ;		//与父类名称相同类型相同
     String name;
     double heavy = 30.0;		//名称相同但类型不同
    public void New(){
        age = 1;
        name = "小黄";
        System.out.println(name + "今年" + age + "岁" + heavy + "kg");
    }
    void bark(){
        System.out.println(name+"，汪汪叫");
    }
}

public class test{
    public static void main(String[] args) {
        Dog dog = new Dog();
        dog.New();
        dog.bark();
    }

}

在这里插入图片描述
注:
如果访问的成员变量子类中有，优先访问自己的成员变量。

如果访问的成员变量子类中无，则访问父类继承下来的，如果父类也没有定义，则编译报错。

如果访问的成员变量与父类中成员变量同名，则优先访问自己的。

成员变量访问遵循就近原则，自己有优先自己的，如果没有则向父类中找。

3.子类访问父类成员方法

1.成员方法名称不同

class First{
    public void A(){
        System.out.println("方法A");
    }
}
class Second extends First{
    public void B(){
        System.out.println("方法B");
    }
     public void print(){
        A();    //访问父类A
        B();    //访问子类B
    }
}
public class test{
    public static void main(String[] args) {
        Second second = new Second();
        second.print();
    }
}

在这里插入图片描述
2.成员方法名称相同

class First{
    public void A(){
        System.out.println("父类：方法A");
    }
    public void B(){
        System.out.println("父类：方法B");
    }
}
class Second extends First{
    public void B(){
        System.out.println("子类：方法B");
    }
    public void A(int a){
        System.out.println("带int参数的方法A");
    }
     public void print(){
        A();    //访问父类A
        A(2);   //访问子类中带有int参数的方法
        B();    //优先访问子类B，最基类的无法访问
    }
}
public class test{
    public static void main(String[] args) {
        Second second = new Second();
        second.print();
    }
}

在这里插入图片描述
注：
通过子类对象访问父类与子类中不同名方法时，优先在子类中找，找到则访问，否则在父类中找，找到则访问，否则编译报错。
通过派生类对象访问父类与子类同名方法时，如果父类和子类同名方法的参数列表不同(重载)，根据调用方法适传递的参数选择合适的方法访问，如果没有则报错；

4.super关键字

在设计程序时我们常常会遇到父类和子类有相同成员名的情况，因此，我们需要一种方法来在子类中修改父类成员变量。

在Java中提供了super关键字，主要方法：在子类方法中访问父类成员。
代码如下：

class Father{
    int a;
    int b;

    public void A(){
        System.out.println("父类中的方法A");
    }
}

class Son extends Father{
    int a;
    int b;
    public void A(){
        System.out.println("子类中的方法A");
    }

    public void print(){
        a = 100;
        b = 101;
        System.out.println("子类的 a:"+a+" 子类的 b:"+b);
        //子类中变量a，b。
        super.a = 200;
        super.b = 201;
        System.out.println("父类的 a:"+super.a+" 父类 b:"+super.b);
        //父类中的变量a，b
        A();
        super.A();
    }
}
public class test{
    public static void main(String[] args) {
        Son son = new Son();
        son.print();
    }
}

在这里插入图片描述
注：

  1. 只能在非静态方法中使用
  2. 在子类方法中，访问父类的成员变量和方法。

super和this的区别

相同点：

  1. 都是Java中的关键字
  2. 只能在类的非静态方法中使用，用来访问非静态成员方法和字段
  3. 在构造方法中调用时，必须是构造方法中的第一条语句，并且不能同时存在。

不同点：

  1. this是当前对象的引用，当前对象即调用实例方法的对象，super相当于是子类对象中从父类继承下来部分成员的引用。
  2. 在非静态成员方法中，this用来访问本类的方法和属性，super用来访问父类继承下来的方法和属性
  3. 在构造方法中：this(…)用于调用本类构造方法，super(…)用于调用父类构造方法，两种调用不能同时在构造方法中出现
  4. 构造方法中一定会存在super(…)的调用，用户没有写编译器也会增加，但是this(…)用户不写则没有。

5.对静态，实例，构造方法代码块的执行顺序探究

1.无继承关系的顺序
代码如下：

class Find{
    int a;
    public void A(int a){
        this.a = a;
        System.out.println("构造方法");
    }
    {
        System.out.println("实例代码");
    }
    static{
        System.out.println("静态代码");
    }
}
public class test {
    public static void main(String[] args) {
        Find find1 = new Find();
        find1.A(10);
        System.out.println("__________________");
        Find find2 = new Find();
        find2.A(20);
    }
}

在这里插入图片描述
总结：

  1. 静态代码块先执行，并且只执行一次，在类加载阶段执行
  2. 当有对象创建时，才会执行实例代码块，实例代码块执行完成后，造方法执行

2.在继承关系上的顺序
代码如下：

class Father {
    int a;
    public  Father(int a) {
        this.a = a;
        System.out.println("构造方法");
    }
    {
        System.out.println("实例代码");
    }
    static {
        System.out.println("静态代码");
    }
}
    class Son extends Father {
        public int b;
        public Son(int b) {
            super(b);
            System.out.println("构造代码");
        }
        {
            System.out.println("实例代码");
        }
        static {
            System.out.println("静态代码");
        }
    }
public class test {
    public static void main(String[] args) {
        Son son = new Son(10);
        System.out.println("_____________");
        Son son1 = new Son(20);
    }
}

在这里插入图片描述
总结：
1、父类静态代码块优先于子类静态代码块执行，且是最早执行
2、父类实例代码块和父类构造方法紧接着执行
3、子类的实例代码块和子类构造方法紧接着再执行
4、第二次实例化子类对象时，父类和子类的静态代码块都将不会再执行

二、多态

多态的概念：完成某个行为，当不同的对象去完成时会产生出不同 的状
态。

1.多态的实现条件

  1. 必须在继承体系下
  2. 子类必须要对父类中方法进行重写
  3. 通过父类的引用调用重写的方法

在代码运行时，当传递不同类对象时，会调用对应类中的方法。

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+"正在吃饭");
    }
}
class Cat extends Animal{
    public Cat(String name,int age){
        super(name,age);
    }
    public void eat(){
        System.out.println(name+ "在吃鱼");
    }
}
class Dog extends Animal{
    public Dog(String name,int age){
        super(name,age);
    }
    public void eat(){
        System.out.println(name+"吃骨头");
    }
}
public class test {
// 编译器在编译代码时，并不知道要调用Dog 还是 Cat 中eat的方法 
// 等程序运行起来后，形参a引用的具体对象确定后，才知道调用那个方法 
// 注意：此处的形参类型必须时父类类型才可以
    public static void eat(Animal a){
        a.eat();
    }
    public static void main(String[] args) {
        Dog dog = new Dog("大黄",3);
        Cat cat = new Cat("小咪",3);

        eat(cat);
        eat(dog);
    }
}

在这里插入图片描述

2.重写

重写(override)：也称为覆盖。重写是子类对父类非静态、非private修饰，非final修饰，非构造方法等的实现过程进行重新编写，返回值和形参都不能改变。即外壳不变，核心重写！

重写的规则：
1.子类在重写父类的方法时，一般必须与父类方法原型一致： 返回值类型 方法名 (参数列表) 要完全一致。

2.访问权限不能比父类中被重写的方法的访问权限更低。

3.父类被static、private修饰的方法、构造方法都不能被重写。

重写的设计原则：
对于已经投入使用的类，尽量不要进行修改。最好的方式是：重新定义一个新的类，来重复利用其中共性的内容，并且添加或者改动新的内容。

3.向上转型

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

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

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+"正在吃饭");
    }
}
class Cat extends Animal{
    public Cat(String name,int age){
        super(name,age);
    }
    public void eat(){
        System.out.println(name+ "在吃鱼");
    }
}
class Dog extends Animal{
    public Dog(String name,int age){
        super(name,age);
    }
    public void eat(){
        System.out.println(name+"吃骨头");
    }
}
public class test {
    // 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);
        eatFood(cat);
        eatFood(dog);
        Animal animal = buyAnimal("狗");
        animal.eat();
        animal = buyAnimal("猫");
        animal.eat();
    }
}

在这里插入图片描述

如有不足，欢迎指正！

Mo_yang.
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java系列——封装、继承、多态初了解
wct040923的博客
05-06 8559
封装（Encapsulation）是面向对象方法的重要原则，就是把对象的属性和操作（或服务）结合为一个独立的整体，并尽可能隐藏对象的内部实现细节。将类的某些信息隐藏在类的内部，不允许外部程序进行直接的访问调用。通过该类提供的方法来实现对隐藏信息的操作和访问。隐藏对象的信息。留出访问的对外接口。​ 举个比较通俗的例子，比如我们的USB接口。如果我们需要外设且只需要将设备接入USB接口中，而内部是如何工作的，对于使用者来说并不重要。而USB接口就是对外提供的访问接口。
Java中的继承和多态
最新发布
m0_63562631的博客
11-02 159
1.在类的加载阶段,执行静态代码块,并且只执行一次,且静态代码块是最先执行的.2.在实例化对象的过程中,才会执行实例代码块,执行完成后,才会执行构造方法.
继承和多态(Java)
2301_76815082的博客
08-13 114
Java中使用类对现实世界中实体来进行描述，类经过实例化之后的产物对象，则可以用来表示现实中的实体，但是现实世界错综复杂，事物之间可能会存在一些关联，那在设计程序是就需要考虑。比如：狗和猫，它们都是一个动物。通过观察上述代码会发现，猫和狗的类中存在大量重复，如下所示：那能否将这些共性抽取呢？
Java—继承与多态
weixin_48112109的博客
05-27 4954
目录 1、继承 1.1、继承的定义 1.2、继承的使用场景 1.3、构造器 1.4、protected关键字 1.5、谨慎继承 2、多态 2.1、多态的定义 2.2、多态的实现方式 2.2.1、基于继承实现的多态 2.2.2、基于接口实现的多态 1、继承 1.1、继承的定义 继承是使用已存在的类的定义作为基础建立新类的技术，新类的定义可以增加新的数据或新的功能，也可以用父类的功能，但不能选择性地继承父类。通过使用继承我们能够非常方便地复用以前的代码，能够大...
【Java】继承和多态
这个人很勤快，但还是什么也没有。
05-06 563
重载就是将同一个函数名的函数，根据参数列表的不同（顺序、个数、类型），实现为不同的函数，那么这两个同名函数就构成重载。不要在构造函数中使用多态，因为会造成父类的构造违法被调用，此时使用final或者private进行修饰即可。this可访问的成员是当前整个对象的，但是super更专精些，只能访问到当前对象继承父类的那一部分成员。同c++，继承的思想一脉相承，是为了给现实世界中有is-a关系的事物之间实现代码复用的一种思想。多态是一种事物的多种状态，是一种事物在不同对象上表示出的不同状态的现象。
java学习资料-Java继承和多态
06-14
java学习资料—Java继承和多态；java学习资料—Java继承和多态；java学习资料—Java继承和多态；java学习资料—Java继承和多态；java学习资料—Java继承和多态；java学习资料—Java继承和多态；java学习资料—Java...
java继承和多态PPT教案学习.pptx
09-30
java继承和多态PPT教案学习.pptx
Educoder题目：Java面向对象 - 封装、继承和多态答案解析.md
11-08
Educoder题目：Java面向对象 - 封装、继承和多态答案解析
Educoder题目：Java面向对象 - 封装、继承和多态的综合练习答案解析.md
11-09
Educoder题目：Java面向对象 - 封装、继承和多态的综合练习答案解析
JAVA---继承与多态（基础详解与样例分析）
m0_52317537的博客
11-26 3635
在JAVA学习有了一定基础和了解上将会继续深入学习多态，面向对象程序设计的三大支柱是封装、继承和多态，学习的步骤是循环渐进的，在学习了封装和继承的基础知识后进而了解多态。 什么是多态？多态意味着父类型的变量可以引用子类型的对象，注意这句话中的几个关键点，是父类型的变量，去引用子类型的对象。接下来的学习中就是去解释和运用这句话。 目录 HINT 1 继承 HINT 2 多态 HINT 1 继承 在引入多态之前，我们先再回顾一下继承的部分基础知识，我...
Java 中的继承和多态
z_ssyy的博客
12-30 704
我们用白切鸡类来举个栗子。
继承 super的讲解
xiaochen_从入门到实战
10-22 926
继承 super注意点 super调用父类的构造方法，必须在构造方法的第一个 super必须只能出现在子类的方法或者构造方法中 super和this 不能同时调用构造方法 对比this ​ 代表的对象不同 ​ this: 本身调用 用这个对象 ​ super: 代表父类对象的应用 ​ 前提 ​ this: 没有继承也可以使用 ​ super: 只能在继承条件才可以使用 ​ 构造方法 ​ this() 本类的构造 ​ super(); 父类的构造 pa
十三、java类的封装、继承、多态
liujun13579的专栏
07-07 6734
面向对象的三个基本特性就是：封装、继承和多态。 前面讲解了java 程序都是由类文件组成的，java是面向对象的程序设计语言，在java中面向对象的思想就是由类的设计来体现的，也即类的继承、封装和多态。   一、封装(encapsulation) 封装性就是把类（对象）的属性和行为结合成一个独立的相同单位，并尽可能隐蔽类（对象）的内部细节，对外形成一个边界，只保留有限的对外接口使之与外部
super关键字与this关键字区别
码农研究僧的博客
04-24 1570
super/this关键字比较定义区别使用方法superthis 定义 super关键字通过子类访问父类，有三种用法： 通过子类的方法，访问父类的成员变量，成员函数，构造函数。 this 关键字用来访问本类内容，用法也有三种： 在本类的成员方法中，访问本类的成员变量、成员函数、构造函数。 区别 this指向的是当前对象的调用，super指向的是当前调用对象的父类 使用方法 第一行默认为构造函数 构造函数间的调用只能放在第一行，只能调用一次 super()和this()不能同时存在构造函数第一行 super
java继承和多态的练习及自我感悟
qq_42070071的博客
06-18 5343
一、实验目的：1. 理解 Java 语言是如何体现面向对象编程基本思想的；2. 掌握类的声明以及对象的创建；3. 了解类的成员变量和成员方法的特性以及类的构造方法的使用。 二、实验环境：（1）配备计算机一台 （2）计算机需安装好JDK 和eclipse  三、实验内容：（一）使用修饰符出错，public int getY() 和int y都需要定义static类型，static就是静态的意思，对象...
this和super用法
yuqu1028的博客
07-21 1927
如果一个类中声明了n个构造器，则最多有n-1个构造器中使用了"this(【实参列表】)"，否则会发生递归调用死循环。注意super和this都不能出现在静态方法和静态代码块中，因为super和this都是存在与。super()和this()都必须是在构造方法的第一行，所以不能同时出现。在子类中访问父类的成员变量，特别是当子类的成员变量与父类的成员变量重名时。在子类中调用父类的成员方法，特别是当子类重写了父类的成员方法时。（3）this()或this(实参列表)（2）this.成员方法。...
super和this的区别
焕听的专栏
11-10 3018
参考博客：https://www.cnblogs.com/hasse/p/5023392.html                  http://blog.csdn.net/zuoyang1990/article/details/53471494thisthis是自身的一个对象，代表对象本身，可以理解为：指向对象本身的一个指针。this的用法在java中大体可以分为3种： 1、普通的直接引用
JAVA基础--java简单知识04（类与对象，封装，继承，多态）
菜鸟三四五的博客
04-25 885
类与对象 在学习Java中，最重要的就是面对对象，面对对象三大特性：封装，继承，多态 什么是面对对象？ 面对对象，就是你在进行开发时，把所有能够认知到的事物看做对象，去描述它的行为和特征。 什么是类和对象？ 类 类是确定对象将会拥有的特征（属性）和行为（方法），类在客观中是不存在的，它只是用来描述对象的一些信息。 类的特点： 类是对象的类型 具有相同方法和属性的一组对象的集合 对象 对象就是能够描...
头歌java继承和多态
08-23
- *1* [java学习资料-Java继承和多态](https://download.csdn.net/download/weixin_43516258/87905486)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值