精华内容
下载资源
问答
  • 2022-01-23 14:26:48

    多态的基础语法
        
        1、向上转型和向下转型的概念。

            向上转型:子--->父 (upcasting)
                又被称为自动类型转换:Animal a = new Cat();

            向下转型:父--->子 (downcasting)
                又被称为强制类型转换:Cat c = (Cat)a; 需要添加强制类型转换符。
                什么时候需要向下转型?
                    需要调用或者执行子类对象中特有的方法。
                    必须进行向下转型,才可以调用。
                向下转型有风险吗?
                    容易出现ClassCastException(类型转换异常)
                怎么避免这个风险?
                    instanceof运算符,可以在程序运行阶段动态的判断某个引用指向的对象
                    是否为某一种类型。
                    养成好习惯,向下转型之前一定要使用instanceof运算符进行判断。
            
            不管是向上转型还是向下转型,首先他们之间必须有继承关系,这样编译器就不会报错。

        2、什么是多态。
            多种形态,多种状态,编译和运行有两个不同的状态。
            编译期叫做静态绑定。
            运行期叫做动态绑定。
            Animal a = new Cat();
            // 编译的时候编译器发现a的类型是Animal,所以编译器会去Animal类中找move()方法
            // 找到了,绑定,编译通过。但是运行的时候和底层堆内存当中的实际对象有关
            // 真正执行的时候会自动调用“堆内存中真实对象”的相关方法。
            a.move();

            多态的典型代码:父类型的引用指向子类型的对象。(java中允许这样写代码!!!)

        3、什么时候必须进行向下转型?
            调用子类对象上特有的方法时。

    更多相关内容
  • 对java多态作用的理解

    2020-08-10 11:15:19
    多态的理解 先引用某位博主的原话,再对以下话的理解:原文链接 看Java核心技术这本书时,多态的内容讲解的很少,只是举个例子告诉我们怎样使用多态,而没有明确说明为什么使用多态的问题。 谈到面向对象的编程...

    对多态的理解


    先引用某位博主的原话,再对以下话的理解原文链接
    看Java核心技术这本书时,多态的内容讲解的很少,只是举个例子告诉我们怎样使用多态,而没有明确说明为什么使用多态的问题。

    谈到面向对象的编程语言时不可避免的就会介绍继承,子类可以继承父类除private外的成员变量和方法,并且可以添加自己的成员变量与方法,以实现自己独特的功能。

    但是如果在实际的开发中发现某个类的方法可以做出某些改进,但由于工程已经交付给用户使用,就不想增加不必要的麻烦!但以后再次创建该类的对象时就需要改进过来。

    同时又不影响程序其他部分对该方法的调用。也就是说,如果再次创建该类的对象是不能做出改进的,应该由该类产生一个子类,并且子类将重写需要改进的方法,由于程

    序中其他地方需要调用该方法,所以对象的类型如果被创建成子类的类型的话将不能被有效调用,这就需要用到向上转换了即创建一个子类对象但是将其类型转换为父类的

    类型。这样做之后,程序的其他地方调用它时就能正确调用了,而且相应的方法也得到了改进。

    由上可知:多态的存在有3个条件,1)要有继承 2)要有重写3)父类引用指向子类对象

    个人理解
    打个比方有一个类A,在类B中得到引用,在类C中也得到引用

    class A {
    	public void go(){
    		System.out.println("我要打篮球")
    	}
    }
    class B {
    	public  void UseA(A a){
    		a.go()
    	}
    }
    class C {
    	public void UseA(A a){
    		a.go()
    	}
    }
    

    现在我想改一下A类中的go方法,但是根据七大设计原则,直接对A修改会违反开闭原则,所以我们最好写一个子类去继承A

    class AChild extends A {
    	@override
    	public void go(){
    		System.out.println("我要打乒乓球")
    	}
    } 
    

    假如没有多态,那我们想用A的子类AChild,那就必须在B和C中把引用类型修改成AChild,也就是说要把B、C类里面的UseA类修改,那就违背了开闭原则。所以有了多态以后,我们只要创建一个需要修改的类的子类,以其父类作为引用类型,子类作为引用对象,就可以在修改想要修改的方法的同时又不影响其他类对该类的引用。

    不知道我这样理解对不对,还请大佬们指出。

    展开全文
  • JAVA多态的概述及作用 战神三考:Why、What、How 1、为何用多态? 2、多态是什么? 3、多态怎么用? 1、为什么要用多态 1)提高了代码的维护性 (通过继承和实现来保证) 2)提高了代码的扩展性 (通过多态来保证) 3)...

    JAVA多态

    战神三考:Why、What、How
    1、为何用多态?
    2、多态是什么?
    3、多态怎么用?

    1、为什么要用多态

    	1)提高了代码的维护性 (通过继承和实现来保证)
    	2)提高了代码的扩展性 (通过多态来保证)
    	3)降低代码耦合度 
    

    2、多态基本概念

    	1.多态是继封装、继承之后,面向对象的第三大特性。
    
    	2.多态的理解:
    	现实事物经常会体现出多种形态,比如老虎,是一种猫科动物,蛇是一种冷血动物,
    	但老虎和蛇都是属于动物,也分别属于自己动物类别,当然猫科动物属类中还有很
    	多种,即动物在这里表现出了多种形态。                                                                                                            
    
    	Java作为面向对象的语言,同样可以描述一个事物的多种形态。
    	如Snake类继承了Animal类,一个Snake的对象便既是Snake,又是Animal。
    
    	3.多态体现为父类引用变量可以指向具体的子类对象。
    
    	4.前提条件:必须有父子继承关系或者实现关系。
    
    	注意:在使用多态后的父类引用变量调用方法时,会调用子类重写后的方法。
    
    	5.多态的定义与使用格式
    
    	定义格式:父类类型 变量名 = new 子类类型();
    
    	6.理解:
    
    	多态是同一个行为具有多个不同表现形式或形态的能力。
    
    	多态就是同一个接口,使用不同的实例而执行不同操作。
    

    3、多态怎么用

    3.1、多态中的成员特点

    // 上代码
    public class Animal {
        public String name = "animal";
    
    	@Override
        public void eat(){
            System.out.println("动物吃东西!");
        }
    }
    
    public class Tiger extends Animal {
        public String name = "tiger";
    
        @Override
        public void eat() {
            System.out.println("虎吃鸡!");
        }
        
        public void run() {
    		System.out.println("虎奔跑!");
    	}
    }
    
    public class Snake extends Animal {
        public String name = "snake";
        
        @Override
        public void eat() {
            System.out.println("蛇吞象!");
        }
    
    	public void run() {
    		System.out.println("蛇爬行!");
    	}
    }
    
    	1.多态成员变量:编译检查的时候检查Animal类中是否有此变量定义
    		Animal tiger = new Tiger(); 
    
    		System.out.println("name = " + tiger.name); // name 是Animal中的值,编译期只能取到父中的值
    	上述打印输出结果为: name = Animal
    
    	2.使用多态调用成员方法:编译时检查左边类型,运行时实际调用右边对象
    
        	Animal snake = new Snake();
    
        	System.out.println(sanke.eat()); // snake 的门面类型是 Animal,
        	
        但实际类型是Snake, 所以运行时调用的是Snake中重写后的方法。打印输出结果为: 蛇吞象!
    

    3.2、多态的转型和instanceof关键字

    	多态的转型分为向上转型和向下转型两种
    	向上转型:多态本身就是向上转型过的过程
        使用格式:父类类型 变量名=new 子类类型();
    
        适用场景:当不需要面对子类类型时,通过提高扩展性,或者使用父类的功能就能完成相应的操作。
    	
    	Amimal tiger = new Tiger();
    	
    	tiger.run(); // 这样写会报错,因为编译检查tiger是Animal类型,Animal中没有run方法。
    	
    	((Snake)tiger).run(); // 此时编译检查能通过,但是运行时会报错,因为tiger实际类型是Tiger类型,
    	此时强制类型转换成Snake,编译时检测tiger是Animal类型,Snake也是Animal的子类,所以
    	编译时无法发现老虎不能转化为蛇类型。
    
    	if (tiger instanceof Tiger) {
    		((Tiger) tiger).run() // 此时经过instanceof判断后才能进行强制类型转换,编译和运行时均能通过。
    	}
    
    	作用:用来判断某个对象是否属于某种数据类型。
    

    3.3、多态案例

    // 上代码
    public class Keeper {
        public void feed(Animal animal){
            animal.eat();
        }
    }
    
    public class Test {
        public static void main(String[] args) {
            Keeper GodXiu = new Keeper();
    
            Animal snake = new Snake();
    
            Animal tiger = new Tiger();
            GodXiu.feed(snake);
            GodXiu.feed(tiger);
        }
    }
    

    上述案例中输出打印结果:
    蛇吞象!
    虎吃鸡!

    4、个人思考总结

    	目前在日常开发中经常使用多态的地方就是使用集合的时候:
    
    		List list = new ArrayList();
            Map map = new HashMap();
    
    	今天的个人理解和分享就到这了,后续有新的感悟会继续补充更新!
    
    展开全文
  • 多态作用

    千次阅读 2019-04-30 09:07:54
    概念:同一操作作用于不同的对象,可以有不同的解释,产生不同的执行结果,这就是多态性。简单的说:就是用基类的引用指向子类的对象。 为什么要用多态呢? 原因:我们知道,封装可以隐藏实现细节,使得代码模块...

    什么是多态?

    概念:同一操作作用于不同的对象,可以有不同的解释,产生不同的执行结果,这就是多态性。简单的说:就是用基类的引用指向子类的对象。

     

    为什么要用多态呢?

    原因:我们知道,封装可以隐藏实现细节,使得代码模块化;继承可以扩展已存在的代码模块(类);它们的目的都是为了——代码重用。而多态除了代码的复用性外,还可以解决项目中紧偶合的问题,提高程序的可扩展性.。耦合度讲的是模块模块之间,代码代码之间的关联度,通过对系统的分析把他分解成一个一个子模块,子模块提供稳定的接口,达到降低系统耦合度的的目的,模块模块之间尽量使用模块接口访问,而不是随意引用其他模块的成员变量。

     

    多态有什么好处?

    有两个好处:

    1. 应用程序不必为每一个派生类编写功能调用,只需要对抽象基类进行处理即可。大大提高程序的可复用性。//继承 
    2. 派生类的功能可以被基类的方法或引用变量所调用,这叫向后兼容,可以提高可扩充性和可维护性。 //多态的真正作用,

     

    多态在什么地方用?

    可以用在方法的参数中和方法的返回类型中。

    在方法中的参数,请看下面的例子:

    public abstract class Driver
        {
            public void run();//让子类来运行
        }
    
    
    class SBenz : Driver
        {
            public void run()
            {
                Console.WriteLine("Benz在以200迈的速度在run");
            }
        }
    
    
    
    
     class JD : Driver
        {
            public void run()
            {
                Console.WriteLine("JD is running...");
            }
        }
    
    
     class Person
        {
            private Driver driver;
            public Person()
            {
    
            }
            public Person(Driver driver)
            {
                this.driver = driver;
            }
            public void drive()
            {
                driver.run();
            }
            public void setDriver(Driver driver)
            {//运用参数多态,以后不管买什么车都可以
                this.driver = driver;
            }
       }
    
    
    
    
    static void Main(string[] args)
            {
                Person p = new Person();
                JD jd = new JD();//刚开始没钱就买辆JD吧
                p.setDriver(jd);
                p.drive();
                SBenz benz = new SBenz();//有钱换车了
                p.setDriver(benz);
                p.drive();
            }

    在方法的返回类型中,请看下面的例子:

    上面的例子中,不管是JD还是Benz都是我们自己直接new出来的.我们可以设计一个工厂类,专门生成汽车

    /**
    *   我们将多态使用在方法的返回类型中
    *   Driver可以是抽象类,也可以是接口,JD和Benz分别继承该类或实现该借口

    */

    public class CarFactory
        {
            public Driver factory(String carName)
            {
                if (carName.Equals("JD"))
                {
                    return new JD();
                }
    
                else if (carName.Equals("Benz"))
                {
                    return new SBenz();
                }
    
                else
                {
                    Console.WriteLine("对比起,不伺候");
                    return null;
                }
            }
        }

    这实际上就是设计模式中的简单工厂模式!

    类型的参数.,传入参数的时候,可以传入任何一个类的对象,只要是对应的类的对象名称就可以了
    这就是多态的应用!

    展开全文
  • 看了大量的资料和视频之后,我终于搞清了多态作用了,废话不多说,直接上干货! 多态的好处: 1.提高了代码的可维护性 2.提高了代码的扩展性 多态作用: 可以当做形式参数,可以接受任意子类对象 多态...
  • C++多态的好处和作用(用实例说话) 在面向对象的程序设计中,使用多态能够增强程序的可扩充性,即程序需要修改或增加功能时,只需改动或增加较少的代码。此外,使用多态也能起到精简代码的作用。本节通过两个实例来...
  • Java中运行时的多态的含义及其作用 1.多态含义 同种类的多个对象,在接收到同一个消息时却产生了不同的反应和效果。 2.运行时多态的含义 使用父类引用指向子类对象,再调用某一父类中的方法时,不同的子类会表现出...
  • 计算机代码的可扩充性和可维护性指的是? 多态作用如何理解?
  • 多态的定义和作用

    万次阅读 2018-03-25 00:08:40
    1多态(polymorphism)...2多态作用 1不必编写每一子类的功能调用,可以直接把不同子类当父类看,屏蔽子类间的差异,提高代码的通用率/复用率 2父类引用可以调用不同子类的功能,提高了代码的扩充性和可维护性...
  • 封装、继承、多态的定义和作用

    千次阅读 2021-08-11 08:40:58
    作用: 尽可能地隐藏对象的内部实现细节、控制用户对类的修改和访问权限(体现:private属性)。 提到代码的可维护性。 可进行数据检查、有利于保证对象信息的完整性。 继承 定义:继承就是由已经存在的类创建...
  • 多态是面向对象的重要特性,简单点说:“一个接口,多种实现”,就是同一种事物表现出的多种形态。 编程其实就是一个将具体世界进行抽象化的过程,多态就是抽象化的一种体现,把一系列具体事物的共同点抽象出来, 再...
  • C#多态详解

    2021-10-13 21:15:26
    定义 why? what? How? 实现多态的两个要素 案例 使用多态的好处 String类
  • java封装 继承 多态 的概念和作用

    千次阅读 2019-12-01 14:46:43
    二:作用 封装: 1 : 提高了代码的复用性 2 : 提高了代码的安全性 继承: 1 : 提高了代码的复用性 2 : 提高了代码的安全性 多态: 提高了代码的灵活性 提高了代码的耦合性(配合反射)
  • C#中 多态作用

    千次阅读 2016-06-09 09:00:29
    How to use Polymorphism, Upcasting, and Downcasting to create powerful and dynamic functionality ...如何使用多态,向上转型和向下转换创建继承的类之间的强大和动态功能 public new void Chop() {
  • 系列文章目录 C语言–面向对象编程之封装 C语言–面向对象编程之继承 文章目录系列文章目录前言一、多态是什么?...在C++中有一个叫做重载的功能,作用类似,比如下面的函数。 看例子: /*函数重载*/ in
  • C++ 什么是多态多态的用途

    千次阅读 2018-02-17 23:29:52
     *多态与非多态的实质区别就是函数地址是早绑定还是晚绑定。  *如果函数的调用,在编译器编译期间就可以确定函数的调用地址,并生产代码,是静态的,就是说地址是早绑定的。  *而如果函数调用的地址不能在...
  • 多态的理解以及作用

    2022-05-27 14:47:40
    一、多态是什么   多态在面向对象中的定义:指为不同数据类型的实体提供统一的接口。   比如有动物(Animal)之类别(Class),而且由动物继承出类别鸡(Chicken)和类别狗(Dog),并对同一源自类别动物(父类...
  • Java中的封装,继承和多态(详解)

    千次阅读 多人点赞 2021-05-21 22:07:08
    目录 封装 继承 多态 接口 一些建议和小结 写在最后的话 封装 所谓的封装就是把类的属性和方法使用private修饰,不允许类的调用者直接访问,我们定义如下一个类,可以看到所有的成员变量和成员方法都使用private修饰...
  • 1.多态的含义 什么是多态,就是一个事物有多种形态,比如说是老师是老师,他也是人,也是丈夫或者妻子,或者光棍儿,这就阐述了多种形态。
  • 多态多态的好处(扩展性)

    万次阅读 多人点赞 2018-08-14 09:41:51
    多态 1、多态:同一个对象,在不同时刻体现出来的不同状态。 2、多态的前提:1)要有继承关系;2)要有方法重写;3)要有父类引用指向子类`Fu f= new Zi(); 例如,动物 d= new 狗( ),形参实参形式的(形参父类...
  • Java 中多态的好处

    千次阅读 2022-03-28 17:46:22
    多态的好处: * 1)提高了代码的复用性(由继承保证) * 2)提高了代码的扩展性(由多态来保证) //动物类 class Animal{ public void eat() { System.out.println("动物需要吃饭"); } public void sleep() {...
  • java多态及其作用

    2018-01-16 16:01:30
    多态 多态:一个对象具备多种形态。(父类的引用类型变量指向了子类的对象)或者是接口 的引用类型变量指向了接口实现类的对象) 多态的前提:必须存在继承或者实现 关系。 动物 a = new 狗(); ...
  • 多态的好处 1,能使继承基类的子类重写(覆盖)基类定义的相同函数名字和参数的虚函数接口,使子类对象更符合自己的要求或特征 一个简单粗暴的比喻就是 假设人是基类,派生出了子类男人和女人. 则子类男人和女人拥有...
  • 封装,继承,多态作用

    千次阅读 2013-08-18 09:13:34
    封装可以使得代码模块化, 继承可以扩展已存在的代码,他们的目的都是为了...而多态的目的则是为了接口重用。也就是说,不论传递过来的究竟是那个类的对象,函数都能够通过同一个接口调用到适应各自对象的实现方法。
  • 在继承中,常常用到多态多态作用是什么啊,对于直接书写 之间的好处有那些啊?
  • 面向对象编程有三大特性:封装、继承、多态。封装隐藏了类的内部实现机制,可以在不影响使用的情况下改变类的内部结构,同时也保护了数据。对外界而已它的内部细节是隐藏的,暴露给外界的只是它的访问方法。继承是...
  • 多态作用? 虚函数的作用? 实现多态。(预留:虚函数的实现原理) 多态是什么? “一个接口,多种表现/实现”,多态性是提供一种技术,这种技术允许将父类指针或引用赋值为子类的指针或引用,进行这种赋值之后,...
  • 多态概括以及其作用

    2019-04-26 20:33:35
    多态前提 a. 要有继承关系 b. 要有方法的重写 c. 要有父类引用指向子类对象 多态的好处 提高了代码的维护性 提高了代码的扩展性 多态的坏处 不能使用子类的特有属性 多态的形式 Father f = new Son(); 示例代码...
  • 深入理解c#多态

    2020-12-17 11:25:18
     多态:即一个接口,多个功能  同一种操作作用于不同的对象,可以有不同的解释,产生不同的执行结果  多态性可以是静态的或动态的。在静态多态性中,函数的响应是在编译时发生的。在动态多态性中,函数的响应是在...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 150,456
精华内容 60,182
关键字:

多态作用