精华内容
下载资源
问答
  • 面向对象多态的好处和弊端 优点 1.提高代码的维护性(由继承保证):上面修改了下面也跟着修改。 2.提高了代码的延展性(由多态保证)。 3.可以当做形式参数,可以接受任何类型的子类对象。 缺点 不能使用子类...

    面向对象多态的好处和弊端

    • 优点
      1.提高代码的维护性(由继承保证):上面修改了下面也跟着修改。
      2.提高了代码的延展性(由多态保证)。
      3.可以当做形式参数,可以接受任何类型的子类对象。

    • 缺点
      不能使用子类特有的属性和行为

    • 关键字instanceof的介绍
      instanceof:为了判断引用是否是后面的数据类型
      如果想使用子类特有的属性和行为,就要强转之后再使用。否则,就会出现类型转化异常ClassCastException。

    • 运用到instanceof通常的写法

      public static void method(父类 a) {				//创建静态的方法
             		 if (a instanceof 子类1) {  					//如果a是子类1
                       子类1 z  = (子类) a;						//将父类a强制转化子类1
                       c.子类特有方法1 ( );	
                       c.子类的方法 ( );
                   } 
                   else if (a instanceof 子类2) {					//如果a是子类2同上
                       Dog3 d = (Dog3) a;
                       a.eat ( );
                       a.lookHouse ( );
                   } 
                   else {											//否则调用父类自己的行为
                       a.eat ( );
                   }
               }
      

    以猫狗类为例说明延展性代码如下

    public class Demo3_Animal {
       public static void main(String[] args) {
           //Cat3 c = new Cat3();
           //c.eat ();
           method (new Cat3 ( ));
           method (new Dog3 ( ));
           //Animal3 a = new Cat3();开发中很少这样写,父类引用子类对象没有好处,直接创建子类对象更方便可以直接使用子类中的特有方法
    
       }
    
       /*public static void method(Cat3 c){			//这样写太麻烦了
           c.eat ();
       }
       public static void method(Dog3 d){
           d.eat ();
       }*/
       public static void method(Animal3 a) {		//通常这样写,当作参数的时候这样写最好,再来一个猪类都可以只要属于动物类都行。
          //如果强制把猫类型转换成狗类型就会出现类型转化异常ClassCastException
     		 if (a instanceof Cat3) {  //缺点不能调用子类特有的方法
               Cat3 c = (Cat3) a;
               c.catchMouse ( );
               c.eat ( );
           } else if (a instanceof Dog3) {
               Dog3 d = (Dog3) a;
               a.eat ( );
               ((Dog3) a).lookHouse ( );
           } else {
               a.eat ( );
           }
       }
    }
    
    class Animal3 {
       public void eat() {
           System.out.println ("吃饭");
       }
    }
    
    class Cat3 extends Animal3 {
       public void eat() {
           System.out.println ("猫吃鱼");
       }
    
       public void catchMouse() {
           System.out.println ("抓老鼠");
       }
    }
    
    class Dog3 extends Animal3 {
       public void eat() {
           System.out.println ("狗吃肉");
       }
    
       public void lookHouse() {
           System.out.println ("狗看家");
       }
    }
    
    结果
    抓老鼠
    猫吃鱼
    狗吃肉
    看家
    
    
    
    
    展开全文
  • Java面向对象多态

    2020-07-15 09:53:43
    1.多态优点 1. 消除类型之间的耦合关系 2. 可替换性 3. 可扩充性 4. 接口性 5. 灵活性 6. 简化性 2.多态存在的三个必要条件 继承 重写 父类引用指向子类对象 当使用多态方式调用方法时,首先检查父类中...

    多态是同一个行为具有多个不同表现形式或形态的能力。

    多态就是同一个接口,使用不同的实例而执行不同操作,如图所示:

    多态性是对象多种表现形式的体现。

    1.多态的优点

    • 1. 消除类型之间的耦合关系
    • 2. 可替换性
    • 3. 可扩充性
    • 4. 接口性
    • 5. 灵活性
    • 6. 简化性

    2.多态存在的三个必要条件

    • 继承
    • 重写
    • 父类引用指向子类对象

    当使用多态方式调用方法时,首先检查父类中是否有该方法,如果没有,则编译错误;如果有,再去调用子类的同名方法。

    多态的好处:可以使程序有良好的扩展,并可以对所有类的对象进行通用处理。

    Test.java 文件代码:

    public class Test {
        public static void main(String[] args) {
          show(new Cat());  // 以 Cat 对象调用 show 方法
          show(new Dog());  // 以 Dog 对象调用 show 方法
                    
          Animal a = new Cat();  // 向上转型  
          a.eat();               // 调用的是 Cat 的 eat
          Cat c = (Cat)a;        // 向下转型  
          c.work();        // 调用的是 Cat 的 work
      }  
                
        public static void show(Animal a)  {
          a.eat();  
            // 类型判断
            if (a instanceof Cat)  {  // 猫做的事情 
                Cat c = (Cat)a;  
                c.work();  
            } else if (a instanceof Dog) { // 狗做的事情 
                Dog c = (Dog)a;  
                c.work();  
            }  
        }  
    }
     
    abstract class Animal {  
        abstract void eat();  
    }  
      
    class Cat extends Animal {  
        public void eat() {  
            System.out.println("吃鱼");  
        }  
        public void work() {  
            System.out.println("抓老鼠");  
        }  
    }  
      
    class Dog extends Animal {  
        public void eat() {  
            System.out.println("吃骨头");  
        }  
        public void work() {  
            System.out.println("看家");  
        }  
    }

    执行以上程序,输出结果为:

    吃鱼
    抓老鼠
    吃骨头
    看家
    吃鱼
    抓老鼠

     

    3.虚函数

    虚函数的存在是为了多态。

    Java 中其实没有虚函数的概念,它的普通函数就相当于 C++ 的虚函数,动态绑定是Java的默认行为。如果 Java 中不希望某个函数具有虚函数特性,可以加上 final 关键字变成非虚函数。

     

    4.多态的实现方式

    方式一:重写

    这个内容已经在上一章节详细讲过,就不再阐述,详细可访问:Java 重写(Override)与重载(Overload)

    静态方法被子类重写,要看父类引用还是子类引用指向子类对象,如果是父类引用指向子类对象,那么调静态方法时,会调用父类的静态方法,如果是子类引用指向子类对象,那么调静态方法时,会调用子类的静态方法。

    方式二:接口

    • 1. 生活中的接口最具代表性的就是插座,例如一个三接头的插头都能接在三孔插座中,因为这个是每个国家都有各自规定的接口规则,有可能到国外就不行,那是因为国外自己定义的接口类型。

    • 2. java中的接口类似于生活中的接口,就是一些方法特征的集合,但没有方法的实现。具体可以看 java接口 这一章节的内容。

    方式三:抽象类和抽象方法

    详情请看 Java抽象类 章节。

    C++ 虚函数    ==  Java 普通函数
    
    C++ 纯虚函数  ==  Java 抽象函数
    
    C++ 抽象类    ==  Java 抽象类
    
    C++ 虚基类    ==  Java 接口

    摘自:

    菜鸟教程 

    展开全文
  • 面向对象多态

    2020-12-23 21:01:36
    多态 多态,按照字面意思来解释就是多种形态。 一句话概括就是同一种事物不同的表现形态 举个栗子: 水 在常温下水是以液体的形态呈现;而在零度或者零度以下水又会被冻结以固态的形态呈现;当温度很高的时候水又会...

    多态

    多态,按照字面意思来解释就是多种形态。

    一句话概括就是同一种事物不同的表现形态

    举个栗子:

    在常温下水是以液体的形态呈现;而在零度或者零度以下水又会被冻结以固态的形态呈现;当温度很高的时候水又会被蒸发以气态的形态呈现。

    而在程序中可以通过代码描述这种关系,只需满足继承这一关系即可

    多态的定义与使用:
    父类类型 变量名 = new 子类类型();

    变量名.方法名();

    • 普通类多态定义的格式

      父类 变量名 = new 子类();

    • 抽象类多态定义的格式

      抽象类 变量名 = new 抽象类子类();

    • 接口多态定义的格式

      接口 变量名 = new 接口实现类();

    多态成员的特点

    • 多态成员变量

      当子父类中出现同名的成员变量时,多态调用该变量时:

      ​ 编译时期:参考的时引用型变量所属的类中是否有被调用的成员变量。没有,编译失败。

      ​ 运行时期:也是调用引用型变量所属的类中的成员变量。

      ​ 口诀:编译和运行都参考等号的左边,编译运行看左边。

    • 多态成员方法

      当子父类中出现同名的成员方法时,多态调用该方法时:

      ​ 编译时期:参考引用变量所属的类,如果类中没有调用的方法,编译失败。

      ​ 运行时期:参考引用变量所指的对象所属的类,运行所属类中的成员方法。

      ​ 口诀:编译看左,运行看右。

    以下演示多态成员特点:

    /**
     * Project:javaSE
     * Package:demo
     *
     * @date: 2020/12/23
     * @author: CnreCoder
     * @signature: Bug Free
     * @version: 1.8
     */
    
    /***
    * 演示多态成员的特点
    */
    public class Demo1 {
        public static void main(String[] args) {
            //创建多态对象
            Fu i = new Zi();
            //输出多态对象的成员属性
            System.out.println(i.str);
            //调用多态对象的成员方法
            i.method();
        }
    
    }
    
    /***
     * 父类
     */
    class Fu{
        /**
         * 父类成员属性
         */
        String str = "父类变量";
    
        /**
         * 父类成员方法
         */
        public void method(){
            System.out.println("父类方法");
        }
    }
    
    /***
     * 子类
     */
    class Zi extends Fu{
        /**
         * 父类成员属性
         */
        String str = "子类变量";
    
        /**
         * 父类成员方法
         */
        @Override
        public void method(){
            System.out.println("子类方法");
        }
    }
    

    多态成员特点

    多态中向上转型与向下转型

    多态的转型分为向上转型与向下转型两种:

    • 向上转型:当有子类对象赋值给一个父类引用时,便是向上转型,多态本身就是向上转型的过程。

      格式:

      //父类类型 变量名 = new 子类类型();
      Animal animal = new Animal();
      
    • 向下转型:一个已经向上转型的子类对象可以使用强制类型转换的格式,将父类引用转为子类引用,这个过程就是向下转型。如果时直接创建父类对象,是无法向下转型的

      格式:

      //子类类型 变量名 = (子类类型) 父类类型的变量;
      //变量animal实际上指向Dog对象
      Dog dog = (Dog) animal;
      

    以下演示向上向下转型

    /**
     * Project:javaSE
     * Package:demo
     *
     * @date: 2020/12/23
     * @author: CnreCoder
     * @signature: Bug Free
     * @version: 1.8
     */
    
    /***
    * 演示多态的向上向下转型
    */
    public class Demo2 {
        public static void main(String[] args) {
            //多态    旺财是动物     这里自动使用了向上转型
            Animal animal1 = new Dog();
            //输出动物的name属性
            System.out.println(animal1.name);
            //创建动物对象
            Animal animal2 = new Animal();
            //调用动物方法
            animal2.method();
            //调用旺财方法
            animal1.method();
            //向下转型
            Dog dog = (Dog) animal1;
            //输出旺财的name属性
            System.out.println(dog.name);
    
        }
    }
    
    /**
     * 父类
     */
    class Animal {
        /**
         * 父类的属性
         */
        String name = "动物";
    
        /**
         * 父类的方法
         */
        public void method() {
            System.out.println("动物的方法");
        }
    }
    
    /**
     * 子类
     */
    class Dog extends Animal {
        /**
         * 子类的属性
         */
        String name = "旺财";
    
        /**
         * 子类的方法
         */
        @Override
        public void method() {
            System.out.println("旺财的方法");
        }
    }
    

    多态的转型

    多态的优缺点

    优点:

    可以提高可维护性(多态前提所保证的),提高代码的可扩展性

    为了方便以后使用接口和抽象类时,想访问其中的成员

    缺点:

    无法直接访问子类特有的成员


    如果你学废了就   一键三连   支持支持我吧,谢谢!其他优质文章点击这里即可观看!

    展开全文
  • JAVA面向对象 多态

    2021-02-27 11:35:40
    多态:同一个引用类型,使用不同的实例而执行不同操作(父类引用指向子类对象)2:实现多态的三个要素:继承关系,子类重写父类方法,父类的引用指向子类的对象3:实现多态的俩种形式(1) 使用父类作为方法形参实现多态...

    1:什么是多态?

    多态:同一个引用类型,使用不同的实例而执行不同操作(父类引用指向子类对象)

    2:实现多态的三个要素:

    继承关系,子类重写父类方法,父类的引用指向子类的对象

    3:实现多态的俩种形式

    (1)     使用父类作为方法形参实现多态

    (eg:使用多态优化主人给宠物喂食

    public  class Master{                                                Pet  pet=new Dog();

    public void feed(Pet pet){                               Master  master=new master();

    pet.eat();     使用父类作为                      master.feed(pet);

    }           }                             方法形参                       ........     同一种操作方式,                                       )                                                                                           不同的操作对象

    在使用该形式时要注意主人类和测试类的变化,在参数位置进行添加父类。

    (2) 使用父类作为方法返回值实现多态

    eg:public class Master{

    public Pet getPet(String typeld){

    ...............}

    }

    实现思路:在Master类中进行一个方法的添加该方法就是父类后面的方法

    然后在测试类中,根据编号来进行实现

    在使用该形式时要注意父类在其返回值那块,并且没有返回值类型,在父类后

    紧跟着一个方法,在方法中会有一个定义的数据类型 以及其定义的对象,方法里则

    为自己需要进行的详细代码步骤

    4:父类到子类的转换

    从父类直接变成子类(不允许)

    向下转型(强制类型转换)Son  s=(son) f

    子类继承父类所有财产中,子类可编程父类

    向上转型(自动转换类型)F  f =new Son();

    5:instanceof运算符

    对象  instanceof  类或接口

    instanceof通常和强制类型转换结合使用

    6:父转子为不安全,子转父为安全

    7:object 类对象可以强制转换任何类型而不发生编译错误

    任何非object类型的数据都需要强制类型转换才能转换成object类型的数据

    以上说法均为错误的

    8:object 整个大类

    父类引用指向子类对象,这时父类不能调用子类独有的属性和方法,必须进行向下转型

    (强制转换)

    子类重写父类的方法不是独有的,可以用父类调用子类的重写方法

    9:一个抽象父类让一个抽象的子类继承:

    建下一个类可以是   public abstract  class  /  public class

    方法体可不重写                必须重写方法

    10:多态的优点:

    减少类中的代码量,

    提高代码的可扩展性和可维护性

    开发效率高

    11:多态:

    子类转化为父类后,main方法中调用普通方法时依旧是子类的方法

    类型转换带来的作用就是多态

    子类继承父类的所有方法但子类可以重新定义一个名字(重写)

    子类方法优先级高与父类

    展开全文
  • C++面向对象——多态

    2020-05-16 23:48:48
    虚函数和多态的基本概念 虚函数 在类的定义中,前面有virtual关键字的成员函数就是虚函数 class base { virtual int get(); }; int base::get(){ } virtual关键字只用在类定义里的函数声明中,写函数体时不用 构造...
  • Java 面向对象多态的理解 一、多态的定义 一个对象的实际类型是确定的,但可以指向引用对象的类型可以有很多(父类,有关系的类) 操作符的多态 +可以作为算数运算,也可以作为字符串连接 类的多态 父类引用...
  • 今天我们研究一下javascript面向对象中的多态 javascript 多态 在《JavaScript设计模式与开发实践》中有这么一个故事: 主人家里养了两只动物,分别是一只鸭和一只鸡,当主人向它们发出“叫”的命令时,鸭会“嘎嘎嘎...
  • java面向对象多态

    2020-12-03 21:18:13
    java面向对象多态 多态就是某一个事物,在不同的时态的不同表达,比如猫,鱼,老虎都是动物类,你去家里看的就是猫,水里看的就是鱼,动物园看的就是老虎。 多态格式: 父类 对象名=new 子类 多态的条件:1.多态的...
  • Python面向对象的三个基本特征是: 封装 继承 多态 通过研读多篇博文,发现python的多态别具一格,本文就来探讨一下python中的多态。 1. 多态 1.1 什么是多态多态就是同一类事物具有多种形态 那么什么叫同一...
  • Java之面向对象多态

    2018-05-14 23:25:05
    多态:某一事物在同一时刻,体现出来的不同状态。...必须有父类引用指向子类对象.多态中方法的特点: 成员变量:编译看左运行看左; 成员方法:编译看左运行看右; 构造方法:无论是子类还是父类都对方法进...
  • 面向对象之(多态

    2018-08-23 16:36:39
    面向对象简介。 在面向对象程序设计中,术语对象(object)基本上可以看做数据(特性)以及由一系列可以存取,操作这些数据的方法所组成的集合。使用对象替代全局变量和函数的原因可能有很多。其中对象最重要的...
  • 深度解析面向对象多态 多态的概念 多态指的是同一个方法的调用,由于对象不同可能会有不同的行为。 现实生活中,同一个方法,具体实现会完全不同。 1.多态是方法的多态,不是属性的多态(多态与属性无关)。 2.多态...
  • 面向对象多态 ———————————————— 1. 2. 3.
  • Java面向对象编程三大特征 - 多态

    千次阅读 多人点赞 2020-04-06 11:43:48
    本文关键字:Java、面向对象、三大特征、多态多态面向对象编程的三大特征之一,是面向对象思想的终极体现之一。在理解多态之前需要先掌握继承、重写、父类引用指向子类对象的相关概念。
  • 面向对象程序设计(OOP)是当今主流的程序设计范性,它取代了结构化或过程式编程技术。 一、面向对象是什么? 1、定义: 面向对象就是:把数据及对数据的操作方法放在一起,作为一个相互依存的整体——对象。对同类...
  • python 面向对象 多态

    2019-02-19 18:27:00
    什么是多态 在不考虑实例类型的情况下使用实例 例子 peo=People() dog=Dog() pig=Pig() def func(obj): obj.talk() func(pig) 鸭子类型 #如果看起来像、叫声像而且走起路来像鸭子,...
  • 面向对象是一种思想,是基于面向过程而言的,面向对象是将功能等通过对象来实现,将功能封装到对象之中,让对象实现具体的细节。这种思想是将数据作为第一位,而方法(算法)作为其次,是对数据的一种优化,操作起来...
  • 面向对象接口多态

    2019-01-22 22:49:55
    第3天 面向对象 今日内容介绍  接口  多态  笔记本案例 今日学习目标  写出定义接口的格式  写出实现接口的格式  说出接口中成员的特点  接口和抽象类的区别  能够说出使用多态的前提条件  理解...
  • Java面向对象之:多态

    2019-02-21 14:50:44
    多态优点 消除类型之间的耦合关系 可替换性 可扩充性 接口性 灵活性 简化性 多态存在的三个必要条件 继承 重写 父类引用指向子类对象 当使用多态方式调用方法时,首先检查父类中是否有该方法,如果...
  • 多态 1.多态的理解 ①....2.多态优点 ①.降低了程序之间的耦合度。 ②.提高了程序的可扩展性。 3.多态的类型 ①.编译时多态:静态的 方法重载(在编译期间调用相同的方法根据不同的形参列表区...
  • 多态 1.多态 代码执行过程中呈现的多种形式 java分为编译时期、运行时期 编译时多态---在编译时期绑定代码 体现形式—重载 public void m(){} public void m(int i)...
  • Java学习——面向对象多态 多态的概念:多态指的是某一个事物,在不同时刻表现出来的不同状态。在面向对象语言当中,其表现的是接口的不同实现方式。也就是说允许父类的引用指向子类。 举个例子: Dog dog = new ...
  • 面向对象-接口与多态

    2019-05-15 22:35:19
    面向对象-接口与多态 接口的概述 Java语言的继承是单一继承,一个子类只能有一个父类(一个儿子只能有一个亲爹) Java语言给我们提供了一种机制,用于处理继承单一的局限性,接口 接口:接口是一个比抽象类还抽象的...
  • Java面向对象多态

    2020-04-13 19:07:48
    多态的定义和多态中的相关概念 多态中涉及到的概念 向上转型:子类型-->父类型,父类型的引用指向子类型的对象,自动类型转换 向下转型:父类型-->子类型,强制类型转换 不管是向上转型还是向下转型,...
  • js:面向对象编程,带你认识封装、继承和多态

    万次阅读 多人点赞 2017-06-05 22:59:25
    周末的时候深入的了解了下javascript的面向对象编程思想,收获颇丰,感觉对面向对象编程有了那么一丢丢的了解了~很开森什么是面向对象编程 先上一张图,可以对面向对象有一个大致的了解,然而什么是面向对象呢,用...
  • 02面向对象-多态

    2021-03-30 17:18:52
    优点: 消除类型之间的耦合关系 可替换性 可扩充性 接口性 灵活性 简化性 多态存在的三个必要条件: 继承 重写 父类引用指向子类对象:Parent p = new Child(); 过程: 当使用多态方式调用方法时,首先检查父类...
  • (1) 继承是面向对象程序设计不可缺少的设计思想,是实现代码可重 用的根 基,是提高代码可扩展性的主要途径。 (2) 继承是从已有的类中派生出新的类,新的类能吸收已有类的属性和行 为, 并能扩展新的能力。 例如: ...
  • a....多态优点:简化代码,去掉繁琐 d.演示代码: package com.zhangwei.testDuotai; /***  * 多态应用。可以解决繁琐的调方法  * @author zw  *有继承关系  *必须在方法类  *必须是
  • 对于面向对象而言, 多态分为编译时多态和运行时多态。 其中编辑时多态是静态的,主要是指方法的重载,它是根据参数列表的不同来区分不同的函数,通过编辑之后会变成两个不同的函数,在运行时谈不上多态。而运行时...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 42,937
精华内容 17,174
关键字:

面向对象多态优点