精华内容
下载资源
问答
  • 多态表示不同的对象可以执行相同的动作,但要通过它们自己的实现代码来执行。 例:猪、狗、猫都属于动物类,我们将动物类作为父类,猪“哼哼叫”,狗“汪汪叫”,猫“喵喵叫”,猪、狗、猫三...

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

    什么是多态?

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

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

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

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

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

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

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

    什么时候用多态?

    • 方法中的参数
        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 多态的泛型实现

    2010-10-30 16:30:38
    RTRTRTRTRT 多态的泛型实现 急需积分...
  • 多态:方法的输入参数类型是父类,运行的时候,根据传入的子类或者接口的实现类不同,产生不同的效果 叫多态。 Java 实现多态有三个必要条件:继承、重写、向上转型(父类引用指向子类对象) 在 Java 中有两种...

    多态:方法的输入参数类型是父类,运行的时候,根据传入的子类或者接口的实现类不同,产生不同的效果 叫多态。

    Java 实现多态有三个必要条件:继承、重写、向上转型(父类引用指向子类对象)

    在 Java 中有两种形式可以实现多态。继承和接口
    继承例子:

    public class Parent {
    
    
        public void printPrice(){
            System.out.println("这是父类方法");
        }
    }
    
    public class ChildA extends Parent{
        public void printPrice(){
            System.out.println("这是ChildA方法");
        }
    }
    
    public class ChildB  extends  Parent{
        public void printPrice(){
            System.out.println("这是ChildB方法");
        }
    }
    

    测试

    public class Test {
        public static void main(String[] args) {
            Parent a=new ChildA();
            Parent b=new ChildB();
            printName(b);
        }
    
    
        static void printName(Parent p){
             p.printPrice();
        }
    }
    

    接口实现多态

    public interface Parent {
      public void pringName();
      
    }
    
    public class ChildA implements Parent {
    
    	@Override
    	public void pringName() {
    		// TODO Auto-generated method stub
    		System.out.println("这是子类A");
    	}
    
    }
    
    public class ChildB implements Parent {
    
    	@Override
    	public void pringName() {
    		// TODO Auto-generated method stub
    		System.out.println("这是子类B");
    	}
    
    }
    

    测试:

    public class TestAB {
    	static void print(Parent p){
    		p.pringName();
    		
    	}
    	public static void main(String[] args) {
    		// TODO Auto-generated method stub
    		Parent a=new ChildA();
    		Parent b=new ChildB();
    		print(a);
    		print(b);
    		
    	}
    
    }
    
    展开全文
  • 主要介绍了C#中多态现象和多态实现方法,较为详细的分析了多态的原理与C#实现多态的方法,以及相关的注意事项,需要的朋友可以参考下
  • 本篇博客让我们从一个完全不懂得状态一步步了解什么多态,深入掌握多态的概念。 什么多态? 让我们看看百度是怎么定义多态的,话不多说,上图! 望文生义,第一眼看到多态,感觉就是多种...

    前言:

    今天我准备探讨一下多态的终极奥义,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,有说的不对的地方也希望大家能够指出来,谢谢!

    展开全文
  • 多态实现

    2019-11-24 20:59:16
    (一)多态 1、定义 一个函数名根据对象的不同对应有不同的实现 2、作用 ...而运行时多态是动态的,它是通过动态绑定来实现的,也就是我们所说的多态性 (二)多态实现 1、实现条件 ①静...
  • 主要介绍了 C++ 通过指针实现多态实例详解的相关资料,需要的朋友可以参考下
  • 多态的底层实现原理

    2020-05-13 16:52:40
    动态多态:派生类和虚函数实现运行时多态 1.3 静态多态和动态多态的区别: 静态多态的函数地址早绑定,在编译阶段确定函数地址 动态多态的函数地址晚绑定,在运行阶段确定函数地址 1.4 使用动态多态需满足条件 ...
  • 编程中多态就是指程序中定义的引用变量所指向的具体类型和通过该引用变量发出的方法调用在编程时并不确定,而是在程序运行期间才确定,即一个引用变量倒底会指向哪个类的实例对象,该引用变量发出的方法调用到底是...
  • 接口的多种不同的实现方式即为多态。 2.多态性是允许你将父类对象设置成为一个或更多的他的子对象相等的技术。 3.我们在程序中定义的引用变量所指向的具体类型和通过改引用变量的方法调用在编程的时候并不确定,...
  • 什么多态?如何实现?只看这一篇就够了

    千次阅读 多人点赞 2020-04-12 20:00:12
    2. 多态的定义及实现 2.1多态的构成条件 多态是在不同继承关系的类对象,去调用同一函数,产生了不同的行为。 那么在继承中要构成多态还有两个条件: 必须通过基类的指针或者引用调用虚函数 被调用的函数必须是虚...
  • Python多态的两种实现形式

    万次阅读 2020-10-27 18:25:50
    以下是Python伪代码实现Java或C的多态: class A(object): def test(self): print('A test') class B(A): def test(self): print('B test') class C(A): def test(self): print('C t
  • 什么多态实现多态的机制是什么

    千次阅读 多人点赞 2018-10-30 22:13:00
    接口的多种不同的实现方式即为多态。 多态性是允许你将父对象设置成为一个或更多的他的子对象相等的技术。 我们在程序中定义的引用变量所指向的具体类型和通过该引用变量的方法调用在编程的时候并不确定,当处于...
  • 比如有一个父类superClass,它有2个子类subClass1,subClass2。superClass有一个方法 func(),两个子类都重写了这个方法。...要想实现多态必须:1、继承。2、子类重写父类方法(成员函数)。3、要父类引用子类对象
  • C++多态三种实现方式

    千次阅读 2020-10-14 19:52:01
    多态实现方式分为三块:重载、重写、重定义。下面我们来谈一谈他们各自的实现方式和实现原理。 重载 实现方式 重载是在同一作用域内(不管是模块内还是类内,只要是在同一作用域内),具有相同函数名,不同的形参...
  • 多态: 一个事物的多种表现形态。(两个或两个以上的对象在调父类中的方法时,实现了各自的内容) 多态代码: 父类 对象 = new 子类(); //父类引用指向子类对象 子类 对象 = new 父类(); //不可以 多于多态来...
  • 多态的前提: 1.继承 2.重写 3.向上转型(这里的向上转型即父类型的引用指向子类型的实例) 二.类的加载 首先得介绍一下JVM的大体结构: 类先被加载进来。。。。。。(类的加载过程)得到class文件 class文件...
  • 1.练习:多态实现宠物店领养宠物 package duotai; import java.util.Scanner; //领养宠物 public class TestDuoTaiTest { public static void main(String[] args) { showMenu(); } //显示主菜单 ...
  • python3 多态的简单实现

    千次阅读 2020-01-10 16:14:38
    多态什么多态指的是一类事物有多种形态(一个抽象类有多个子类,因而多态的概念依赖于继承) 定义:多态是一种使用对象的方式,子类重写父类的方法,调用不同的子类对象相同的父类方法可以产生不同的执行结果 ...
  • Java多态实现机制是父类或接口定义的引用变量可以指向子类或实现类的实例对象,而程序调用的方法在运行期才动态绑定,就是引用变量所指向的具体实现对象的方法,也就是内存里正在运行的那个对象的方法,而不是引用...
  • 多态定义、多态实现、多态分类。

    千次阅读 2018-08-23 11:46:47
    2.如何实现多态:C++中的多态只能通过指向基类类型的指针和引用来调用对象的虚函数来实现实现多态有三种方式:虚方法,抽象方法,接口。   虚方法:子类重写父类中的方法,对父类中的方法进行覆盖。适用情况:...
  • 实现隐藏”则通过将细节“私有化”,把接口和实现分离开来。这种类型的组织机制对那些拥有过程化程序设计背景的人来说,更容易理解,而多态的作用则是消除类型之间的耦合关系。继承允许将对象视为他自己本身的类型...
  • 所谓多态:定义时的类型和运行时的类型不一样,此时就成为多态多态的概念是应用于Java和C#这一类强类型语言中,而Python崇尚“鸭子类型”。...Python伪代码实现Java或C#的多态 class F1(object): def show
  • 多态实现

    千次阅读 2018-10-09 08:54:05
    多态实现: (1)编译时的多态性。编译时的多态性是通过重载来实现的。对于非虚的成员来说。系统在编译时,根据传递的参数、返回的类型等信息决定实现何种操作。 (2)运行时的多态性。运行时的多态性就是直到...
  • 抽象只关注对象有哪些属性和行为,并不关注这些行为的细节是什么; 2 封装:通常认为封装是把数据和数据操作的方法绑定起来,对数据的访问只能通过已定义的接口。面向对象的本质就是将现实世界描绘成一系列完全自治...
  • C++多态实现

    2011-10-19 15:54:56
    C++多态实现,详细讲述了C++中实现多态的过程,教会怎样运用多态解决实际问题。

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 253,620
精华内容 101,448
关键字:

多态通过什么实现