Java多态详解(2)

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

向上转型和向下转型

向上转型

定义:实际就是创建一个子类对象,将其当作父类对象来使用

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

Animal animal = new Cat("元宝", 2);

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

特点:

  1. 编译时多态性: 父类引用变量可以引用子类对象,编译器会在编译时检查引用变量的类型是否与对象的类型兼容。

  2. 运行时多态性: 在运行时,根据引用变量所指向的实际对象类型来调用对应的方法,实现方法的多态性。

  3. 限制方法访问: 向上转型后,只能调用父类中声明的方法,而不能直接调用子类新增的方法。

使用场景:1.直接赋值 2.方法传参 3.方法返回

举例一:直接赋值:

class Animal {
    void makeSound() {
        System.out.println("Animal makes a sound");
    }
}

class Dog extends Animal {
    void makeSound() {
        System.out.println("Dog barks");
    }
}

public class Main {
    public static void main(String[] args) {
        Animal animal = new Dog(); // 直接赋值
        animal.makeSound(); // 调用的是 Dog 类的方法
    }
}

举例二:方法传参

class Shape {
    void draw() {
        System.out.println("draw a shape");
    }
}

class Circle extends Shape {
    @Override
    void draw() {
        System.out.println("draw a circle");
    }
}

class Triangle extends Shape {
    @Override
    void draw() {
        System.out.println("draw a triangle");
    }
}
public class Test {
    public static void shapeDrawing(Shape s) {
        s.draw();
    }

    public static void main(String[] args) {
        Shape s1 = new Circle();
        Shape s2 = new Triangle();

        shapeDrawing(s1);
        shapeDrawing(s2);//方法传参,传递不同子类对象
    }
}

举例三:做返回值

class Vehicle {
    String getType() {
        return "Vehicle";
    }
}

class Car extends Vehicle {
    @Override
    String getType() {
        return "Car";
    }
}

class Bike extends Vehicle {
    @Override
    String getType() {
        return "Bike";
    }
}

public class Test {
    public static Vehicle getType(String type){
        if(type.equals("car")){
            return new Car();
        } else if(type.equals("bike")) {
            return new Bike();
        } else {
            return new Vehicle();
        }
    }

    public static void main(String[] args) {
        Vehicle v1 = getType("car");
        Vehicle v2 = getType("bike");
        Vehicle v3 = getType("plane");

        System.out.println(v1.getType());
        System.out.println(v2.getType());//方法返回,返回的实际上可能是子类对象
        System.out.println(v3.getType());
    }
}

向上转型的优点:让代码实现更加简单灵活

向上转型的缺点:不能调用到子类特有的方法

向下转型

将一个子类对象经过向上转型之后当作父类方法使用,在无法调用子类的方法,但有时候可能需要调用子类特有的方法,此时:将父类引用还原为子类对象即可,即向下转换。

class Animal1 {
    void makeSound() {
        System.out.println("Animal makes a sound");
    }
}

class Dog1 extends Animal1 {
    @Override
    void makeSound() {
        System.out.println("Dog barks");
    }

    void fetch() {
        System.out.println("Dog fetch the ball");
    }
}

public class Test1 {
    public static void main(String[] args) {
        Animal1 animal1 = new Dog1();//向上转型

        //向下转型
        if(animal1 instanceof Dog1) {
            Dog1 dog = (Dog1)animal1;//实例类型检查和向下转型
            dog.makeSound();//调用子类的方法
            dog.fetch();//调用子类特有的方法
        }
    }
}

向下转型用的比较少,而且不安全,万一转换失败,运行时就会抛出异常。Java中为了提高向下转型的安全性,引入了instanceof(用于检查一个对象是否是指定类或其子类的实例),如果表达式的结果为true,则可以安全转换。

多态的优缺点

优点

假设有如下代码:

class Shape {
    //属性。。。
    public void draw() {
        System.out.println("画图形");
    }
}

class Rect extends Shape {
    @Override
    public void draw() {
        System.out.println("⎕");
    }
}

class Circle extends Shape {
    @Override
    public void draw() {
        System.out.println("◉");
    }
}

class Star extends Shape {
    @Override
    public void draw() {
        System.out.println("★");
    }
}

1.能够降低代码的“圈复杂度”,避免使用大量的if-else

圈复杂度:一种描述一段代码复杂程度的方式。一段代码如果平铺直叙,那么就比较简单容易理解,而如果有很多条件分支或者循环语句,就认为了解起来比较复杂。

因此我们可以简单粗暴的计算一段代码中条件语句和循环语句出现的个数,这个个数就称为“圈复杂度”,如果一个方法的圈复杂度太高,就需要考虑重构

不同公司对于圈复杂度的规范不一样,但一般不会超过10

例如我们现在需要的不只是打印一个形状了,而是多个形状,如果不基于多态,实现代码如下:

public static void drawShapes() {
    Rect rect = new Rect();
    Circle circle = new Circle();
    Star star = new Star();
    String[] shapes = {"circle", "rect", "circle", "rect", "star"};
    for(String shape : shapes) {
        if(shape.equals("circle")){
            circle.draw();
        } else if(shape.equals("rect")) {
            rect.draw();
        } else if(shape.equals("star")) {
            star.draw()
        }
    }

}

如果使用多态,则不必写这么多的if-else分支语句,代码更简单。

Shape[] shapes = {new Circle(), new Rect(), new Circle(), new Rect(), new Star()};
for(Shape shape : shapes) {
    shape.draw();
}

2.可扩展能力更强

如果要新增一种形状,使用多态的方式代码改动成本也比较低。

class Triangle extends Shape {
    @Override 
    public void draw() {
        System.out.println("▲");
    }
}

对于类的调用者(主函数),只要创建一个新类的实例就可以了,改动成本很低。

而对于不用多态的情况,就要把drawShapes中的if-else进行一定修改,改动成本更高

缺点

代码运行效率降低

1.属性没有多态性:当父类和子类都有同名属性的时候,通过父类引用,只能引用父类自己的成员属性

2.构造方法没有多态性

 文章来源地址https://www.toymoban.com/news/detail-661935.html

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

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

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

相关文章

  • 年度语言之--c#与java的多态

    引言 多态是面向对象编程中的一个核心概念,它赋予语言更强大的表达力和灵活性。 Java和C#作为广泛使用的两中面向对象编程语言,多态这一特性都起到重要的作用,但它们实现这一概念的方式存在着一些差异。 本文将讨论Java与C#在实现多态方面的不同。 我们将分析这两种

    2024年02月22日
    浏览(40)
  • Java SE 继承和多态 (图文搭配,万字详解!!)

    目录 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.8 再谈初始化 1.9 protected 1.10 继承方式  1.11 final 1.12 继承与组合 2

    2024年02月05日
    浏览(47)
  • 编程开发8大语言详解,为什么Java是我最推荐的?

    很多没有接触过编程语言的同学,都会觉得编程开发特别高端和神奇,担心理解不了更担心学不会。 当然,也有人会认为,你既然是做编程的,那么你应该什么都会,什么软件的开发都能完成,这是平哥经常听到的两种声音。 在此,平哥需要给大家科普一下, 编程确实改变

    2024年02月05日
    浏览(70)
  • c、c++、java、python、js对比【面向对象、过程;解释、编译语言;封装、继承、多态】

    目录 内存管理、适用 区别 C 手动内存管理:C语言没有内置的安全检查机制,容易出现内存泄漏、缓冲区溢出等安全问题。 适用于系统级编程 C++ 手动内存管理:C++需要程序员手动管理内存,包括分配和释放内存,这可能导致内存泄漏和指针错误。 适用于游戏引擎和系统级编

    2024年02月08日
    浏览(73)
  • 【Java基础教程】(十四)面向对象篇 · 第八讲:多态性详解——向上及向下转型、关键字 final与 instanceof的作用~

    掌握final 的主要作用及使用; 掌握对象多态性的概念以及对象转型的操作; 掌握instanceof 的主要作用及使用; 在Java 中 final称为终结器,在Java 里面可以使用 final定义类、方法和属性,用于表示不可变性 。 final 类:当一个类被声明为 final 时,意味着该类不能被

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

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

    2024年02月04日
    浏览(42)
  • 【Java】Java中的多态

    在Java中,多态是面向对象编程中的一个重要概念,它 允许不同类型的对象对同一方法进行不同的实现 。具体来说, 多态性指的是通过父类的引用变量来引用子类的对象,从而实现对不同对象的统一操作 。 例如:狗和猫都是动物,动物共同的行为都有吃这个动作,而狗可以

    2024年02月10日
    浏览(40)
  • Java多态与重写

    Java继承与组合 你知道为什么会划分数据类型吗?—JAVA数据类型与变量 10 > 20 10 / 0 == 0等于串联小灯泡?—JAVA运算符 你真的知道怎样用java敲出Hello World吗?—初识JAVA 现实生活中,但我们完成某一个同样的行为,当不同的对象去完成时会产生出不同的状态.比如说吃食物,当猫去完

    2023年04月15日
    浏览(45)
  • Java面向对象多态

    目录 多态概述 Java 多态包括以下三种方式 方法重写(Override) 向上转型(Upcasting) 实现多态 Java 多态是指同一种类型的对象,在不同的情况下有着不同的状态和行为。它是基于继承、重写和向上转型等特性实现的,多态是面向对象编程的三大特征之一,其他两个分别是封装

    2023年04月13日
    浏览(47)
  • java特征:多态性

    对象的多态性 多态性,是面向对象中最重要的概念,在Java中的体现: 对象的多态性:父类的引用指向子类的对象 格式:(父类类型:指子类继承的父类类型,或者实现的接口类型) 举例: 对象的多态:在Java中,子类的对象可以替代父类的对象使用。所以,一个引用类型变

    2024年02月12日
    浏览(32)

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

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

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

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

二维码1

领取红包

二维码2

领红包