JAVASE语法零基础——多态

已于 2022-09-10 14:47:05 修改
阅读量261 收藏 9
点赞数 16
分类专栏： JAVASE 0基础入门 文章标签： java jvm 数据库
于 2022-06-30 12:51:09 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_62160964/article/details/125518891
版权

Java系列文章目录

在这里插入图片描述

Write once,Runanywhere.🔥🔥🔥

💥 💥 💥如果你觉得我的文章有帮助到你，还请【关注➕点赞➕收藏】，得到你们支持就是我最大的动力!!!
💥 💥 💥

⚡版权声明：本文由【马上回来了】原创、在CSDN首发、需要转载请联系博主。
版权声明：本文为CSDN博主「马上回来了」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。

在这里插入图片描述

🚀🚀🚀 新的知识开始喽🚀🚀🚀
在这里插入图片描述

文章目录

1.多态

多态的概念：通俗来说，就是多种形态，具体点就是去完成某个行为，当不同的对象去完成时会产生出不同的状态。
比如让中国人和外国人写作文，在不是特殊的情况下，中国人用中文写，外国人用外文写。

2.实现多态的三个条件

2.1 向上转型

向上转型：父类引用引用子类的对象。
三种向上转型：
1.直接引用型(核心)
直接通过引用实现向上转型

//父类引用 引用了 子类的对象
        Animal animal1 = new Cat("小橘",2);

2.传参数型
通过传递参数实现向上转型

public class Test {
                        // 父类引用
    public static void fun(Animal animal){
        animal.eat();
    }
    public static void main(String[] args) {
           //子类对象
        fun(new Cat("小黑",1));
        fun(new Dog("白虎",1));

    }

3.返回值类型
通过返回值构成父子类的关系实现向上转型

 //      返回值类型 父类
    public static Animal funcc(){
        // 返回子类对象
        return new Cat("122",1);
    }

完成向上转型后，父类的引用引用了子类的对象，无法在访问子类的属性和方法，只能引用父类的方法和属性。但是如果父类的方法被重写了，那么父类引用会调用子类这个被重写的方法。

2.2 方法重写

方法重写：
1.方法名、返回值类型、参数表(参数类型、个数、顺序)都一样。
2.被static、private、final修饰的方法不能再被重写。
3.子类重写方法的修饰限定符对于等于父类的修饰限定符
4.返回值类型如果不一样，则必须是父子类型。
在这里插入图片描述

class Animal{
    private String name;
    private int age;


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

    public String getName() {

        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {

        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
    public void eat(){
        System.out.println(name+"正在吃饭"+"(Animal)");
//        return new Animal("121",121);
    }

    @Override
    public String toString() {
        return "Animal{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}
class Cat extends Animal{
    public String catpaw;

    public Cat(String name, int age) {
        super(name, age);
    }
    public void miaomiao(){
        System.out.println(getName()+"正在喵喵喵");
    }
    @Override
    /**
     * 1.方法名、参数(类型、个数、顺序)、返回值一样
     * 2.被static、private、final修饰的方法名不能重写
     * 3.子类的修饰符访问权限大于等于父类
     * 4.如果返回值不相同，那么返回值类型必须构成父子关系
     */
    public void eat(){
        System.out.println(getName()+"正在吃猫粮");
//        return new Cat("1551",1);
    }
}

2.3 动态绑定

动态绑定：通过父类的引用调用这个被重写的方法。
在编译时父类还是引用的父类自己未被重写的方法，在运行时，父类引用发生动态绑定，引用由调用父类未被重写的方法变成调用被重写的方法。
在这里插入图片描述

在这里插入图片描述

class Animal{
    private String name;
    private int age;


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

    public String getName() {

        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {

        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
    public void eat(){
        System.out.println(name+"正在吃饭"+"(Animal)");
//        return new Animal("121",121);
    }

    @Override
    public String toString() {
        return "Animal{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}
class Dog extends Animal{

    public Dog(String name, int age) {
        super(name, age);
    }
    public void bark(){
        System.out.println(getName()+"正在汪汪汪");
    }

    @Override
    public void eat() {
        System.out.println(getName()+"正在吃狗粮");
    }
}
class Cat extends Animal{
    public String catpaw;

    public Cat(String name, int age) {
        super(name, age);
    }
    public void miaomiao(){
        System.out.println(getName()+"正在喵喵喵");
    }
    @Override
    /**
     * 1.方法名、参数(类型、个数、顺序)、返回值一样
     * 2.被static、private、final修饰的方法名不能重写
     * 3.子类的修饰符访问权限大于等于父类
     * 4.如果返回值不相同，那么返回值类型必须构成父子关系
     */
    public void eat(){
        System.out.println(getName()+"正在吃猫粮");
//        return new Cat("1551",1);
    }
}
public class Test {
    public static void fun(Animal animal){
        animal.eat();
    }
    //      返回值类型 父类
    public static Animal funcc(){
        // 返回子类对象
        return new Cat("122",1);
    }
    public static void main(String[] args) {
        fun(new Cat("小黑",1));
        fun(new Dog("白虎",1));

    }

运行结果：

总结：多态是一种思想，通过父类引用去引用子类对象，通过父类引用去调用这个被重写的方法，此时发生了动态绑定，父类的引用只有这一个，该引用所引用子类对象的不同，通过调用同一个方法所表现的结果不同。

int a = 10;
int b = 20;
a + b;
a>b;

3.向下转型

将一个子类对象经过向上转型之后当成父类方法使用，再无法调用子类的方法，但有时候可能需要调用子类特有的方法，此时：将父类引用再还原为子类对象即可，即向下转换。
向下转型用到关键字instanceof
能够向下转型：
在这里插入图片描述
不能够向下转型：
在这里插入图片描述
在这里插入图片描述

class Animal{
    private String name;
    private int age;


    public Animal(String name, int age) {
        this.name = name;
        this.age = age;
        eat();// 父类 构造方法里调用的方法也能实现动态绑定 但是以后不要这样写代码 除非考试考
    }

    public String getName() {

        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {

        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
    public void eat(){
        System.out.println(name+"正在吃饭"+"(Animal)");
//        return new Animal("121",121);
    }

    @Override
    public String toString() {
        return "Animal{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}
class Dog extends Animal{

    public Dog(String name, int age) {
        super(name, age);
    }
    public void bark(){
        System.out.println(getName()+"正在汪汪汪");
    }

    @Override
    public void eat() {
        System.out.println(getName()+"正在吃狗粮");
    }
}
class Cat extends Animal{
    public String catpaw;

    public Cat(String name, int age) {
        super(name, age);
    }
    public void miaomiao(){
        System.out.println(getName()+"正在喵喵喵");
    }
    public void Ninelives(){
        System.out.println("猫有九条命");
    }
    @Override
    /**
     * 1.方法名、参数(类型、个数、顺序)、返回值一样
     * 2.被static、private、final修饰的方法名不能重写
     * 3.子类的修饰符访问权限大于等于父类
     * 4.如果返回值不相同，那么返回值类型必须构成父子关系
     */
    public void eat(){
        System.out.println(getName()+"正在吃猫粮");
//        return new Cat("1551",1);
    }
}
 public static void main6(String[] args) {
        Animal animal = new Dog("白虎",2);
      //通过instanceof来判断 如果结果为true则执行向下转型
        if ( animal instanceof Cat){
            //不是所有的动物都是猫 狗子不是猫
            Cat cat =(Cat) animal;
            cat.Ninelives();
        }

    }
    public static void main5(String[] args) {
        Animal animal = new Cat("小橘",1);
        //向下转型
       if (animal instanceof Cat){
           Cat cat =(Cat) animal;
           cat.Ninelives();
       }

    }
 }

4.避免在父类构造方法中调用被子类重写的方法

结论: “用尽量简单的方式使对象进入可工作状态”, 尽量不要在构造器中调用方法(如果这个方法被子类重写, 就会触发动态绑定, 但是此时子类对象还没构造完成), 可能会出现一些隐藏的但是又极难发现的问题。
在这里插入图片描述

class Animal{
    private String name;
    private int age;


    public Animal(String name, int age) {
        this.name = name;
        this.age = age;
        eat();// 父类 构造方法里调用的方法也能实现动态绑定 但是以后不要这样写代码 除非考试考
    }

    public String getName() {

        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {

        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
    public void eat(){
        System.out.println(name+"正在吃饭"+"(Animal)");
//        return new Animal("121",121);
    }

    @Override
    public String toString() {
        return "Animal{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}
class Dog extends Animal{

    public Dog(String name, int age) {
        super(name, age);
    }
    public void bark(){
        System.out.println(getName()+"正在汪汪汪");
    }

    @Override
    public void eat() {
        System.out.println(getName()+"正在吃狗粮");
    }
}
public class Test {
    public static void main(String[] args) {
        Animal animal = new Animal("动物",1);
        Dog dog = new Dog("狗子",2);

    }
 }

运行结果：
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

5.多态的优缺点

先看下面的代码：

class Shape{
    public void draw(){
        System.out.println("画图形");
    }
}
class Thefireworks extends Shape{
    @Override
    public void draw() {
        System.out.println("🎇");
    }
}
class Smile extends Shape{
    @Override
    public void draw() {
        System.out.println("😊");
    }
}
class Flower extends Shape{
    @Override
    public void draw() {
        System.out.println("💐");
    }
}
public class ShapeTest {
    public static void drawMap(Shape shape){
        shape.draw();

    }
    public static void main(String[] args) {
        Thefireworks thefireworks = new Thefireworks();
        Smile smile = new Smile();
        Flower flower = new Flower();
        drawMap(thefireworks);
        drawMap(smile);
        drawMap(flower);

    }
}

用数组：

class Shape{
    public void draw(){
        System.out.println("画图形");
    }
}
class Thefireworks extends Shape{
    @Override
    public void draw() {
        System.out.println("🎇");
    }
}
class Smile extends Shape{
    @Override
    public void draw() {
        System.out.println("😊");
    }
}
class Flower extends Shape{
    @Override
    public void draw() {
        System.out.println("💐");
    }
}
public class ShapeTest {
    public static void drawMap(Shape shape){
        shape.draw();

    }
    public static void main(String[] args) {
        Thefireworks thefireworks = new Thefireworks();
        Smile smile = new Smile();
        Flower flower = new Flower();
        //向上转型
        Shape [] shapes = {thefireworks,smile,flower,thefireworks,smile,flower};
        for (Shape shape:shapes){
            shape.draw();
        }
//        drawMap(thefireworks);
//        drawMap(smile);
//        drawMap(flower);

    }
}

如果这段代码不用多态实现：

class Shape{
    public void draw(){
        System.out.println("画图形");
    }
}
class Thefireworks extends Shape{
    @Override
    public void draw() {
        System.out.println("🎇");
    }
}
class Smile extends Shape{
    @Override
    public void draw() {
        System.out.println("😊");
    }
}
class Flower extends Shape{
    @Override
    public void draw() {
        System.out.println("💐");
    }
}
public class ShapeTest {
    public static void drawMap(Shape shape) {
        shape.draw();

    }

    public static void main(String[] args) {
        Thefireworks thefireworks = new Thefireworks();
        Smile smile = new Smile();
        Flower flower = new Flower();
        String[] shapes = {"thefireworks", "smile", "flower", "thefireworks", "smile", "flower"};
        for (String shape : shapes) {
            if (shape.equals("thefireworks")) {
                thefireworks.draw();
            } else if (shape.equals("smile")) {
                smile.draw();
            } else if (shape.equals("flower")) {
                flower.draw();
            } else if (shape.equals("thefireworks")) {
                thefireworks.draw();
            } else if (shape.equals("smile")) {
                smile.draw();
            } else if (shape.equals("flower")) {
                flower.draw();
            }
//        drawMap(thefireworks);
//        drawMap(smile);
//        drawMap(flower);

        }
    }
}

【使用多态的好处】

  1. 能够降低代码的 “圈复杂度”, 避免使用大量的 if - else什么叫 “圈复杂度” ?
    圈复杂度是一种描述一段代码复杂程度的方式. 一段代码如果平铺直叙, 那么就比较简单容易理解. 而如果有很多的条件分支或者循环语句, 就认为理解起来更复杂.
    因此我们可以简单粗暴的计算一段代码中条件语句和循环语句出现的个数, 这个个数就称为 “圈复杂度”.如果一个方法的圈复杂度太高, 就需要考虑重构.
    不同公司对于代码的圈复杂度的规范不一样. 一般不会超过 10 .
  2. 可扩展能力更强
    如果要新增一种新的形状, 使用多态的方式代码改动成本也比较低.

在这里插入图片描述
只用添加一段子类的代码。
对于类的调用者来说(drawShapes方法), 只要创建一个新类的实例就可以了, 改动成本很低.
而对于不用多态的情况, 就要把 drawShapes 中的 if - else 进行一定的修改, 改动成本更高.
多态缺陷：代码的运行效率降低

🌏🌏🌏今天的你看懂这里又学到了很多东西吧🌏🌏🌏

在这里插入图片描述

🌔 🌔 🌔下次见喽🌔 🌔 🌔
在这里插入图片描述

马上回来了
关注
专栏目录
Java基础 学习笔记 Markdownr版
06-27
面向对象的三大特性——封装、继承和多态，在06面向对象（上）、07面向对象（中）和08面向对象（下）中进行了详细介绍。其中，封装是保护数据免受外部世界干扰，继承允许子类继承父类的属性和方法，而多态则提供了...
Java每日一题
weixin_33788244的博客
06-17 1134
1、(单选题)What will be printed when you execute the following code? class C { 　　C() { 　　　　System.out.print("C"); 　　} } class A { 　　C c = new C(); 　　A() { 　　　　this("A"); 　　　　System.out.print("...
Java 经典笔试题
weixin_33948416的博客
05-07 381
        文章转载自：http://blog.csdn.net/hdwt/article/details/1294558         这些题目对我的笔试帮助很大，有需要的朋友都可以来看看，在笔试中能遇到的题目基本上下面都会出现，虽然形式不同，当考察的基本的知识点还是相同的。         在分析中肯定有不足和谬误的地方还请大虾们能够给予及时的纠正,特此感谢。 1. publ...
Java异常
该博主太懒了，简介都不写
08-25 315
Java异常 1、什么是异常？ Java 中的错误大致可以分为两类： 一类是编译时错误，一般是指语法错误。 另一类是运行时错误。 Java 中有一组专门用来描述各种不同的运行时异常，叫做异常类，Java 结合异常类提供了处理错误的机制。 具体步骤是当程序出现错误时，会创建一个包含错误信息的异常类的实例化对象，并自动将该对象提交给系统，由系统转交给能够处理异常的代码进行处理。 异常可以分为两类：Error 和 Exception。 Error 是指系统错误，JVM 生成，我们编写的程序无法处理。 Except
java入门基础(四)
qq_45798550的博客
08-15 2314
（一）对象和类 类:类是对象的抽象(不存在) 对象:对象是类的实现(具体存在) 现实生活中先有对象再有类 Java中先有类再有对象 面向对象:是一种思想,在开发过程中关注于对象进行开发 类中相同的行为和特征在Java中如何表示 特征:变量 行为:方法 类的定义: 1.public class 类名{} 2.定义成员变量 格式:public 数据类型 变量名 3.定义成员方法 格式:public 返回值数据类型 方法名称(参数){} 类的使用(对象): 1.通过类创建对象 格式:类名 对象名=
java中匿名类例题的简要分析
cilicilico的博客
04-01 992
在学习java的继承的过程中遇到这样的一个分析类题目，比较有意思，在这里做出简要分析： //请写出以下程序运行结果： package test; public class Test { public static void main(String[] args) { Test t = new Test(); t.show(new Car(){ pu...
javaSE代码实例
06-21
第8章　继承——多态的支柱　122 8.1　继承概述　122 8.1.1　类之间的关系　122 8.1.2　面向对象中的继承性　124 8.2　类的继承　125 8.3　成员变量的继承与隐藏　126 8.3.1　成员变量的继承规则　126 8.3.2　成员...
Java基础知识——Java入门与加深
08-31
Java是一种广泛使用的面向...总结，Java的基础知识涵盖了从基本语法到面向对象编程，再到高级特性和框架。理解并熟练运用这些知识，是成为一名合格的Java开发者的关键。希望本文能为你的Java学习之路提供有力的支持。
传智播客毕向东JavaSE课件
07-23
2. **Java语法基础**：包括数据类型（基本类型和引用类型）、变量、运算符、流程控制（条件语句和循环结构）、数组等基础知识。学习者将学会编写简单的Java程序并理解程序运行机制。 3. **面向对象编程**：这是Java...
java 基础知识储备（csdn）————程序.pdf
12-01
- **JavaSE**（Standard Edition）：适用于桌面应用和控制台开发，是Java的基础和核心。 - **JavaME**（Micro Edition）：针对嵌入式设备，如手机和小家电，目前在移动领域已不再主流。 - **JavaEE**（Enterprise...
易错的JAVA笔试题
wys0127的博客
04-17 968
需求：阅读下面程序，并给出程序的运行结果 。 public class Test01 { public static void main(String[] args) { new B(); } } class B extends A{ int x = 5; public B(){ run(); } public void run(){ System.out.println(x); } } class
异常Java
HongYu012的博客
02-24 902
异常 1.什么是异常 异常指程序运行过程中出现的不期而至的各种状况，如：文件找不到、网络连接失败等 异常发生在程序运行期间，它影响了正常的程序执行流程 public class Demo01 { public static void main(String[] args) { System.out.println(11/0); } } Exception in thread "main" java.lang.ArithmeticException: / by
Java面试笔试-003-public static void main(String[] args)
qq_33605778的博客
04-23 5335
描述1）publicpublic是权限修饰符，表明任何类或对象都可以访问这个方法。2）staticstatic表明main()方法是一个静态方法，即方法中的代码是存储在静态存储区的，只要类被加载后，就可以使用该方法而不需要通过实例化对象来访问，可以直接通过类名.main()直接访问，JVM在启动时就是按照上述方法的签名（必须有public与static修饰，返回值为void,且方法的参数为字符中数组
java 静态变量和静态块底层原理
h70614959的专栏
11-04 3538
Java静态变量的初始化（static块的本质） 在网上看到了下面的一段代码： public class Test {       static {            _i = 20;        }       public static int _i = 10;              public static void main(String[] args) {
Java static关键字详解
热门推荐
测试极客
08-07 13万+
static关键字 在类中，用static声明的成员变量为静态成员变量，也成为类变量。类变量的生命周期和类相同，在整个应用程序执行期间都有效。 这里要强调一下： static修饰的成员变量和方法，从属于类 普通变量和方法从属于对象 静态方法不能调用非静态成员，编译会报错 static关键字的用途 一句话描述就是：方便在没有创建对象的情况下进行调用(方法/变量)。 显然，被sta...
Java基础题10：(单选题)以下代码的输出结果是（） public class Test { public static void main(String[] args) { Stri
qq_45453185的博客
08-15 2万+
一道String面试题
bi_ma_wen的博客
04-01 1077
能用代码解决不瞎比比!public class Test { public static void changeStr(String str) { str = new String("welcome"); } public static void main(String[] args) { String str = "1234";
Java基础题29：(单选题)阅读下列代码； public class Test{ String s=“One World One Dream“； public static void main(St
qq_45453185的博客
09-14 4269
29、(单选题)阅读下列代码; public class Test{ String s=“One World One Dream”; public static void main(String args[]){ System.out.println(s); } } 其运行结果是（） A.args B.One World One Dream C.s D.编译错误 【正确答案】D 【答案解析】main方法是程序执行的入口，在本程序中main方法中的语句"System.out.println(s);"无法调用在
public static class和public class的区别 和builder模式
usstmiracle的博客
01-18 1万+
链接：https://www.jianshu.com/p/749fbd9879cf https://blog.csdn.net/gengqiquan/article/details/52764455    （builder模式） 新学的java知识，静态类，使用static关键字修饰的类（public static class） 今天在看别人源码的时候看到了一个新知识。使用static关键字...
JavaSE入门详解：从基础到高级特性
在JavaSE的学习中，基础部分包括了对Java编程语言的理解，如基本语法、数据类型（整型、浮点型、字符型、布尔型）以及常量和变量的使用。数组是存储同类型数据的集合，可以是一维、二维或多维。类和对象是面向对象...
评论 19
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

马上回来了

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值