JavaSE:继承和多态(下篇)

这篇具有很好参考价值的文章主要介绍了JavaSE:继承和多态(下篇)。希望对大家有所帮助。如果存在错误或未考虑完全的地方,请大家不吝赐教,您也可以点击"举报违法"按钮提交疑问。

目录

一、前言

二、多态

(一)多态的概念

(二)多态实现条件

(三)多态的优缺点

三、重写

(一)重写的概念

(二)重写的规则

 (三)重写和重载的区别

四、向上转型和向下转型

(一)向上转型

(二)向下转型 

 五、总结


一、前言

大家好,前几天蜡笔小欣带大家了解并学习了Java中的继承,子类通过extends关键字来继承父类。通过继承,子类可以重写父类的方法,从而实现多态性。今天我们就一起去认识Java中的多态,了解多态的概念,掌握多态的用法,使我们在写程序时更加方便。

二、多态

(一)多态的概念

多态 通俗来说,就是多种形态, 具体点就是去完成某个行为,当不同的对象去完成时会产生出不同 的状 态。
举个栗子:打印机的功能是打印文件,那么打印机又分为 彩色打印机黑白打印机
JavaSE:继承和多态(下篇),java,学习

简单来说就是同一件事情,发生在不同对象身上,会产生不同的结果 。

(二)多态实现条件

多态实现的条件:

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

JavaSE:继承和多态(下篇),java,学习

下面举个例子让大家更好地理解:

我们先定义一个父类Animal,这个类里面有两个成员变量,一个方法。

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(name + "正在吃东西");
    }
}

 接着我们定义两个子类,分别是Dog和Cat,都继承父类Animal,在这两个类中重写eat()方法。

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

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

    public void bark() {
        System.out.println(name + "汪汪汪");
    }
}

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

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

    public void mew() {
        System.out.println(name + "喵喵喵");
    }
}

然后我们在Test里面定义一个静态方法func(),父类Animal作为参数引用,再调用eat()方法。

public class Test {
    public static void eat(Animal animal) {
        animal.eat();
    }
}

最后实例化对象,进行初始化赋值。

public static void main(String[] args) {
        Dog dog = new Dog("小白", 3);
        Cat cat = new Cat("汤姆", 5);
        eat(dog);
        eat(cat);
}
当类的调用者在编写 eat 这个方法的时候 , 参数类型为 Animal ( 父类 ), 此时在该方法内部并 不知道 , 也不关注 当前的animal引用指向的是哪个类型( 哪个子类 ) 的实例。 此时animal 这个引用调用 eat 方法可能会有多种不同的表现 ( 和animal 引用的实例 相关), 这种行为就称为 多态。

(三)多态的优缺点

多态的优点:
1. 能够降低代码的 " 圈复杂度 ", 避免使用大量的 if - else,
2. 可扩展能力更强。
多态缺陷:代码的运行效率降低

三、重写

(一)重写的概念

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

(二)重写的规则

1. 子类在重写父类的方法时,一般必须与父类方法原型一致 : 返回值类型方法名 ( 参数列表 ) 要完全一致。
JavaSE:继承和多态(下篇),java,学习

2.被重写的方法返回值类型可以不同,但是必须是具有父子关系的。我们可以理解为将eat()方法定义为父子关系。

JavaSE:继承和多态(下篇),java,学习

3.访问权限不能比父类中被重写的方法的访问权限更低。例如:如果父类方法被public修饰,则子类中重写该方法就不能声明为protected。

JavaSE:继承和多态(下篇),java,学习

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

JavaSE:继承和多态(下篇),java,学习

 5.重写的方法,可以使用 @Override 注解来显式指定。 有了这个注解能帮我们进行一些合法性校验。 例如不小心将方法名字拼写错了 (比如写成 aet),那么此时编译器就会发现父类中没有 aet 方法就会编译报错,提示无法构成重写。

 操作步骤:1.点击鼠标右键,点击generate。

JavaSE:继承和多态(下篇),java,学习

2.选择红色箭头所指向的部分。

JavaSE:继承和多态(下篇),java,学习

3.点击我们要重写的方法。 

JavaSE:继承和多态(下篇),java,学习

 4.最后就可以对父类的方法进行重写,如果我们不小心把重写的方法名写错了,@Override就可以帮我们检测出来,使我们在重写方法时更加方便。

JavaSE:继承和多态(下篇),java,学习 

 (三)重写和重载的区别

JavaSE:继承和多态(下篇),java,学习方法重载一个类的多态性表现,方法重写子类与父类的一种多态性表现。

四、向上转型和向下转型

(一)向上转型

向上转型:实际就是创建一个子类对象,将其当成父类对象来使用。
语法格式:父类类型 对象名 = new 子类类型()
Animal animal = new Cat ( " 汤姆 " , 5 );

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

下面我们举个例子看看:

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(name + "正在吃东西");
    }
}

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

    @Override
    public void eat() {
        System.out.println(name +"正在吃狗粮");
    }

    public void bark() {
        System.out.println(name + "汪汪汪");
    }
}

public class Test {
    public static void eat(Animal animal) {
        animal.eat();
    }

    public static void main(String[] args) {
        Dog dog = new Dog("小白", 3);
        Animal animal =dog;//animal这个引用指向了Dog对象
        animal.eat();
    }
}

运行结果如下:

 JavaSE:继承和多态(下篇),java,学习

当我们把Dog类中eat()方法注释后,运行结果为:

JavaSE:继承和多态(下篇),java,学习

我们会发现它执行了父类Animal中的eat()方法。那如果这时候我们在Dog类中加入一个color成员变量。

JavaSE:继承和多态(下篇),java,学习

然后我们用对象animal去调用它试试看能否运行。

JavaSE:继承和多态(下篇),java,学习

 我们发现结果报错,这是因为color这个属性是Dog类中的,而animal无法访问到。

Tips:
向上转型的优点:让代码实现更简单灵活。
向上转型的缺陷:不能调用到子类特有的方法。

(二)向下转型 

将一个子类对象经过向上转型之后当成父类方法使用,再无法调用子类的方法,但有时候可能需要调用子类特有的方法,此时:将父类引用再还原为子类对象即可,即向下转型。
JavaSE:继承和多态(下篇),java,学习

 

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(name + "正在吃东西");
    }
}

class Dog extends Animal {
    public String color;

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

    /*@Override
    public void eat() {
        System.out.println(name +"正在吃狗粮");
    }*/

    public void bark() {
        System.out.println(name + "汪汪汪");
    }
}

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

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

    public void mew() {
        System.out.println(name + "喵喵喵");
    }
}

public class Test {
    public static void eat(Animal animal) {
        animal.eat();
    }

    public static void main(String[] args) {
        Dog dog = new Dog("小白", 3);
        Animal animal = dog;//animal这个引用指向了Dog对象
        Cat cat = new Cat("汤姆", 5);
        cat = (Cat) animal;
        cat.mew();
    }
}

Animal向下转型为Cat,Cat本来就是猫,转换为猫,安全;Animal向下转型为Dog,Cat本来是猫,转换为狗,则不安全。 

运行结果:

JavaSE:继承和多态(下篇),java,学习 因为animal实际指向的是狗,但现在要强制还原为猫,无法正常还原,所以运行时抛出类型转换异常。

解决方法:

Java 中为了提高向下转型的安全性,引入了 instanceof ,如果该表达式为 true ,则可以安全转换。
public class Test {
    public static void eat(Animal animal) {
        animal.eat();
    }

    public static void main(String[] args) {
        Dog dog = new Dog("小白", 3);
        Animal animal = dog;//animal这个引用指向了Dog对象
        Cat cat = new Cat("汤姆", 5);
        if (animal instanceof Cat) {
            cat = (Cat) animal;
            cat.mew();
        }
        if (animal instanceof Dog) {
            dog = (Dog) animal;
            dog.bark();
        }
    }
}

 运行结果:

JavaSE:继承和多态(下篇),java,学习

 五、总结

多态是面向对象的一个关键概念,它允许对象以不同的方式表现,具体取决于它们的类型。在 Java中,多态通过继承和方法重写来实现,让我们能够编写灵活、可扩展且可维护的代码。我们这期多态的内容就分享到这里,希望能够对大家有所帮助,感谢各位对蜡笔小欣的鼓励支持,我们下次再见!!!文章来源地址https://www.toymoban.com/news/detail-847715.html

到了这里,关于JavaSE:继承和多态(下篇)的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处: 如若内容造成侵权/违法违规/事实不符,请点击违法举报进行投诉反馈,一经查实,立即删除!

领支付宝红包 赞助服务器费用

相关文章

  • JavaSE【继承和多态】(1)(重点:初始化、pretected封装、组合)

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

    2024年02月14日
    浏览(36)
  • 01 java 学习 数据类型、基础语法、封装、继承、多态、接口、泛型、异常等

    目录 环境搭建和基础知识  什么是JRE: 什么是JDK: 基础数据类型  分支选择if else switch和c一毛一样 for和while循环还有数组基本和c一样 封装 函数调用、传参、命名规范、数组新命名规范 java输入Scanner scanner = new Scanner(System.in); 类的创建和使用以及封装修饰符  构造方法:含义、

    2024年02月11日
    浏览(41)
  • 【Java0基础学Java第八颗】 -- 继承与多态 -- 多态

    通俗来说就是多种形态, 具体点就是去完成某个行为,当不同的对象去完成时会产生出不同的状态 。 就比如打印机,彩色打印机和黑白打印机,打印出的效果一个是彩色,一个是黑白。 即: 同一件事情,发生在不同对象身上,就会产生不同的结果 。 在Java中要实现多态,

    2024年02月04日
    浏览(42)
  • (java)继承和多态 (详解)

    目录 1 继承 1.1为什么需要继承 1.2 继承概念 1.3 继承的语法 1.4 父类成员访问  1.4.1 子类中访问父类的成员变量 1.4.2 子类中访问父类的成员方法   1.5 super 1.6 子类构造方法 1.7 super和this 1.7.1 this 1.7.2 super和this  1.8 再谈初始化 1.9 继承方式 1.10 继承与组合 2 多态 2.1 多态

    2024年02月03日
    浏览(40)
  • Java之继承和多态

    1.  为什么需要继承 先看下代码 // Dog.java public class Dog { string name ; int age ; float weight ; public void eat (){ System . out . println ( name + \\\" 正在吃饭 \\\" ); } public void sleep (){ System . out . println ( name + \\\" 正在睡觉 \\\" ); } void Bark (){ System . out . println ( name + \\\" 汪汪汪 ~~~\\\" ); } } // Cat.Java public class Ca

    2024年04月23日
    浏览(32)
  • Java 封装 继承 多态(深入理解)

    登神长阶 第二阶 封装 继承 多态 🍀🍀🍀🍀🍀🍀🍀🍀🍀🍀🍀🍀🍀🍀🍀🍀🍀🍀🍀🍀🍀🍀 目录 🍒一.面向对象编程的三大特性 🍍二.封装 🧉1.定义及其作用  🥝2.访问限定符 🫛3.封装扩展 包(package) 🥕3.1.定义及其作用  🥦 3.2.导入包的类 🍔3.3.自定义包 🌯

    2024年03月11日
    浏览(96)
  • Java三大特性:封装、继承、多态

    高内聚,低耦合 高内聚:类内部操作自己完成,不允许外部干涉。 低耦合:仅暴露少量的方法给外部使用。 封装(数据的隐藏) 通常应禁止直接访问一个对象中数据的实际表达,而应该通过操作接口来访问,这称为信息的隐藏。 封装的特点 1.提高程序的安全性,保护数据

    2024年03月21日
    浏览(45)
  • Java面向对象 - 封装、继承和多态

    目录 第1关:什么是封装,如何使用封装 第2关:什么是继承,怎样使用继承 第3关:super的使用 第4关:方法的重写与重载 第5关:抽象类 第6关:final的理解与使用 第7关:接口 第8关:什么是多态,怎么使用多态 Java_Educoder

    2024年02月07日
    浏览(77)
  • Java系列——封装、继承、多态初了解

    目录 一、前言 二、封装 1.什么是封装?   2.封装的特点 3.封装的使用 三、继承 1.什么是继承? 2.继承的特点 3.继承的优点 4.继承的使用  4.1 继承的格式  4.2 继承的演示 4.3 成员变量 4.4 成员方法 4.5 构造方法 五、多态 1.什么是多态? 2.多态的特点 3.多态的使用  4.引用类型

    2024年02月08日
    浏览(40)
  • 【Java初阶(六)上】封装 继承 多态

    ❣博主主页: 33的博客❣ ▶文章专栏分类: Java从入门到精通◀ 🚚我的代码仓库: 33的代码仓库🚚 对于面向对象程序三大特性:封装、继承、多态。这篇文章将会详细讲解到如何实现封装、继承、多态,以及具体的应用。 本章重点 掌握封装的概念,如何实现封装,包的概念,继

    2024年04月09日
    浏览(43)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包,优惠每天领

二维码1

领取红包

二维码2

领红包