精华内容
下载资源
问答
  • 什么是多态?多态有什么用途? 什么是多态?多态有什么用途? 什么是多态?多态有什么用途? 什么是多态?多态有什么用途?
  • Java多态有编译时多态和运行时多态

    千次阅读 2016-09-04 10:53:39
    多态有编译时多态和运行时多态。  第一个是通过方法重载实现;  第二个是通过方法覆盖实现(子类覆盖父类方法)。  第一种就是我们调用方法是不用区分参数类型,程序会自动执行相应方法,如:加法运算,可以使int...

      多态有编译时多态和运行时多态。

      第一个是通过方法重载实现;

      第二个是通过方法覆盖实现(子类覆盖父类方法)。

      第一种就是我们调用方法是不用区分参数类型,程序会自动执行相应方法,如:加法运算,可以使int相加,可以是double相加,都是同一个方法名。

      第二种就是动态绑定,使用父类引用指向子类对象,再调用某一父类中的方法时,不同子类会表现出不同结果。

      这样的作用就是扩展性极好,玩过网游的话应该知道游戏中有不同的角色,它们都有一个父类,它们做相同动作时表现出来的效果就会不一样,比如跑,魔法师的跑跟战士的跑就不会一样,这就是俩者都覆盖了父类中的跑方法,各自有自己的现实,表现出来多态。如果有一天你想再加个角色,只用再写一个类继承该父类,覆盖其中的跑方法就行了,其他代码不用怎么改,所以可维护性也很好。这一个小的程序或许你体会不到多态的强度作用。

      其实说到多态就是面向接口编程,它不和具体类进行挂钩了比如你没用多态的话,你没实例化一个对象,就要new一下,那假如你那天改变了需求了呢?那是不是又要改里面的?这样不好,所以你可以通过多态,把需要相似的给提出来,然后继承它这样以后需要扩展你仅仅只是继承而已。这样就...展开

      追问

      am=new Dog();

      am.roar();改为

      Dog dog=new Dog();

      dog.roar();

      这实现的功能不是一样吗?

      追答给你个例子吧!。。好好体会体会。

      假设有一个类 叫 鸟类,它拥有属性翅膀,拥有方法鸣叫,如下

      public class Bird{

      private Wing wing;

      public void moo(){

      System.out.println("鸟叫声");

      }

      }

      鸟类封装了 翅膀类和moo方法;另外有两个类都继承鸟类并重写了moo方法,分别是鹦鹉和麻雀如下:

      鹦鹉类:

      public class Parrot extends Bird{

      public void moo(){

      System.out.println("鹦鹉的叫声");

      }

      }

      麻雀类:

      public class Sparrow extends Bird{

      public void moo(){

      System.out.println("麻雀的叫声");

      }

      }

      方法重写应该懂吧,不懂自己找书看吧;然后你有个妻子她想听鸟叫,就有个妻子类

      public class Wife{

      public void listen(Bird bird){

      bird.moo();

      }

      public static void main(String[] args) {

      new Wife().listen(new Parrot());

      }

      }

      多态实现了动态绑定,让程序有了很好的扩展性,比如你以后想买一只燕子送给你妻子,就只需要写个燕子类Swallow继承Bird方法就可以了,而不需要再在妻子类里添加一个方法listen(Swallow swallow)……上面编码没用编译器,可能有错误,请谅解 说得够详细了吧,感谢世界上有我这么好的人吧 ^_^

      来自:多态

    展开全文
  • C#多态和重载有什么区别?还有多态有什么用? 老师上课讲了还是迷迷糊糊的,有没有大神用一句话概括下。
  • 使用多态有什么好处?我们将根据以上五个问题展开激烈的讨论。 什么是多态?   多态,顾名思义指“多种形态”。多态表示不同的对象可以执行相同的动作,但要通过它们自己的实现代码来执行。 例:猪、狗、猫都...

      在学习《大话设计模式》的时候经常会遇到多态,但什么是多态?为什么要使用多态?什么时候用多态?多态是如何实现的?使用多态有什么好处?我们将根据以上五个问题展开激烈的讨论。

    什么是多态?

      多态,顾名思义指“多种形态”。多态表示不同的对象可以执行相同的动作,但要通过它们自己的实现代码来执行。

    例:猪、狗、猫都属于动物类,我们将动物类作为父类,猪“哼哼叫”,狗“汪汪叫”,猫“喵喵叫”,猪、狗、猫三者都能叫,但三者都要通过重写父类的方法才能实现。

    为什么要使用多态?使用多态有什么好处?

      我们知道,封装可以隐藏实现细节,使得代码模块化;继承可以扩展已存在的代码模块(类);它们的目的都是为了——代码重用。

    代码重用,也称代码复用, 就是说你把一个功能写成一个模块, 以便再次需要相同功能的时候,可以直接使用,而不用重新开发。
    举例: 假如你的网站需要验证码, 你就可以把验证码这个功能单独提取出来以便复用。
    通常代码复用是通过类与对象来实现的, 这也是面向对象编程与面向过程编程最主要的区别之一。

      作为面向对象的三大特性之一,多态也有代码重用的功能,还有解决项目中紧耦合的问题,提高程序的可扩展性·。

    举例:添加一个子类,继承父类,重写父类的方法。至此,该程序的扩展性得到了提升,而又不需要查看源代码是如何实现的就可以扩展新功能。

    什么时候用多态?

    • 方法中的参数
        class Program
        {
            static void Main(string[] args)
            {
                Person p=new Person();
                Audi audi=new Audi();
                p.setDriver(audi);
                p.drive();
                SBenz benz=new SBenz();
                p.setDriver(benz);
                p.drive();
            }
        }
    
        public abstract class Driver
        {
            public abstract void run();
        }
    
        class SBenz : Driver
        {
            public override void run()
            {
                Console.WriteLine("大奔");
            }
        }
    
        class Audi:Driver
        {
            public override void run()
            {
                Console.WriteLine("奥迪");
            }
        }
    
        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;
            }
        }
    
    • 方法的返回类型
        public class CarFactory
        {
            public static Driver createCar(string carName)
            {
                
                if (carName.Equals("Audi"))
                {
                    return new Audi();
                }
                else if (carName.Equals("Benz"))
                {
                    return new SBenz();
                }
                else
                {
                    Console.WriteLine("出门左拐");
                    return null;
                }
            }
        }
    

    多态是如何实现的?

    • 父类是抽象类,方法是抽象方法(没有方法体,也不能实例化),子类重写父类的方法
    • 父类中是虚方法(有方法体,能实例化),子类重写父类的方法

    小结

    • 虚方法一定要有方法体(哪怕只是大括号),抽象方法一定没有方法体
    • 虚方法可以被子类重写,抽象方法必须被子类重写
    • 如果我们不需要使用父类创建对象,它的存在只是为供子类继承。可以将父类写成抽象(关键字abstract)类,将父类的方法写成抽象方法,子类中的方法仍用关键字override重写
    • 抽象类不能被实例化
    • 多态是指类可以有多种形态,通过修改可以形成多个的实现方法。当子类从父类继承时,它会获得父类的所有方法、字段、属性和事件。若要更改父类的数据和行为,通常有两种选择,第一种是在子类的访问修饰符后加new,就是隐藏了基类(父类)的方法,第二种是在子类中重写父类的方法,更换方法里的内容。

      耐心点,坚强点,总有一天,你承受过的疼痛会有助于你,生活从来不会刻意亏欠谁,它给了你一块阴影,必会在不远的地方撒下阳光。

    展开全文
  • 今天我准备探讨一下多态的终极奥义,Java也学习了两年了,但是对于多态一直不是很理解,上周刚刚来到青软实训基地,才了时间深入学习这些熟知用法而不知底层的知识。 花了一天时间来了解多态存在的意义。本篇博客...

    前言:

    今天我准备探讨一下多态的终极奥义,Java也学习了两年了,但是对于多态一直不是很理解,上周刚刚来到青软实训基地,才有了时间深入学习这些熟知用法而不知底层的知识。 花了一天时间来了解多态存在的意义。本篇博客让我们从一个完全不懂得状态一步步了解什么是多态,深入掌握多态的概念。

    什么是多态?

    让我们看看百度是怎么定义多态的,话不多说,上图!

    望文生义,第一眼看到多态,感觉就是多种形态的意思,作为Java三大特性之一,多态究竟是什么呢?

    百度已经解释的很清楚了,实际上就是字面意思,拥有多种形态的意思,多态是允许将父类对象设置成为一个或更多的他的子对象相等的技术,赋值之后,父对象就可以根据当前赋值给它的子对象的特性以不同的方式运作。

    读到这里好像明白了点,就是让父类拥有更多的属性呗!那看看代码看看是不是这个意思。

    比如父接口是超级英雄(SuperHero)

    public interface SuperHero {
        int age = 0;
        String sex = "";
        //超级英雄的移动方式
        public void move() ;
        //超级英雄的攻击方式
        public void Hit();
    }

    子类A是美国队长(CaptainAmerica)

    public class CaptainAmerica implements SuperHero{
        int age = 89;
        String sex = "男";
        @Override
        public void move(){
            System.out.println("俺是美队,俺跑的移动");
        }
        @Override
        public void Hit() {
            System.out.println("俺是美队,一锅盖悠死灭霸!");
        }
    }

    子类B是钢铁侠(IronMan)

    public class IronMan implements SuperHero{
        int age = 49;
        String sex = "男";
        @Override
        public void move() {
            System.out.println("没想到吧,我会飞,hiahiahia!~");
        }
        @Override
        public void Hit() {
            System.out.println("我是铁男,兄弟,全是高科技,neng死灭霸!");
        }
    }

    然后在main方法中按照多态的定义生成对象:

        public static void main(String[] args) {
            SuperHero superHero = new CaptainAmerica();
            superHero.move();
            superHero.Hit();
            System.out.println(((CaptainAmerica) superHero).sex);
            System.out.println(((CaptainAmerica) superHero).age);
            System.out.println("--------我是华丽的分割线---------");
            superHero = new IronMan();
            superHero.move();
            superHero.Hit();
            System.out.println(((IronMan) superHero).sex);
            System.out.println(((IronMan) superHero).age);
        }

    打印结果:

    俺是美队,俺跑的移动
    俺是美队,一锅盖悠死灭霸!
    男
    89
    --------我是华丽的分割线---------
    没想到吧,我会飞,hiahiahia!~
    我是铁男,兄弟,全是高科技,neng死灭霸!
    男
    49

    嗯,原来这就是多态,so easy,可是短暂的兴奋过后,我突然意识到了一个问题,如果从技术角度去实现的话,我直接用子类去引用子类的对象完全OK啊,无论是从效率还是结果,都完全一样,那么多态有个P用?

    具体实现如下:

        public static void main(String[] args) {
            CaptainAmerica captainAmerica = new CaptainAmerica();
            captainAmerica.move();
            captainAmerica.Hit();
            System.out.println(captainAmerica.sex);
            System.out.println(captainAmerica.age);
            System.out.println("--------我是华丽的分割线---------");
            IronMan ironMan = new IronMan();
            ironMan.move();
            ironMan.Hit();
            System.out.println(ironMan.sex);
            System.out.println(ironMan.age);
        }

    结果如下:

    俺是美队,俺跑的移动
    俺是美队,一锅盖悠死灭霸!
    男
    89
    --------我是华丽的分割线---------
    没想到吧,我会飞,hiahiahia!~
    我是铁男,兄弟,全是高科技,neng死灭霸!
    男
    49

    结果完全相同,而且从代码量上看,后者反而更少一些,那么多态的存在岂不是太显鸡肋?

    后来经过网上的查找,终于找到了多态的终极奥义:

    多态性:发送消息给某个对象,让该对象自行决定响应何种行为。
    通过将子类对象引用赋值给超类对象引用变量来实现动态方法调用。

    java 的这种机制遵循一个原则:当超类对象引用变量引用子类对象时,被引用对象的类型而不是引用变量的类型决定了调用谁的成员方法,但是这个被调用的方法必须是在超类中定义过的,也就是说被子类覆盖的方法。

    摘自百度知道-https://zhidao.baidu.com/question/101623530.html

    说白了,假设你站在开发者的角度去思考而不是一个苦b的程序猿角度,我要你设计一个漫威英雄生产器,但是用户有不同的需求,有的喜欢钢铁侠,有的喜欢美队,有的都喜欢。所以你应该设计一个接口,里面包含超级英雄的通性,再写出不同的实现类,用户有不同需要的时候,直接从你这个漫威英雄生产器中去找到自己喜欢的英雄,这样会很省事,如果没有这个漫威英雄生产器,你每个超级英雄所有的属性和方法必须自己再一个一个写,虽然也可以,但是很不方便。有了这个通用的接口,什么样的英雄都可以通过给不同的实例化对象让其去引用对象去实现。不知道大家有没有玩儿过红外线灯,通过替换前面不同的灯头,可以射出不同的图案,道理差不多,不安灯头也可以亮,但是没有图案,想要不同的图案只需安装对应的灯头即可,很方便。但是如果没有灯头,你就需要生产拥有不同图案的红外线灯,虽然也能达到射出不同图案的效果,但是要花更多的钱而且麻烦。漫威英雄生产器就相当于这个红外线灯,通过new不同的漫威英雄,以达到射出不同图案的效果,new IronMan();那么就是射出钢铁侠的图案,new CaptainAmerica();就可以射出美队的图案,但是他们都是在漫威英雄这个灯上面,归根到底还是一个红外线灯,但是你每次需要新的漫威英雄,就赋值给对应的类,例如:IronMan ironman = new IronMan(); CaptainAmerica captainAmerica = new CaptainAmerica(); 就相当于又生产了两个红外线灯,试想如果需要更多的超级英雄呢?每个都需要重新生产红外线灯?那不是很麻烦么?

    如果还有疑惑请加我QQ继续探讨~1169213632,有说的不对的地方也希望大家能够指出来,谢谢!

    展开全文
  • 同一操作作用于不同的对象,可以不同的解释,产生不同的执行结果,这就是多态性。简单的说:就是用基类的引用指向子类的对象。 为什么用多态? "封装"通过合并特征和行为来创建新的数据类型。“实现隐藏”则通过将...

    什么是多态?

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

    为什么用多态?

    "封装"通过合并特征和行为来创建新的数据类型。“实现隐藏”则通过将细节“私有化”,把接口和实现分离开来。这种类型的组织机制对那些拥有过程化程序设计背景的人来说,更容易理解,而多态的作用则是消除类型之间的耦合关系。继承允许将对象视为他自己本身的类型或其基本类型来加以处理。多态方法允许一种类型表现出于其他类型之间的区别,只要他们都是从同一基类导出即可,这种区别是根据方法行为的不同而表现出来的,虽然这些 方法都可以通过同一个基类来调用。

    多态的应用:

    1. 转型。即只要用一个基类的引用指向子类对象时,该对象会自动提升到基类的类型。
    2. 动态绑定,也就是说在如果一个派生类上升到基类之后,当调用基类中的方法时,如果该方法在派生类中被重写了,默认会调用派生类中的重写方法。
    class Cycle {
    	private String name = "Cycle";
    
    	public static void travel(Cycle c) {
    		System.out.println("Cycle.ride()" + c);
    	}
    
    	public String toString() {
    		return this.name;
    	}
    }
    
    class Unicycle extends Cycle {
    	private String name = "Unicycle";
    	public String toString() {
    		return this.name;
    	}
    }
    
    class Bicycle extends Cycle {
    	private String name = "Bicycle";
    	public String toString() {
    		return this.name;
    	}
    }
    
    class Tricycle extends Cycle {
    	private String name = "Tricycle";
    	public String toString() {
    		return this.name;
    	}
    }
    
    public class Demo1 {
    	
    	public static void ride(Cycle c) {
    		c.travel(c);
    	}
    	public static void main(String[] args) {
    		Unicycle unicycle = new Unicycle();
    		Bicycle bicycle = new Bicycle();
    		Tricycle tricycle = new Tricycle();
    		ride(unicycle);
    		ride(bicycle);
    		ride(tricycle);
    	}
    }

     

    展开全文
  • 什么是多态多态顾名思义多种状态,在python中,不同的对象调用同一个接口,表现出不同的状态,称为多态。 class Duck(): def who(self): print("I am a duck") class Dog(): def who(self): print("I am a ...
  • 到底多态有多难

    2016-10-31 14:24:02
    多态简单来说就是一种事物具有多种形式或者形态的特征,好比我们生活中最简单的事物,就像每天都会用到的水,水三态,即固态、液态和气态。生活中这种多多态的例子很多,同样在我们C++的学习过程中,多态也是一种...
  • 多态的特点,该怎么使用。多态是用于解决什么问题的呢? 寻找答案,寻找答案,
  • java多态有两种情况:重载和覆写 在覆写中,运用的是动态单分配,是根据new的类型确定对象,从而确定调用的方法; 在重载中,运用的是静态多分派,即根据静态类型确定对象,因此不是根据new的类型确定调用的...
  • 这个就是理解错误了,多态的表现形式远远不止重写方法。 多态可以分为变量的多态,方法的多态和类的多态 变量的多态的表现形式是泛型(Generic),方法的多态就是我现在理解的多态(包括override and overload) 类...
  • 继承是子类获得父类的成员,重写是继承后重新实现父类的方法。重载是在一个类里一系列参数不同名字相同的方法。多态则是为了避免在父类里大量重载引起代码臃肿且难于维护。
  • ![图片说明](https://img-ask.csdn.net/upload/201602/25/1456370818_784322.png)
  • 跟汤老师学Java笔记:总结多态 完成:第一遍 1.实现多态的条件是什么? (1).继承的存在(继承是多态的基础,没有继承就没有多态) (2).子类重写父类的方法(多态下调用的是子类重写后的方法) 父类引用变量指向子类...
  • 什么是多态?它的作用?这两个问题我以前在看Think in Java的时候遇到过,但是已经淡忘了,重温一下。 什么是多态? 其实可以理解为“动态绑定”,它的含义就是在运行时根据对象的类型进行绑定。这是一种机制,...
  • C++多态方式: (1)静态多态(重载,模板) 是在编译的时候,就确定调用函数的类型。 (2)动态多态(覆盖,虚函数实现) 在运行的时候,才确定调用的是哪个函数,动态绑定。运行基类指针指向派生类的对象,并...
  • 继承和多态有何区别

    千次阅读 2013-04-07 15:43:41
    在OOD和OOP中,多态组合优于继承,多态的基础是继承,没有继承,多态就无从谈起。 1、当对象的类型不影响类中的行为时,就要使用模板来生成这样的一组类 2、当对象的类型影响类中的行为时,就要使用继承来生成这样...
  • 【超经典】Java多态有什么好处?怎样用?

    万次阅读 多人点赞 2015-10-06 23:05:01
    多态的表现形式方法重载,方法改写,多态变量和泛型。重载是一种静态的多态性,在程序编译时确定被调用的方法,称为早绑定。而多态变量和改写相结合之后,方法的调用在运行时才能确定,是动态的多态性,称为晚绑定...
  • C++学习--多态有哪几种方式?

    千次阅读 2018-06-23 08:14:34
    (2)动态多态(覆盖,虚函数实现)在运行的时候,才确定调用的是哪个函数,动态绑定。运行基类指针指向派生类的对象,并调用派生类的函数。虚函数实现原理:虚函数表和虚函数指针。纯虚函数: virtual int fun() = ...
  • 多态

    2021-02-18 11:21:27
    使用多态有三个要素: 1.编写具有继承关系的父类和子类 2.子类重写父类方法 3.使用父类的引用指向子类的对象(向上转型) 实现多态的两种形式: 1.使用父类作为方法形参实现多态 2.使用父类作为方法返回值实现多态 ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 347,259
精华内容 138,903
关键字:

多态有