Java多态概述

最新推荐文章于 2022-07-14 20:57:06 发布
原创 最新推荐文章于 2022-07-14 20:57:06 发布 · 230 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

本文介绍了Java中的多态概念，包括多态的前提条件——继承和方法重写，以及多态在成员变量、成员方法、静态成员方法访问上的特点。讨论了多态带来的好处，如代码维护性和扩展性提升，同时也指出了其弊端，如无法访问子类特有属性和行为。还涵盖了向上转型和向下转型的操作，并给出了多态中应注意的事项。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

一、多态的概述

  • 事物存在多种形态
2.多态的前提
  • 要有继承关系
  • 要有方法重写
  • 要有父类引用指向子类对象
3.代码体现
class Demo1_Polymorphic {
  public static void main(String[] args) {
      Cat c = new Cat();
      c.eat();

      //父类引用指向子类对象
      Animal a = new Cat();
      a.eat();
  }
}


class Animal {
  public void eat() {
      System.out.println("动物吃饭");
  }
}

class Cat extends Animal {
  public void eat() {
      System.out.println("猫吃鱼");
  }
}
输出：
猫吃鱼
猫吃鱼
4.多态中成员变量访问特点
  • 成员变量

编译看左边（父类）运行看左边（父类）

class Demo2_Polymorphic {
  public static void main(String[] args) {
      //父类引用指向子类对象
      Father f = new Son();
      System.out.println(f.num);

  }
}

class Father {
   int num = 10;
}

class Son extends Father {
   int num = 20;
}
输出：10

在这里插入图片描述

5.多态中成员方法访问特点
  • 成员方法

编译看左边(父类)，运行看右边(子类)。动态绑定

class Demo2_Polymorphic {
 public static void main(String[] args) {
     //父类引用指向子类对象
     Father f = new Son();
     System.out.println(f.num);

     Son s = new Son();
     System.out.println(s.num);

     Father f1 = new Son();
     f1.print();
 }
}

class Father {
 int num = 10;

 public void print() {
     System.out.println("father");
 }

}

class Son extends Father {
 int num = 20;

 public void print() {
     System.out.println("son");
 }
}

输出：
10
20
son
6.多态中静态成员方法访问特点
  • 静态方法
    • 编译看左边(父类)，运行看左边(父类)。
    • (静态和类相关，算不上重写，所以，访问还是左边的)
    • 只有非静态的成员方法,编译看左边,运行看右边
class Demo2_Polymorphic {
 public static void main(String[] args) {
     Father f = new Son();
     //相当于是Father.method()
     f.method();
 }
}

/*
静态方法
编译看左边(父类)，运行看左边(父类)。
(静态和类相关，算不上重写，所以，访问还是左边的)
只有非静态的成员方法,编译看左边,运行看右边
*/

class Father {
 public static void method() {
     System.out.println("father static method");
 }
}

class Son extends Father {
 public static void method() {
     System.out.println("son static method");
 }
}
7.多态中向上转型与向下转型
  • 一定先有向上转型，才有向下转型
基本数据类型自动类型提升和强制类型转换
int i = 10;
byte b = 20;
i = b;	 //自动类型提升
b = (byte)i; 	//强制类型转换

class Demo3_SuperMan {
 public static void main(String[] args) {

     //父类引用指向子类对象,超人提升为了人
     Person p = new SuperMan();
     //父类引用指向子类对象就是向上转型
     System.out.println(p.name);
     p.谈生意();

     //向下转型
     SuperMan sm = (SuperMan) p;
     sm.fly();
 }
}

class Person {
 String name = "John";

 public void 谈生意() {
     System.out.println("谈生意");
 }
}

class SuperMan extends Person {
 String name = "superMan";

 public void 谈生意() {
     System.out.println("谈几个亿的大单子");
 }

 public void fly() {
     System.out.println("飞出去救人");
 }
}

输出：
John
谈几个亿的大单子
飞出去救人
8.多态的好处与弊端
多态的好处
  • 提高了代码的维护性(继承保证)
  • 提高了代码的扩展性(由多态保证)
  • 多态的好处
    • 可以当作形式参数,可以接收任意子类对象
多态的弊端
  • 不能使用子类的特有属性和行为。
class Demo4_Animal {
 public static void main(String[] args) {
     Cat c1 = new Cat();
     c1.eat();
     method(new Cat());
     method(new Dog());
 }

 //Cat c = new Dog();狗是一只猫,这是错误的
 public static void method(Cat c) {
     c.eat();
 }

 public static void method(Dog d) {
     d.eat();
 }


}


class Animal {
 public void eat() {
     System.out.println("动物吃饭");
 }
}

class Cat extends Animal {
 public void eat() {
     System.out.println("猫吃鱼");
 }

 public void catchMouse() {
     System.out.println("抓老鼠");
 }
}

class Dog extends Animal {
 public void eat() {
     System.out.println("狗吃肉");
 }

 public void lookHome() {
     System.out.println("看家");
 }
}
输出：
猫吃鱼
猫吃鱼
狗吃肉

class Demo4_Animal {
public static void main(String[] args) {
    
    method(new Cat());
    method(new Dog());

    // 开发的是很少在创建对象的时候用父类引用指向子类对象,直接创建子类对象更方便,可以使用子类中的特有属性和行为
    //Animal a = new Cat();
}

//如果把狗强转成猫就会出现类型转换异常,ClassCastException
public static void method(Animal a) {    //当作参数的时候用多态最好,因为扩展性强
    //关键字 instanceof 判断前边的引用是否是后边的数据类型
    if (a instanceof Cat) {
        Cat c = (Cat) a;
        c.eat();
        c.catchMouse();
    } else if (a instanceof Dog) {
        Dog d = (Dog) a;
        d.eat();
        d.lookHome();
    } else {
        a.eat();
    }
}
}



class Animal {
public void eat() {
    System.out.println("动物吃饭");
}
}

class Cat extends Animal {
public void eat() {
    System.out.println("猫吃鱼");
}

public void catchMouse() {
    System.out.println("抓老鼠");
}
}

class Dog extends Animal {
public void eat() {
    System.out.println("狗吃肉");
}

public void lookHome() {
    System.out.println("看家");
}
}
输出：
猫吃鱼
抓老鼠
狗吃肉
看家
9.多态中的注意事项
class Test1_Polymorphic {
 public static void main(String[] args) {
     //编译看左边，运行看右边
     Fu f = new Zi();
     f.show();
     //f.method();//因为父类中没有此方法，编译会报错的
 }
}

class Fu {
 public void show() {
     System.out.println("fu show");
 }
}

class Zi extends Fu {
 public void show() {
     System.out.println("zi show");
 }
 public void method() {
     System.out.println("zi method");
 }
}

class Test2_Polymorphic {
 public static void main(String[] args) {
    A a = new B();
    a.show();

//编译看左边，运行看右边，父类B有show()方法，编译通过，调用子类C的show()方法
     B b = new C();
     b.show();
 }
}

class A {
 public void show() {
     show2();
 }
 public void show2() {
     System.out.println("我");
 }
}

class B extends A {
 public void show() {
     show2();
 }
 public void show2() {
     System.out.println("爱");
 }
}


class C extends B {
 public void show() {
     super.show();
 }
 public void show2() {
     System.out.println("你");
 }
}
输出：
爱
你
Java语言-类的多态详解
NoobNo2的博客
07-17 1513
我上述的代码中，eat方法形参是Animal，传参是Dog或者Cat类，此时发生的就是一个典型的动态绑定，即：编译期间无法确定方法的行为，需要等到程序运行时看看传入的实参是谁（Dog还是Cat）才能确定调用哪个方法。将一个子类对象经过向上转型之后当成父类方法使用，再无法调用子类的方法，但有时候可能需要调用子类特有的方法，此时：将父类引用再还原为子类对象即可，即向下转换。也就是说子类能够根据需要实现父类的方法。，即在编译时，不能确定方法的行为，需要等到程序运行时，才能够确定具体调用那个类的方法。
Java>多态>>多态的概述与使用
越努力，越幸福！
07-29 305
多态的概述： 一个对象拥有多种形态，这就是：对象的多态性（多态指的是对象而不是类） 多态的使用： 代码当中体现多态，其实就是一句话，父类引用指向子类对象。 格式： 父类名称 对象名 = new 子类名称(); 或者， 接口名称 对象名 = new 实现类名称(); 使用多态的好处： 无论右边new的时候换成哪个子对象，等号左边的调用方法都不会改变 实例如下： 创建一个父...
Java 多态的概述
dldodo的博客
06-01 331
面向对象有三大特点：封装，继承，多态。前两者比较简单，大家也没什么疑惑。现在就解释下多态。看了很多人写的关于多态的表述，感觉总是差那么一点，说的不痛快，我把自己对于多态的看法写出来。 1.※什么是多态 多态是同一个行为具有多个不同表现形式或形态的能力。 2.※多态的前提条件有哪些 要有继承/实现关系 要有方法重写 要有父类引用指向子类对象 3.※ 多态的成员特点是什么 Animal a=new Dog();//Dog类继承Animal，有方法的重写。 当代码变成这个样子的时候，...
JAVA多态概述
小冬瓜的博客
11-30 328
一、什么是多态 多态性是面向对象程序设计代码重用的重要机制之一，JAVA中通常将多态分为两大类（特定的（强制的、重载的）、通用的（包含的、参数的））。 1、强制的：一种隐式做类型转换的方法。 2、重载的：将一个标识符用作多个意义。 3、参数的：为不同类型的参数提供相同的操作。 · 4、包含的：类包含关系的抽象操作。 二、概念解释 1、强制的多态 强制的多态隐式地将参数按某种方式
Java中的多态概述
weixin_43502415的博客
04-21 188
多态概述 事物存在的多种形态 多态前提 1.要有继承关系 2.要有方法重写 3.要有父类引用指向子类对象（Animal a = new Cat();） 代码体现多态如下： public class test { public static void main(String [] args) { Cat c = new Cat(); //实例化对象，猫是猫 c...
Java 多态性（概述）
weixin_49199821的博客
12-15 616
多态性 多态性是发送消息给某个对象，让该对象自行决定响应何种行为。通过将子类对象引用复制给超类对象引用变量来实现动态方法调用 多态形成的三个必要条件： 有继承，父类定义方法，子类重写方法 父类的引用指向子类的对象 Object obj = new Date(); 可以使用参数传递时多态，也可以直接创建对象时多态 多态可以用三个定义个两个方法来总结 三个定义分别是父类定义子类构建、接口定义实现类构建、抽象类定义实体类构建 两个方法分别是方法重载和方法重
JAVA基础（多态的概述）
Cricket_7的博客
06-15 211
1，多态(polymorphic)概述 事物存在的多种形态 【1】多态前提 要有继承关系。 要有方法重写。 要有父类引用指向子类对象。 2， 代码体现多态 class Demo1_Polymorphic { public static void main(String[] args) { Cat c = new Cat(); ...
概述java中的多态
涟涟的博客
08-01 171
1.当子类对象调用重写后的方法时，调用的是子类重写后的方法 我们写一个实例帮助理解 我们写一个父类： public class Mammal { public void move() { System.out.println("正在游动、、、、"); } } 子类： public class Whale extends Mammal { public void move() {...
java多态的概念_Java基本概念：多态
weixin_35975197的博客
02-16 4992
一、简介描述：多态性是面向对象编程中的一个重要特性，主要是用来实现动态联编的。换句话说，就是程序的最终状态只有在执行过程中才被决定，而非在编译期间就决定了。这对于大型系统来说能提高系统的灵活性和扩展性。多态允许相同类域的不同对象对同一消息做出响应。即同一消息可以根据发送对象的不同而采用多种不同的行为方式。多态可以让我们不用关心某个对象到底是什么具体类型，就可以使用该对象的某些方法，从而实现更加灵活...
java语言中的多态概述
人间诗画的专栏
03-12 1043
java语言中的多态概述
Java中多态的概述与使用
bingongzi的博客
07-15 207
一、多态的概述： 某一个事物（对象），在不同时刻表现出来的不同状态。 例：1.猫可以是猫的类型，猫 m = new 猫(); 2.同时猫也是动物的一种，动物 m = new 猫(); 二、多态的前提和弊端： 1.有继承关系； 2.有方法重写； 3.有父类引用指向子类对象； 三、多态中的成员访问特点： 1.成员变量：编译看左边（父...
Java学习-多态的概述
qq_44813352的博客
02-16 136
Java基础（多态的概述及使用）
Money_bagZ的博客
05-02 198
代码当中体现多态性，其实就是一句话，父类引用指向子类对象。 格式: 父类名称 对象名 = new 子类名称(); //右侧子类就被当作父类来使用 或者： 接口名称 对象名 = new 实现类名称(); 例如: package 多态; public class democ01 { public static void main(String[] args) { // ...
Java多态（简单介绍）
m0_58336322的博客
07-13 412
多态
Java中多态详细介绍
qq_40808896的博客
04-25 358
多态 （1）概述:同一个对象，在不同时刻表现出来的不同形态； 比如：猫，可以是猫，也可以是动物；这种表示形式就是多态； 多态的前提和体现：有继承/实现关系；有方法重写；有父类引用指向子类对象； （2）多态中成员访问特点 构造方法：同继承相同，子类会通过super访问父类构造方法； 成员变量：编译看左边（父类），执行看左边（父类）； 成员方法：编译看左边(父类)，执行看右边（子类）： 成员变量和成员方法不一样的原因是：成员方法有重写，而成员变量没有； （3）多态的缺点和优点； 优点：
Java 多态简单介绍
weixin_47942417的博客
07-14 130
父类定义两个num和一个geResult（）方法，此方法并没有具体实现。如果子类重写了getResult（）方法，调用的就是子类中的方法。如果子类重写了getResult（）方法，调用的就是子类中的方法。加减乘除四个子类继承父类Cal并重写geResult（）方法。多态声明成父类类型，指向不同的子类对象，能实现不同的重写方法。声明成父类类型，指向不同的子类对象，能实现不同的重写方法。如果没有重写，调用的就是父类中的方法。如果没有重写，调用的就是父类中的方法。3.父类引用指向子类对象。.........
详细讲解java中的多态
galaxyrt的博客
03-22 360
1、多态概述 同一对象在不同时刻表现不同的形态 举例：猫 猫 cat=new 猫；（猫是猫） 动物 animal=new 猫（猫是动物） 猫在不同时刻表现出不同状态就是多态 多态的前提和表现： 1、有继承和实现关系 2、有方法重写 3、有父类引用指向子类对象 代码实现多态： 父类： package animals; public class animal { public void eat(){ System.out.println("动物");
java多态的实用
最新发布
03-08
### Java 多态的实际应用和用法 #### 实际应用场景 在软件开发中，多态的应用场景广泛存在于需要处理具有共同特征但行为各异的对象集合时。例如，在图形界面设计中，各种形状（圆形、矩形等）都可视为广义上的`...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值