精华内容
下载资源
问答
  • 多态产生条件

    2015-04-01 22:05:00
    1、要有继承 2、要有重写 3、父类引用指向子类对象 转载于:https://www.cnblogs.com/hy87/p/5982359.html

    1、要有继承

    2、要有重写

    3、父类引用指向子类对象

    转载于:https://www.cnblogs.com/hy87/p/5982359.html

    展开全文
  • Java多态实现的必要条件

    千次阅读 2020-09-30 21:17:44
    在 java 面向对象中,Java 主要采用运行时多态,实现的必要条件为(AC) A.要有继承 B.要有重载 C.要有父类引用指向子类对象(向上转型) D.要有包 重载与重写是Java 多态性的不同表现。  重写是父类与子类之间多...

    多态分两种:
    (1) 编译时多态(设计时多态):其中编辑时多态是静态的,主要是指方法的重载,它是根据参数列表的不同来区分不同的函数,通过编辑之后会变成两个不同的函数。

    (2) 运行时多态:而运行时多态是动态的,它是通过动态绑定来实现的,JAVA运行时系统根据调用该方法的实例的类型来决定选择调用哪个方法则被称为运行时多态。(我们平时说得多的是运行时多态,所以多态主要也是指运行时多态)

    运行时多态的解释:

    a.运行时多态是指程序中定义的引用变量所指向的具体类型和b.通过该引用变量发出的方法调用在编程时并不确定,而是在程序运行期间才确定,即一个引用变量倒底会指向哪个类的实例对象,该引用变量发出的方法调用到底是哪个类中实现的方法,必须在由程序运行期间才能决定.

    1.程序序中定义的引用变量所指向的具体类型不确定(即一个引用变量倒底会指向哪个类的实例对象) 。

    2.通过该引用变量发出的方法调用在编程时并不确定(该引用变量发出的方法调用到底是哪个类中实现的方法) 。

    在 java 面向对象中,Java 主要采用运行时多态,实现的必要条件为(AC)
    A.要有继承
    B.要有重载
    C.要有父类引用指向子类对象(向上转型)
    D.要有包

    重载与重写是 Java 多态性的不同表现。
      重写是父类与子类之间多态性的表现,在运行时起作用(动态多态性,譬如实现动态绑定)
      而重载是一个类中多态性的表现,在编译时起作用(静态多态性,譬如实现静态绑定)。

    多态的要点:

    1.多态是方法的多态,不是属性的多态(多态与属性无关)

    2.多态存在要有3个必要条件:继承、方法重写、父类引用指向子类对象。

    3.父类引用指向子类对象后,用该父类引用调用子类重写的方法,此时多态就出现了。

    例如 :Object cat = new Cat();

    三个必要条件:

    继承:在多态中必须存在有继承关系的子类和父类。其中继承包括了接口的实现implements
    
    重写:子类对父类中某些方法进行重新定义,在调用这些方法时就会调用子类的方法。
    
    向上转型:在多态中需要将子类的引用赋给父类对象,只有这样该引用才能够具备技能调用父类的方法和子类的方法。
    
    只有满足了上述三个条件,我们才能够在同一个继承结构中使用统一的逻辑实现代码处理不同的对象,从而达到执行不同的行为。

    关于使用使用父类引用指向子类对象:https://zhangvalue.blog.csdn.net/article/details/106269444

    public class TestAnimal {
        public static void main(String[] args) {
            Animal a = new Animal();
            animalCry(a);
    
            Dog d = new Dog();
            animalCry(d);
    
            Cat t = new Cat();
            animalCry(t);
        }
    
        //多态的关键,通过父类的引用调用子类重写的方法。
        static void animalCry(Animal a) {
            a.shout();
        }
    }
    class Animal{
        public void shout() {
            System.out.println("animal 叫了一声");
        }
    }
    
    class Dog extends Animal{
        public void shout() {
            System.out.println("dog 汪汪汪!");
        }
    }
    
    class Cat extends Animal{
        public void shout() {
            System.out.println("cat 喵喵喵!");
        }
    }

    展开全文
  • 1.多态的引入 面向对象有三大特征:封装,继承与多态。多态是面向对象的三大特征之一,指的是在不同的时刻,所表现...下面对多态产生条件作以介绍: 多态的前提 1.多态的前提是继承,没有继承,多态也就无从

    1.多态的引入

    面向对象有三大特征:封装,继承与多态。多态是面向对象的三大特征之一,指的是在不同的时刻,所表现出的不同的状态。举个简单的例子来说,动物中的猫属于猫类型,具体在创建对象时,可以通过Cat cat =new Cat()的代码来进行实现。同时猫也属于动物类型,按照此种逻辑进行推算的话,可以使用父类的引用去接受子类的对象,具体的实现是:Animal an=new Cat(),这种现象就叫做多态。


    2.多态产生的条件以及意义

    下面对多态产生的条件作以介绍:

    多态的前提
    1.多态的前提是继承,没有继承,多态也就无从谈起
    2.多态必须要有方法的重写(不重写也是可以的,但就会失去多态的意义)
    3.多态具体的代码实现是:父类的引用指向子类的对象
    public class MyTest {
        public static void main(String[] args) {
            //多态的语法:父类引用指向子类对象
            Animal animal = new Cat();
            animal.eat();
            animal.sleep();
            System.out.println("============");
            animal = new Dog();
            animal.eat();
            animal.sleep();
        }
    }
    //父类:将子类中共有的的成员进行抽取
     class Animal{
     public void eat(){
         System.out.println("吃饭");
     }
     public void sleep(){
         System.out.println("睡觉");
     }
    }
    
    //子类:猫类
    class Cat extends Animal{
        public void catchMouse(){
            System.out.println("猫抓老鼠");
        }
        //对父类中的方法进行重写
        @Override
        public void eat() {
            System.out.println("猫吃鱼");
        }
        @Override
        public void sleep() {
            System.out.println("猫喜欢躺在温暖的地方睡觉");
        }
    }
    
    //子类:狗类
    class  Dog extends Animal{
        public void lookDoor(){
            System.out.println("狗看门");
        }
    
        @Override
        public void eat() {
            System.out.println("狗吃骨头");
        }
    
        @Override
        public void sleep() {
            System.out.println("狗喜欢晚睡");
        }
    }
    
    输出的结果为:
    
    猫吃鱼
    猫喜欢躺在温暖的地方睡觉
    ============
    狗吃骨头
    狗喜欢晚睡
    
    

    多态的意义
    提高代码的复用性与维护性(靠继承可以进行保障)
    多态提高代码的扩展性

    下面的案例中体现多态提高代码的扩展性:

    public class MyTest {
        public static void main(String[] args) {
            //多态:父类的引用指向子类的对象
            Aniaml aniaml = new Cat();
            aniaml.eat();
            System.out.println("===============");
            aniaml = new Dog();
            aniaml.eat();
    
        }
    }
    //父类
    class Aniaml{
        public void eat(){
            System.out.println("吃饭");
        }
    
    }
    //子类:猫类
    class Cat extends Aniaml{
        @Override
        public void eat() {
            System.out.println("小猫吃鱼");
        }
    }
    //子类:狗类
    class  Dog extends Aniaml{
        @Override
        public void eat() {
            System.out.println("小狗吃骨头");
        }
    }
    //功能测试类
    class AniamlGongJu{
        /*多态的程序的扩展性在此有体现
         当需要再增加其他动物时,不用在此
         对程序进行增加。形参这里给的父类的
         引用,体现多态的可扩展性。
         */
        public static void test(Aniaml an){
            an.eat();
        }
    }
    
    输出的结果为:
    小猫吃鱼
    ===============
    小狗吃骨头
    

    3.多态访问成员的特点

    多态的语法为:父类的引用指向子类的对象

    多态访问成员的特点
    多态的形式来访问成员变量,编译看左边(父类),运行看左边(父类)
    多态的形式访问成员方法,如果子类有重写,编译看左边(父类),运行看右边(子类)。运行的结果以子类重写的方法为准。
    多态的形式访问静态方法,静态方法不参与方法重写,编译看左边(父类),运行看左边(父类)
    多态的语法下的构造方法,是先调用父类的构造方法,先完成父类的数据初始化
    public class MyTest {
        public static void main(String[] args) {
            //多态的语法:父类的引用指向子类对象
            Fu f = new Zi();
            //多态的形式访问成员变量,编译看父类,运行看父类
            int num=f.num;
            System.out.println(num);//100
            /*多态的形式访问成员方法,如果子类有重写,编译
              看父类,运行看子类。运行后的结果以子类的重写
              后的方法为准
             */
            f.show();//子类的show方法执行了
            //静态的方法不参与重写(直接可以用类名进行访问)
            Fu.test();
    
        }
    }
    
    class Fu{
        //父类的成员变量
        int num=100;
        //父类的构造方法
        public Fu(){
            System.out.println("父类的构造方法执行了");
        }
        public void show(){
            System.out.println("父类的show方法执行了");
        }
        public static void test(){
            System.out.println("父类的静态方法");
        }
    }
    class Zi extends Fu{
        //子类的成员变量
        int num=500;
        public Zi(){
            System.out.println("子类的构造方法执行了");
        }
    
        @Override
        public void show() {
            System.out.println("子类的show方法执行了");
        }
    }
    
    输出的结果为:
    父类的构造方法执行了
    子类的构造方法执行了
    100
    子类的show方法执行了
    父类的静态方法
    
    

    4.多态的弊端

    多态的存在提高了代码的复用性与维护性,以及提高代码的可扩展性。但多态也存在着弊端,不能访问子类中特有的功能。想要进行访问子类中特有的功能,需要进项向下转型。

    public class MyTest {
        public static void main(String[] args) {
            //多态:父类的引用指向子类的对象
            //多态就是向上转型
            Fu fu= new Zi();
            fu.show();//子类的成员方法
            //多态的弊端:就是不能直接访问子类中特有的功能
            //fu.test();
            //通过向下转型的方式:把父类引用,向下转换为子类型
            Zi zi= (Zi) fu;
            zi.test();//子类中特有的方法
    
        }
    }
    
    //父类
    class Fu{
        public void show(){
            System.out.println("父类的成员方法");
        }
    }
    //子类
    class Zi extends Fu{
        //子类重写父类中的成员方法
        @Override
        public void show() {
            System.out.println("子类的成员方法");
        }
        public void test(){
            System.out.println("子类中特有的方法");
        }
    }
    

    5.多态的题目分析题

    1.看下面的程序是否有问题,如果没有,说出结果
    public class MyTest {
        public static void main(String[] args) {
            //采用多态的方式,父类的引用指向子类对象
            Fu fu = new Zi();
            fu.show();//子类的show方法
            //多态的形式不能直接访问子类中特有的功能
            //fu.method();
            Zi zi= (Zi) fu;
            zi.method();//zi method
        }
    }
    class  Fu{
        public void show(){
            System.out.println("父类的show方法");
        }
    }
    class Zi extends Fu{
        @Override
        public void show() {
            System.out.println("子类的show方法");
        }
        public void method(){
            System.out.println("zi method");
        }
    }
    
    输出后的结果为:
    
    子类的show方法
    zi method
    
    

    2.看下面的程序是否有问题。如果没有,说出结果
    public class MyTest {
        public static void main(String[] args) {
            //多态的形式:父类引用指向子类对象
            A a = new B();
            a.show();//javase
            System.out.println("===============");
            B b = new C();
            b.show();//javaee
        }
    }
    
    class A{
        public void show(){
            show2();
        }
        public void show2(){
            System.out.println("java");
        }
    }
    class B extends A{
        public void show2(){
            System.out.println("javase");
        }
    }
    class  C extends B{
        public void show(){
            super.show();
        }
        public void show2(){
            System.out.println("javaee");
        }
    }
    
    输出的结果为:
    javase
    ===============
    javaee
    
    

    6.总结

    • 多态:一种事物,在不同的时刻所表现出的不同状态
    • 多态的前提要有继承关系,语法想表现形式为:父类引用指向子类对象
    • 多态的好处:提高代码的复用性与维护性,同时主要提高代码的扩展性
    • 多态的弊端:不能直接调用子类特有的功能,想要访问子类特有功能,可以进行向下转型的操作
    • 多态访问成员的特点:
    • 访问成员变量,编译看左边(父类),运行看左边(父类)
    • 访问成员方法,子类重写父类中的方法,编译看左边(父类),运行看右边(子类)
    • 访问静态方法,静态方法不参与方法重写,编译看左边(父类),运行看左边(父类)
    展开全文
  • 多态:同一个方法调用,由于对象不同会产生不同的行为 一个对象的实际类型是确定的,但可以指向对象的引用的类型很多 多态存在的条件: 有继承关系; 子类重写父类方法; 父类引用指向子类对象 Pig p = new ...

    多态

    多态的定义、条件及案例

    1. 多态:同一个方法调用,由于对象不同会产生不同的行为

    2. 一个对象的实际类型是确定的,但可以指向对象的引用的类型很多

    3. 多态存在的条件:

      • 有继承关系;
      • 子类重写父类方法;
      • 父类引用指向子类对象
      Pig p = new Pig();
      Animal an = p;
      //等价于Animal an = new Pig()
      //=左侧:编译器的类型
      //=右侧:运行期的类型
      
    4. 多态是方法的多态(static,final,private方法无法被重写),属性没有多态

    5. 多态的好处:多态能够提高代码的拓展性,符合面向对象的设计原则:开闭原则,即扩展是开放的,修改是关闭的。

    6. 案例

    public class Animal {//父类,动物
        //喊叫
        public void shout(){
            System.out.println("我是小动物,我可以叫");
        }
    }
    
    public class Cat extends Animal{//子类 Cat
        //喊叫
        //子类重写父类的方法
        public void shout(){
            System.out.println("我是小猫,我可以喵喵叫");
        }
    
        public void scratch(){
            System.out.println("我是小猫,我可以挠人");
        }
    }
    
    public class Dog extends Animal{//子类 Dog
        //喊叫
        public void shout(){
            System.out.println("我是小狗,我可以汪汪叫");
        }
    
        public void guard(){
            System.out.println("我是小狗,我可以看家护院");
        }
    }
    
    public class Pig extends Animal{//子类 Pig
        //喊叫
        public void shout(){
            System.out.println("我是小猪,我可以哼哼叫");
        }
    
        public void eat(){
            System.out.println("我是小猪,我喜欢吃东西");
        }
    }
    
    public class Girl {
        //跟猫玩耍
        /*public void play(Cat cat){
            cat.shout();
        }*/
        //跟狗玩耍
        /*public void play(Dog dog){
            dog.shout();
        }*/
        //跟小动物玩耍
        public void play(Animal an){
            an.shout();
        }
    }
    
    public class Test {
        //main方法,程序的入口
        public static void main(String[] args) {
            Girl g = new Girl();
            //父类的引用指向子类的类型
            Animal an = new Cat();
            g.play(an);
        }
    }
    

    多态内存分析

    两种解释

    public class Pig extends Animal{   
        double weight;
        //喊叫
        public void shout(){
            System.out.println("我是小猪,我可以哼哼叫");
        }
    
        public void eat(){
            System.out.println("我是小猪,我喜欢吃东西");
        }
    }
    
    public class Animal {//父类,动物
        int age;
        //喊叫
        public void shout(){
            System.out.println("我是小动物,我可以叫");
        }
    }
    

    在这里插入图片描述

    转型

    在这里插入图片描述


    多态的应用场合

    应用场合一:父类作为方法的形参传入方法中

    将父类作为方法的形参传入方法中,真实传入类型可以是该类的任意一个子类对象

    public class Girl {
        //跟猫玩耍
        /*public void play(Cat cat){
            cat.shout();
        }*/
        //跟狗玩耍
        /*public void play(Dog dog){
            dog.shout();
        }*/
        //跟小动物玩耍
        public void play(Animal an){
            an.shout();
        }
    }
    

    应用场合二:父类作为方法的返回值类型

    父类作为方法的返回值类型,真实返回的对象可以是该类的任意一个子类对象

    • 简单工厂模式

      它是解决大量对象创建问题的一个解决方案。将创建和使用分开,工厂负责创建,使用者直接调用即可。

    • 简单工厂模式的基本要求

      • 定义一个static方法,通过类名直接调用
      • 返回值类型是父类类型,返回的可以是其任意子类类型
      • 传入一个字符串类型的参数,工厂根据参数创建对应的子类产品
    public class PetStore {//宠物店
        //方法:提供动物
        public static Animal getAnimal(String petName){//把父类当作方法的返回值
            Animal an = null;
            switch (petName){
                case "猫":
                    an = new Cat();
                    break;
                case "狗":
                    an = new Dog();
                    break;
                case "猪":
                    an = new Pig();
                    break;
                default:
                    System.out.println("请选择合适的小动物");
            }
            return an;
        }
    }
    
    public class Test {
        //main方法,程序的入口
        public static void main(String[] args) {
            Girl g = new Girl();
            //父类的引用指向子类的类型
            Animal an = PetStore.getAnimal("狗");
            g.play(an);
        }
    }
    
    展开全文
  • 多态

    2020-12-08 16:56:36
    多态:同一种操作作用于不同的对象可以有不同的解释,产生不同的效果。 多态的好处? 面向对象的三大特征,封装可隐藏代码的实现细节,是的代码模块,编程的粒度更大。继承可以扩展代码模块,他们的目的都是为了...
  • 多态是在不同继承关系的类对象,去调用同一函数,产生了不同的行为。比如Child\Adult继承了Person。 Adult对象买票全价,Child对象买票半价。 那么在继承中要构成多态还有两个条件: 必须通过基类的指针或者引用...
  • 多态条件

    2017-03-08 15:11:04
    多态(Polymorphism)按字面的意思就是”多种状态”。在面向对象语言中,接口的多种不同的实现方式即为多态 1,继承 2,重写 3,父类的指针指向子类

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 42,481
精华内容 16,992
关键字:

多态的产生不需要条件