Day10_多态

于 2021-07-20 10:59:50 发布
阅读量258 收藏 1
点赞数
分类专栏： # 大数据优就业——javase阶段
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_36972345/article/details/118894342
版权

一、多态

1.1泛化

泛化就是抽象化，把具体的事物当作抽象的东西看待（把猫看成动物）。

泛化也叫向上转型，是通往多态的路口。

Cat c = New Cat()
Animail n = New Cat();
//这种不叫泛化  叫自动转换
double x = 1;

这样做有用吗？

有用，我们可以用同样的类型处理不同的东西。

示例代码

public class Animal {
    private String name;
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
​
    public void eat(){
        System.out.println("吃");
    }
    public void sleep(){
        System.out.println("睡");
    }
}
​
public class Cat extends Animal {
    private String eyeColor;
    public String getEyeColor() {
        return eyeColor;
    }
    public void setEyeColor(String eyeColor) {
        this.eyeColor = eyeColor;
    }
    public void climbTree(){
        System.out.println("爬树###");
    }
}
​
public class Demo01{
    /*泛化——向上转型
     *子类中特有的内容将不能被访问
     * */
    public static void main(String[] args) {
    /*  
        Cat cat = new Cat();
        cat.climbTree();
        cat.eat();
        cat.sleep();
        
        Animal a = cat;  // 把猫看成动物——泛化——向上转型
        a.eat();
        a.sleep();
        //a.climbTree();  //子类中特有的内容不能访问
    */
​
    /*
        Animal a = new Animal();
        Cat cat= (Cat)a;          //    很不安全
        cat.climbTree();
    */
        /*
        Animal a = new Cat();
        Cat c = (Cat)a;           //强转 这样做还勉强可以
        */
    }
}

这样做的缺点就是Cat中特有的方法就不能调用了

注意：只有向上转型，没有向下转型。向下转型叫做强转，这样做很不安全！

 Cat c = (Cat)o; 编译可以通过，但是运行时会出现错误。

泛化指的是引用的泛化，不是对象的泛化，内存中的对象还是原来的对象，只是把引用的类型给改变了。

1.2多态的概念

多态就是指程序中定义的引用变量所指向的具体类型和通过该引用变量发出的方法调用在编程时并不确定，而是在程序运行期间才确定，即一个引用变量倒底会指向哪个类的实例对象，该引用变量发出的方法调用到底是哪个类中实现的方法，必须在由程序运行期间才能决定。因为在程序运行时才能确定具体的类，这样，不用修改源程序代码，就可以让引用变量绑定到各种不同的类实现上，从而导致该引用调用的具体方法随之改变，即不修改程序代码就可以改变程序运行时所绑定的具体代码，让程序可以选择多个运行状态，这就是多态性。

简单来说，多态就是一个事物的多种状态（形态）。

现实生活中，关于多态的例子不胜枚举。比方说按下 F1 键这个动作，如果当前在 Flash 界面下弹出的就是 AS 3 的帮助文档；如果当前在 Word 下弹出的就是Word 帮助；在 Windows 下弹出的就是 Windows 帮助和支持。同一个事件发生在不同的对象上会产生不同的结果。

1.3多态的分类

Java中的多态，可以分为静态多态和动态多态。

静态多态就是指方法的重载。

动态多态是指“动态绑定”。而我们这里所说的多态，大多数是指动态多态。

静态多态是方法重载。

多态应该具备的条件

  • 继承

  • 子类重写父类的方法

  • 父类引用指向子类对象（泛化）

二、动态绑定和静态绑定

1.1动态绑定

所谓动态绑定，是指在编译期不能确定引用指向什么类型，而是在运行期选择具体的类型。

示例代码

Animal a = new Cat() 编译期不能确定类型。

运行时确定是Cat类型。

为什么说编译器不能确定是Cat类型呢？

public class Animal {
    String name="动物";
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public void eat(){
        System.out.println("吃");
    }
    public void sleep(){
        System.out.println("睡");
    }
    public static void sayHello(){
        System.out.println("你好，我是动物");
    }
}
​
public class Cat extends Animal {
    String name="猫";
    //重写
    public void eat(){
        System.out.println("吃鱼@@@");
    }
    //重写
    public void sleep(){
        System.out.println("白天睡觉，晚上行动@@@");
    }
    public void climbTree(){
        System.out.println("爬树");
    }
    public static void sayHello(){
        System.out.println("你好，我是猫");
    }
}
​
public class Dog extends Animal {
    //重写
    public void eat(){
        System.out.println("吃骨头...");
    }
    //重写
    public void sleep(){
        System.out.println("在狗窝中睡觉...");
    }
}
​
public class Demo01_动态绑定_多态 {
​
        double ran = Math.random();
        Animal a;
        if(ran>0.5){
            a = new Cat();
        }else{
            a = new Dog();
        }
        a.eat();
    }
}

编译器能确定a的类型吗？？？不能，因为编译期，随机数的值还没有生成。

注意

子类重写父类的方法。

当使用父类的引用指向子类的对象时，调用这个重写的方法，调用到的是子类重写的方法。

示例代码

Animal a = new Cat();
//a.climbTree();
a.eat();   //动态绑定——绑定的是Cat类中重写的eat方法

总结

多态中成员方法的访问特点：编译看左边，运行看右边

1.2静态绑定

静态绑定是指编译期就确定调用的是父类中的成员。

动态绑定只是针对类中的普通方法，而对于成员变量，静态变量，静态方法，采用的是静态绑定。也就是说，对于成员变量，静态变量，和静态方法，绑定的是声明时类型中的成员。

示例代码

Animal a = new Cat();
a.eat();   //动态绑定
        
System.out.println(a.name);  //静态绑定
a.sayHello();  // 静态绑定

总结：成员变量、静态方法、静态变量、私有变量等采用静态绑定

编译看左边，运行看右边

1.3 引用类型转换

多态的转型分为向上转型与强转两种：

向上转型

  • 向上转型：多态本身是子类类型向父类类型向上转换的过程，这个过程是默认的。

当父类引用指向一个子类对象时，便是向上转型。

使用格式：

父类类型  变量名 = new 子类类型();
如：Animal a = new Cat();

强转

  • 强转：父类类型向子类类型向下转换的过程，这个过程是强制的。

一个已经向上转型的子类对象，将父类引用转为子类引用，可以使用强制类型转换的格式，便是向下转型。

使用格式：

子类类型 变量名 = (子类类型) 父类变量名;
如:Cat c =(Cat) a;  

为什么要转型

当使用多态方式调用方法时，首先检查父类中是否有该方法，如果没有，则编译错误。也就是说，不能调用子类拥有，而父类没有的方法。这也是多态给我们带来的一点"小麻烦"。所以，想要调用子类特有的方法，必须做向下转型。

转型演示，代码如下：

定义类：

abstract class Animal {  
    abstract void eat();  
}  
​
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 watchHouse() {  
        System.out.println("看家");  
    }  
}

定义测试类：

public class Test {
    public static void main(String[] args) {
        // 向上转型  
        Animal a = new Cat();  
        a.eat();                // 调用的是 Cat 的 eat
​
        // 向下转型  
        Cat c = (Cat)a;       
        c.catchMouse();         // 调用的是 Cat 的 catchMouse
    }  
}

转型的异常

转型的过程中，一不小心就会遇到这样的问题，请看如下代码：

public class Test {
    public static void main(String[] args) {
        // 向上转型  
        Animal a = new Cat();  
        a.eat();               // 调用的是 Cat 的 eat
​
        // 向下转型  
        Dog d = (Dog)a;       
        d.watchHouse();        // 调用的是 Dog 的 watchHouse 【运行报错】
    }  
}

这段代码可以通过编译，但是运行时，却报出了 ClassCastException ，类型转换异常！这是因为，明明创建了Cat类型对象，运行时，当然不能转换成Dog对象的。这两个类型并没有任何继承关系，不符合类型转换的定义。

为了避免ClassCastException的发生，Java提供了 instanceof 关键字，给引用变量做类型的校验，格式如下：

变量名 instanceof 数据类型 
如果变量属于该数据类型，返回true。
如果变量不属于该数据类型，返回false。

所以，转换前，我们最好先做一个判断，代码如下：

public class Test {
    public static void main(String[] args) {
        // 向上转型  
        Animal a = new Cat();  
        a.eat();               // 调用的是 Cat 的 eat
​
        // 向下转型  
        if (a instanceof Cat){
            Cat c = (Cat)a;       
            c.catchMouse();        // 调用的是 Cat 的 catchMouse
        } else if (a instanceof Dog){
            Dog d = (Dog)a;       
            d.watchHouse();       // 调用的是 Dog 的 watchHouse
        }
    }  
}

三、多态的好处

1.1多态的好处

站在更高的层次管理对象的行为

例如：气象专家告诉农民收割庄稼。

1.2多态的应用

案例1： 多态做为形参（接受范围更广的对象，避免方法重载过度使用）
需求：完成喂动物操作。定义一个动物园类，类中有一个喂动物的方法。
动物包括：老虎，猴子，狗，猫。每个动物类中都有一个eat的方法。（喂动物即是调用动物的eat方法）  

示例代码

public class Animal {
    public void eat(){
        System.out.println("吃");
    }
}
​
public class Tiger extends Animal{
    public void eat(){
        System.out.println("吃肉###");
    }
}
​
public class Monkey extends Animal{
    public void eat(){
        System.out.println("吃桃...");
    }
}
public class Cat extends Animal{
    public void eat(){
        System.out.println("吃鱼");
    }
}
​
public class Dog extends Animal{
    public void eat(){
        System.out.println("啃骨头");
    }
}
​
public class Zoo {
    public void feed(Animal a){
        a.eat();
    }
    
/*  
    public void feed(Tiger tiger){
        tiger.eat();
    }
    
    public void feed(Monkey monkey){
        monkey.eat();
    }
    
    public void feed(Cat cat){
        cat.eat();
    }
    
    public void feed(Dog dog){
        dog.eat();
    }
    
*/
}
​
public static void main(String[] args) {
        Zoo zoo = new Zoo();
        
        Tiger tiger = new Tiger();
        zoo.feed(tiger);
        
        Monkey monkey = new Monkey();
        zoo.feed(monkey);
        
        Cat cat = new Cat();
        zoo.feed(cat);
        
        Dog dog = new Dog();
        zoo.feed(dog);
}

案例2： 多态做为返回值类型（简单工厂模式）
需求：有一个生产汽车的工厂，有一个生产汽车的方法，根据客户不同的需求，可以生产出不同的汽车。汽车包括：奔驰（benz）、宝马（BMW）、法拉利（ferrari）

示例代码

public class Car {
    public void run(){
        System.out.println("run");
    }
}
public class CarFactory {
    public Car makeCar(String name){
        if("bmw".equals(name)){
            return new BMW();
        }
        if("benz".equals(name)){
            return new Benz();
        }
        if("ferrari".equals(name)){
            return new Ferrari();
        }
        return null;
    }
​
    /*
    public BMW makeBMW(){
        
        return new BMW();
    }
    
    public Benz makeBenz(){
        
        return new Benz();
    }
    
    public Ferrari makeFerrari(){
        
        return new Ferrari();
    }
    */
}
public class BMW extends Car{
    public void run(){
        System.out.println("宝马在路上飞驰...");
    }
}
public class Benz extends Car{
   
     public void run(){
         System.out.println("奔驰在路上奔驰###");
     }
}
public class Ferrari extends Car{
      public void run(){
          System.out.println("法拉利跑的很快");
      }
}

dogedong
关注
专栏目录
Java学习日志Day11_继承实例_多态_继承多态实例_抽象类初窥
igfff的博客
05-14 212
一、继承 二、多态
day08_10多态的使用练习1
03-26
一个多态的例子
01-06
最近看DELPHI高手突破，把里面多态的说明，用代码实现了一下。多态性是允许用户将父对象设置成为与一个或更多的它的子对象相等的技术，赋值之后，基类 对象就可以根据当前赋值给它的派生类对象的特性以不同的方式运作。代码里面没什么注释，只是一个多态的直观体现。
多态小例子
王军浩的专栏
03-12 4603
多态。没有合适的例子，想出这么个办法理解多态。如果你能想出输出内容来，就理解多态了可以飘过了……；如果你不理解多态，理解了这个例子相信你会记一辈子。 using System; using System.Collections.Generic; using System.Text; namespace ConsoleApplication2 { class Program
多态的趣味例子
枫桥夜泊
09-20 906
你和你朋友都是烟鬼, 某日,你没有带烟, 而你朋友有n种烟, 你说: 来根烟, 朋友给你一根; 你通过烟的过滤嘴, 品出为白沙烟 你再要一根, 品出这次是芙蓉王, 再要一根, 品出这次是熊猫 ... 上面描述的就是多态! 烟 a = 白沙 烟 b = 芙蓉王 烟 c = 熊猫 但发现没有, 仅仅通过"烟"基类, 引用到不同
多态的例子
白夜行
05-09 473
class MainBoard { public void run() { System.out.println("MainBoard run"); } public void usePCI(PCI p) //PCI p=new NetCard()//接口型引用指向自己的子类对象，提高程序的扩展性。 { if(p!=null) { p.open(); p.clo
关于多态的一个很形象的例子
zlb6363061的专栏
01-17 767
今天有开始对多态的理解加深了，基础不好的话看别人的程序很麻烦了，要不断地测试，测试……然后想想为什么，为什么……等过了一两年再看原来的基础代码的时候友开发犯迷糊了，又开始犯迷糊，然后测试测试……回忆一下为什么这样那样……    Father{     视察(){         System.out.println("大家好好工作啊，你们辛苦了！");       
day04_接口和多态.zip
09-12
在Java编程语言中，接口（Interface）和多态（Polymorphism）是两个核心的面向对象编程概念。接口提供了一种定义行为规范的方式，而多态则是这些规范得以灵活实现和使用的机制。让我们深入探讨这两个关键知识点。 ...
day10_07面向对象的基本特征三：多态.avi
08-12
面向对象的基本特征三：多态的理解（java） * 多态：多种形态 * * 变量的引用形式： * （1）本态引用：左边的变量与右边的对象是同一种类型 * （2）多态引用：左边的变量是父类类型，右边的对象是子类的对象 ...
day10 15 多态的概述
08-31
day10_15_多态的概述
关于多态性的经典例子
03-24
学习C#多态性！多态性是C#学习的一个难点和重点，要下功夫学习
多态简单的例子
jx_yangbingchao的博客
07-22 3844
class Animal { private String name; Animal(String name){ this.name=name; } public void enjoy(){ System.out.println("动物的叫声....."); } } class Cat extends Animal { private String eyeColor; Cat...
一个多态经典案例
BarryLee的博客
12-25 5898
1.先上概念： 同一行为的多种不同表达，或者同一行为的多种不同实现就叫做多态 方法覆盖后出现的运行时多态，其运行规则是：编译时看数据类型，运行时看实际的对象类型（new谁调谁） 就是编译看左边，运行看右边。 2.多态的匹配： 确保参数完全匹配O的前提下，依次匹配this与super考虑参数用super(O)渐近匹配O，依次匹配this与super存在子类覆盖父类方法时，根据new
多态的小例子
happy_teemo的博客
08-05 364
#include <iostream> using namespace std;class Person { public: virtual void speak() { cout << "I can speak!" << endl; } };class Chinese:public Person { public: virtual void spea
关于多态的一个简单例子
09-05 500
public static void main(String[] args){        //Collection c=new ArrayList();        Collection c=new HashSet();        int j=0;        for(int i=0;i            if(i!=3){                j++;         
多态的两个小例子
weixin_30421809的博客
11-14 98
class A { public String show(B obj){ return ("A and D"); } public String show(A obj) { return ("A and A"); } } class B extends A { public String show(B obj) { ...
java多态的简单例子
玉米猫的专栏
02-27 1435
public class main { /** * @param args */ public static void main(String[] args) { //分别将animal实例化成三种动物 Animal an = new Dog(); an.cry();//根据每种动物自身的方法，自动选择内容 an = new Cat(); an.cry();
JAVA中“多态”案例学习
weixin_43231398的博客
01-02 343
最近学习了多态的概念和使用，在此记录学习一下。 首先，什么是多态？ 多态是指：同一个方法被调用，会因为调用对象的不同导致完全不同的行为。 说的有点抽象。先了解一下多态的三要素：继承、重写和父类引用指向子类对象 继承和重写比较好理解，那什么叫做父类引用指向子类对象？这么抽象的描述怎么理解？ 举例来说： 首先实现类的继承和方法重写 public class Animal{ public void s...
java基础中的--------多态
刘小白
07-14 276
一、多态polymorphic 1、泛化 泛化就是抽象化，把具体的事物当作抽象的东西看待（把猫看成动物）。 泛化也叫向上转型，是通往多态的路口。 把子类对象看作父类对象，这样可行吗？ 可行，自愿放弃了更丰富的信息。 这样做有用吗？ 有用，我们可以用同样的类型处理不同的东西。 示例代码 public class Animal { private String name; public String getName() { return name; } public void setName(Str
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值