精华内容
下载资源
问答
  • Java中多态理解

    2019-11-17 10:25:24
    Java语言最重要的是面向对象的编程思想,而面向对象重要的就是多态多态:什么是多态,顾名思义 多态就是事物多样的形态。 多态前提 : 必须有继承关系,才可以有多态 多态意义 : 必须有子类重写父类方法 ...

                  Java语言中最重要的是面向对象的编程思想,而面向对象重要的就是多态。

     


    多态:什么是多态,顾名思义 多态就是事物多样的形态。

    多态前提 :  必须有继承关系,才可以有多态

    多态意义 :     必须有子类重写父类方法 才可以使多态有意义。 如果只是单单进行了子类继承父类  这样 多态是没有任何意义的。


    多态: 向上转型和向下转型

    向上转型:

                     父类变量引用子类对象。

                     父类变量可以去调用子类和父类共同拥有的属性和方法。

    向下转型: 

                     由于向上转型 父类变量只能调用 子类和父类共同的方法和属性,无法调用子类特有的属性和方法

                      因此  如果需要父类变量去引用子类特有的属性和方法 就需要向下转型 。 

                      注: 向下转型应当保证两边的对象相同。

                      比如:

                            Animal   animal  =  new Dog();  //向上转型

                             Cat  cat = (Cat)animal  //需要强转   

                          这就是问题所在   这只狗你可以说是一只动物    但你能说这只狗是一只猫吗? 当然不能   

                          因从向下转型应当注意。可以用instanceof

                           instanceof严格来说是Java中的一个双目运算符,用来测试一个对象是否为一个类的实例

                            

                     

     

    展开全文
  • java中多态理解

    2010-09-03 22:53:43
    代码演示对java中多态理解 从代码演示更好的理解多态的作用
  • Java多态理解

    2018-07-30 19:14:10
    **Java多态理解** - Java多态是建立在继承与接口之上的, - Java的继承跟接口给我们提供了安全向上转型。 **多态运用的原理** 1. 动态绑定(OOP的核心技术) 2. 继承与接口作支持 **使用多态时,应注意在哪些...

    **Java之多态理解**

    - Java 的多态是建立在继承与接口之上的,
    - Java的继承跟接口给我们提供了安全向上转型。

    **多态运用的原理**
    1. 动态绑定(OOP的核心技术)
    2. 继承与接口作支持

    **使用多态时,应注意在哪些地方是不起作用的**
    1. 构造器不能进行多态
    2. private 方法不能应用与多态,因为 private 方法相当于 final方法,不能被重写
    3. final 关键字修饰的方法或者类
    4. static 关键字修饰方法
    5. 变量不能应用于多态
    6. 在构造器中应少使用多态,很难查找问题出在哪个位置

    多态非常抽象,用到的技术点也很多,其中 对像的动态引用,动态绑定,转型...

    在此写出一个Demo,便于理解


    ```
    class Meal{
        Meal(){
            System.out.println("Meal()");
        }
    }

    class Bread{
        Bread(){
            System.out.println("Bread()");
        }
    }

    class Cheese{
        Cheese(){
            System.out.println("Cheese()");
        }
    }

    class Lettuce{
        Lettuce(){
            System.out.println("Lettuce()");
        }
    }

    class Lunch extends Meal{
        Lunch(){
            System.out.println("Lunch()");
        }
    }

    class PortableLunch extends Lunch{
        public PortableLunch() {
            System.out.println("PortableLunch()");
        }
    }

    public class Sandwich extends PortableLunch{
        private Bread b = new Bread();
        private Cheese c = new Cheese();
        private Lettuce ll = new Lettuce();
        public Sandwich(){
            System.out.println("Sandwich()");
        }
        
        public static void main(String[] args) {
            new Sandwich();
        }
    }
    ```
    在此给出程序的运行结果
    Meal()
    Lunch()
    PortableLunch()
    Bread()
    Cheese()
    Lettuce()
    Sandwich()

    展开全文
  • java中多态理解

    2018-08-11 21:30:04
    java中多态理解 多态性:多态性是指允许不同子类型的对象对同一消息作出不同的响应。简单的说就是用同样的对象引用调用同样的方法但是做了不同的事情。多态性分为编译时的多态性和运行时的多态性。如果将对象的...

    **

    java中多态的理解

    多态性:多态性是指允许不同子类型的对象对同一消息作出不同的响应。简单的说就是用同样的对象引用调用同样的方法但是做了不同的事情。多态性分为编译时的多态性和运行时的多态性。如果将对象的方法视为对象向外界提供的服务,那么运行时的多态性可以解释为:当A系统访问B系统提供的服务时,B系统有多种提供服务的方式,但一切对A系统来说都是透明的(就像电动剃须刀是A系统,它的供电系统是B系统,B系统可以使用电池供电或者用交流电,甚至还有可能是太阳能,A系统只会通过B类对象调用供电的方法,但并不知道供电系统的底层实现是什么,究竟通过何种方式获得了动力)。方法重载(overload)实现的是编译时的多态性(也称为前绑定),而方法重写(override)实现的是运行时的多态性(也称为后绑定)。
    运行时的多态是面向对象最精髓的东西,要实现多态需要做两件事:

    • 方法重写(子类继承父类并重写父类中已有的或抽象的方法);
    • 对象造型(用父类型引用引用子类型对象,这样同样的引用调用同样的方法就会根据子类对象的不同而表现出不同的行为)。

    java中的引用变量有两个类型:一个编译时类型,一个是运行时类型。编译时类型由声明该变量使用的类型决定,运行时类型由实际赋给该变量的对象决定。如果编译时类型与运行时类型不一致,就可能出现所谓的多态。——疯狂java讲义
    如下的sub,编译时类型为BaseClass,运行时类型为SubClass。
    BaseClass sub=new SubClass;
    如图
    **
    运行时多态的使用例子如下:

    public class PolyTest5
    {
        public void run(Car car)//这样利用公共的父类就屏蔽了子类之间的差异性,可以应对所有的车.
        {
            car.run();//只要子类继承了car都可以作为参数传入方法中.如果没有多态,就要有对应每个类的方法.非常的麻烦.
        }
    
        public static void main(String[] args)
        {
    
            PolyTest5 test = new PolyTest5();
    
            Car car = new BMW();
    
            test.run(car);
    
            QQ qq = new QQ();
    
            test.run(qq);//向上类型转换.
    
    
        }
    }
    
    class Car
    {
        public void run()
        {
            System.out.println("car is running");
        }
    }
    
    class BMW extends Car
    {
        public void run()
        {
            System.out.println("BMW is running");
        }
    }
    
    class QQ extends Car
    {
        public void run()
        {
            System.out.println("QQ is running");
        }
    }

    由于时间关系,还有一些特点没有讲详细
    参考资料:
    1. 疯狂java讲义
    2. 博文https://www.cnblogs.com/DreamDrive/p/4390164.html

    展开全文
  • Java中多态理解

    千次阅读 2018-07-26 18:59:11
    本文主要介绍Java中多态的一些特性和格式,后面附上一个实例和自己的理解多态 什么是多态 概念:同一操作作用于不同的对象,可以有不同的解释,产生不同的执行结果,这就是多态性。(可以理解为对象的多种特性) ...

    本文主要介绍Java中多态的一些特性和格式,后面附上一个实例和自己的理解。

    多态

    什么是多态

    概念:同一操作作用于不同的对象,可以有不同的解释,产生不同的执行结果,这就是多态性。(可以理解为对象的多种特性)

    多态存在的三个必要条件

    1.要有继承关系的存在(实现接口也是一种继承关系)

    2.要有方法的重写

    3.要有父类引用指向子类对象

    向上转型和向下转型

    1.对象的向上转型,其实就是多态写法:

          格式: 父类名称 对象名 = new  子类名称();

          含义:右侧创建了一个子类对象,把它当作父类来看待使用。

            Animal animal=new Cat();

                  创建了一直猫对象,当作动物看待,没有问题。

          注意事项:向上转型一定是安全的。从小范围转向了大范围,从小范围的猫,向上转换成为更大范围的动物

    2.对象的向下转型,其实就是一个还原的动作:

           格式: 子类名称 对象名 =(子类名称) 父类对象;

           含义:将子类还原,还原成为本来的子类对象

    Cat cat =(Cat) animal;//本来是猫,向上转型成为动物,还原回来成为本来的猫

    注意事项:

           a.  必须保证对象本来创建的时候就是猫,才能向下转型成为猫

           b.如果对象创建的时候不是猫,现在非要向下转型成为猫,就会报错

    instanceof关键字

    java 中的instanceof 运算符是用来在运行时指出对象是否是特定类的一个实例。instanceof通过返回一个布尔值来指出,这个对象是否是这个特定类或者是它的子类的一个实例。

    用法: 
    result = object instanceof class 
    参数: 
    Result:布尔类型。 
    Object:必选项。任意对象表达式。 
    Class:必选项。任意已定义的对象类。 
    说明: 
    如果 object 是 class 的一个实例,则 instanceof 运算符返回 true。如果 object 不是指定类的一个实例,或者 object 是 null,则返回 false。

    但是instanceof在Java的编译状态和运行状态是有区别的:

    在编译状态中,class可以是object对象的父类,自身类,子类。在这三种情况下Java编译时不会报错。

    在运行转态中,class可以是object对象的父类,自身类,不能是子类。在前两种情况下result的结果为true,最后一种为false。但是class为子类时编译不会报错。运行结果为false。

    实例应用

    题目

    /*
    分析以下需求,并用代码实现
    	1.定义动物类:
    		属性:
    			年龄
    		行为:
    			喝水,吃东西(吃什么不确定)
    	2.定义游泳接口:
    		行为:
    			游泳方法
    	3.定义狗类:
    		行为:
    			吃饭(啃骨头)和 游泳(狗刨)
    	4.定义羊类:
    		行为:
    			吃饭(羊啃草)
    	5.定义青蛙类:
    		行为:
    			吃饭(吃虫子)和 游泳(蛙泳)
    	6.定义饲养员类:
    		行为:
    			饲养动物:包括吃饭和喝水
    	7.定义测试类:
    		创建饲养员对象,饲养员调用三次饲养方法:饲养狗,饲养羊,饲养青蛙
    	要求: 
    		1.子类重写父类中的吃东西方法
    		2.要求给狗和青蛙添加游泳的方法(实现游泳接口)
    		3.饲养员类中定义一个方法,传入动物类对象(父类),
    			调用吃饭方法,如果有游泳方法也需进行测试
    		4.打印如下格式的结果:
    			喝水
    			狗啃骨头
    			狗会狗刨游泳
    
    			喝水
    			青蛙吃小虫
    			青蛙会蛙泳
    
    			喝水
    			羊啃草
     */

    动物类

    package com.heima.demo1.Work2;
    /*
    1.定义动物类:
    		属性:
    			年龄
    		行为:
    			喝水,吃东西(吃什么不确定)
     */
    public abstract class Animal {
        private int age;
        public void drink(){
            System.out.println("喝水");
        }
    
        public  abstract void eat();
    }

    游泳接口

    package com.heima.demo1.Work2;
    /*
    	2.定义游泳接口:
    		行为:
    			游泳方法
     */
    public interface Swimming {
        public abstract void swim();
    }
    

    定义狗类

    package com.heima.demo1.Work2;
    /*
    	3.定义狗类:
    		行为:
    			吃饭(啃骨头)和 游泳(狗刨)
     */
    public class Dog extends Animal implements Swimming{
        //继承Animal类,重写eat()方法,实现游泳接口,重写swim()方法
        public void eat(){
            System.out.println("狗啃骨头");
        }
    
        public  void swim(){
            System.out.println("狗会狗刨游泳");
        }
    }

    定义羊类

    package com.heima.demo1.Work2;
    /*
    	4.定义羊类:
    		行为:
    			吃饭(羊啃草)
     */
    public class Sheep extends Animal{
        //羊不会游泳,只需要继承Animal类,重写eat()方法
        public void eat(){
            System.out.println("羊吃草");
        }
    }
    

    定义青蛙类

    package com.heima.demo1.Work2;
    /*
    	5.定义青蛙类:
    		行为:
    			吃饭(吃虫子)和 游泳(蛙泳)
     */
    public class Frog extends Animal implements Swimming{
        //继承Animal类,重写eat()方法,实现游泳接口,重写swim()方法
        public void eat(){
            System.out.println("青蛙吃小虫");
        }
    
        public  void swim(){
            System.out.println("青蛙会蛙泳");
        }
    }
    

    饲养员类

    package com.heima.demo1.Work2;
    /*
    	6.定义饲养员类:
    		行为:
    			饲养动物:包括吃饭和喝水
     */
    public class Breeder {
        public void breed(Animal animal){
            //定义一个方法,接受一个Animal对象
            //使用instanceof关键字判断对象是否是这个特定类或者是它的子类的一个实例。
            if(animal instanceof Dog){
                animal.drink();
                animal.eat();
                ((Dog) animal).swim();
            }
    
            if(animal instanceof Frog){
                animal.drink();
                animal.eat();
                ((Frog) animal).swim();
            }
    
            if(animal instanceof  Sheep){
                animal.drink();
                animal.eat();
            }
        }
    }
    

    测试类

    package com.heima.demo1.Work2;
    //测试类
    public class Test02 {
        public static void main(String[] args) {
            Breeder b=new Breeder();
    
            //传入动物对象,调用饲养方法
            b.breed(new Dog());
            System.out.println();
    
            b.breed(new Frog());
            System.out.println();
    
            b.breed(new Sheep());
        }
    }
    

    测试结果

    喝水
    狗啃骨头
    狗会狗刨游泳
    
    喝水
    青蛙吃小虫
    青蛙会蛙泳
    
    喝水
    羊吃草
    
    Process finished with exit code 0

    总结

    多态简单来说就是父类引用指向子类对象,可以提高代码的灵活性和可扩展性。

    展开全文
  • java多态理解

    2018-12-17 14:10:05
    java 个人对于多态理解和一些笔记。
  • 本人在复习JavaSE的过程,发现之前对于多态理解简直不忍直视,最可怕的是最开始,被某个坑逼培训机构的老师带成了,重载和重写是Java中多态的体现。这错的离谱的概念。 Java三大特性之一之多态 这篇文章主要是...
  • java多态理解.pdf

    2021-08-09 16:39:41
    java多态理解.pdf
  • Java中多态

    千次阅读 2019-06-26 12:02:00
    目录 1、概述 2、多态的定义与使用格式 3、多态的特点 ...Java中多态的代码体现在一个子类对象(实现类对象)既可以给这个子类(实现类对象)引用变量赋值,又可以给这个子类(实现类对象)的父类(接口)变...
  • java中多态理解

    2017-10-10 19:27:27
    《疯狂java讲义》是这样理解的:Java引用变量有两个类型:一个是编译时类型,一个是运行时类型。编译时类型由声明该变量时使用的类型决定,运行时类型由实际赋给该变量的对象决定。如果编译时类型和运行时类型不...
  • Java中多态举例说明.pdf
  • java中多态实现

    2014-04-24 09:57:38
    java多态实现的课件,给那些需要的人 讲述了java多态的概念、分类、实现 综合案例讲解、总结多态的作用
  • 一、多态的定义 比如:人可以是学生,也可以是老师,也可以是军人。这就表现了人的多种形态性。多态就是多种形态。 多态的最终体现为:父类的引用变量可以指向子类对象。 多态的前提是必须有子父类关系,或者类...
  • java中多态理解

    2016-06-12 14:47:22
    多态的简单例子与理解
  • 关于java中多态理解

    2015-12-13 11:11:22
    关于java中多态理解 多态的定义:不同类型的对象对同一消息做出的不同反应;就是同一消息根据对象的不同而采取多种不同的行为方式;(发送消息指的是函数的调用)。 实现多态的技术:动态绑定,动态绑定是指在...
  • java中多态

    2016-11-03 23:38:00
    1.什么是多态  同一操作,作用于不同的对象,可以有不同的解释... 运行时多态java代码在被运行时,系统根据调用该方法的实例的类型来决定选择调用哪个方法,被称为运行时多态,体现在方法重写  ps:区分编译与运
  • 深入理解Java中多态的含义

    千次阅读 2019-05-27 21:33:37
    1.什么是多态 多态从字面上理解为,一类事物在不同的环境下以... 在 Java 及其他的编程语言多态是一种很重要的特性。它是面向对象编程 4 种特性(封装、继承、多态、抽象)其中一种。体现了面向对象编程同面...
  • 1.派生类对象的方法调用必须通过一个基类类型的变量进行 2....派生类的方法的访问说明符不能比基类有更多的限制 深入 Java 核心 Java 中多态的实现机制 多态性是面向对象程序设计代码重用的一个重要
  • Java多态理解

    2015-12-05 11:35:46
    Java中多态的概念、理解
  • Java多态理解

    2016-12-01 15:57:30
    Java多态性理解 Java中多态性的实现 什么是多态 面向对象的三大特性:封装、继承、多态。从一定角度来看,封装和继承几乎都是为多态而准备的。这是我们最后一个概念,也是最重要的知识点。多态的定义:指...
  • Java开发之多态的具体应用,包含多态应用的实例和相应实例的代码。
  • java中多态总结

    千次阅读 2019-04-27 10:21:37
    Java 多态总结 1 定义 指允许不同类的对象对同一消息做出响应。即同一消息可以根据发送对象的不同而采用多种不同的行为方式。(发送消息就是函数调用) 多态,简而言之就是同一个行为具有多个不同表现形式或...
  • 主要介绍了简单了解Java中多态,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
  • 多态Java技术具有很重要的位置,在Java面试是必问的知识点,那我们如何正确的认识和理解多态呢?多态理解所谓多态,就是指同一个行为具有多个不同表现形式或形态的能力。也可以理解为,多态是指通过指向父类的...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 210,014
精华内容 84,005
关键字:

java中的多态怎么理解

java 订阅