精华内容
下载资源
问答
  • 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

    说明:仅供学习使用,请勿用于非法用途,若有侵权,请联系博主删除

    作者:zhu6201976

    博客:https://blog.csdn.net/zhu6201976

    一、Python多态

    1.对象多态

    对象多态:在继承体系中,定义时的类型和运行时的类型不一样,此时就构成多态

    以下是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 test')
    
    
    def go(a):
        """
        接收A类或其子类实例
        :param a:
        :return:
        """
        a.test()
    
    
    if __name__ == '__main__':
        go(A())
        go(B())
        go(C())

    执行结果:

    由此可见,go函数接收A类或其子类对象,无论是传递A类对象、B类对象、C类对象,方法都可以正常执行, 此时便构成了对象的多态。

    2.类多态

    类多态:指通过@classmethod形式多态地构造对象,而不是使用Python默认的__init__构造器

    需求:实现一套MapReduce流程,用于统计目录下所有文件的总行数,代码如下:

    """
    知识要点:
        1.接口 抽象 继承
        2.生成器
        3.map reduce
        4.多线程
        5.通过@classmethod形式批量创建对象
    """
    import os
    import threading
    
    
    class GenericInputData(object):
        """
        通用输入抽象类 抽象方法由子类实现
        """
        def read(self):
            raise NotImplementedError
    
        @classmethod
        def generate_inputs(cls, config):
            raise NotImplementedError
    
    
    class FileInputData(GenericInputData):
        """
        文件输入类
        """
        def __init__(self, path):
            super().__init__()
            self.path = path
    
        def read(self):
            return open(self.path, 'r', encoding='utf-8').read()
    
        @classmethod
        def generate_inputs(cls, config):
            dir_path = config['dir_path']
            for file_name in os.listdir(dir_path):
                yield cls(os.path.join(dir_path, file_name))
    
    
    class GenericWorker(object):
        """
        通用Worker抽象类 抽象方法由子类实现
        """
        def __init__(self, input_data):
            self.input_data = input_data
            self.result = None
    
        def map(self):
            raise NotImplementedError
    
        def reduce(self, other):
            raise NotImplementedError
    
        @classmethod
        def generate_workers(cls, input_class, config):
            for input_data in input_class.generate_inputs(config):
                yield cls(input_data)
    
    
    class LineCountWorker(GenericWorker):
        """
        统计文件换行符Worker类
        """
        def map(self):
            content = self.input_data.read()
            self.result = content.count('\n')
    
        def reduce(self, other):
            self.result += other.result
    
    
    def execute(workers):
        threads = [threading.Thread(target=w.map) for w in workers]
        for thread in threads:
            thread.start()
            thread.join()
    
        first, rest = workers[0], workers[1:]
        for other in rest:
            first.reduce(other)
    
        return first.result
    
    
    def map_reduce(input_class, worker_class, config):
        gen_workers = worker_class.generate_workers(input_class, config)
        workers = list(gen_workers)
        return execute(workers)
    
    
    if __name__ == '__main__':
        result = map_reduce(FileInputData, LineCountWorker, {'dir_path': 'temp'})
        print(result)
    

    由此可见,在Python中,不仅可以通过__init__构造器创建对象,也可以通过@classmethod形式多态地构建对象。

    展开全文
  • 实现多态的两种形式

    千次阅读 2017-06-15 19:03:00
    a.使用父类作为方法形参实现多态 public void play(Pet p){} b.使用父类作为方法返回值实现多态 public Pet getPet(int type){} 转载于:https://www.cnblogs.com/liumeilin/p/7019502.html...

      a.使用父类作为方法形参实现多态
            public void play(Pet p){}
         b.使用父类作为方法返回值实现多态
            public Pet getPet(int type){}

    转载于:https://www.cnblogs.com/liumeilin/p/7019502.html

    展开全文
  • C#多态三种实现方式

    千次阅读 2021-02-16 10:18:22
    C#实现多态主要有3方法,虚方法,抽象类,接口 1 虚方法 ​ 在父类的方法前面加关键字virtual, 子类重写该方法时在方法名前面加上override关键字,例如下面的Person类的SayHello方法 class Person { public ...

    C#实现多态主要有3种方法,虚方法,抽象类,接口

    1 虚方法

    ​ 在父类的方法前面加关键字virtual, 子类重写该方法时在方法名前面加上override关键字,例如下面的Person类的SayHello方法

    class Person
    {
        public Person(string name)
        {
            this.Name = name;
        }
    
        string _name;
    
        public string Name { get => _name; set => _name = value; }
    
        //父类方法加virtual,子类用override重写该方法,就实现了多态 
        public virtual void SayHello()   
        {
            Console.WriteLine("我是父类的方法");
        }
    }
    

    ​ 学生类和教师都继承于Person

    class Student : Person
    {
        public Student(string name) : base(name) { }
    
        public override void SayHello()
        {
            Console.WriteLine("我叫{0}, 我是学生", this.Name);
        }
    }
    
    class Teacher:Person
    {
        public Teacher(string name) : base(name) { }
    
        public override void SayHello()
        {
            Console.WriteLine("我叫{0}, 我是老师", this.Name);
        }
    }
    

    然后在Main函数中使用多态

    Student st = new Student("李雷");
    Teacher th = new Teacher("井边君");
    
    Person[] p = { st, th };  //子类对象赋给父类
    
    for(int i = 0; i < p.Length; i++)
    {
        p[i].SayHello();
    }
    
    Console.ReadKey();
    

    本例全部代码

    using System;
    
    namespace 多态之虚方法
    {
        class Program
        {
            static void Main(string[] args)
            {
                Student st = new Student("李雷");
                Teacher th = new Teacher("井边君");
    
                Person[] p = { st, th };  //子类对象赋给父类
    
                for(int i = 0; i < p.Length; i++)
                {
                    p[i].SayHello();
                }
    
                Console.ReadKey();
            }
        }
    
        class Person
        {
            public Person(string name)
            {
                this.Name = name;
            }
    
            string _name;
    
            public string Name { get => _name; set => _name = value; }
    
            //父类方法加virtual,子类用override重写该方法,就实现了多态 
            public virtual void SayHello()   
            {
                Console.WriteLine("我是父类的方法");
            }
        }
    
        class Student : Person
        {
            public Student(string name) : base(name) { }
    
            public override void SayHello()
            {
                Console.WriteLine("我叫{0}, 我是学生", this.Name);
            }
        }
    
        class Teacher:Person
        {
            public Teacher(string name) : base(name) { }
    
            public override void SayHello()
            {
                Console.WriteLine("我叫{0}, 我是老师", this.Name);
            }
        }
    }
    

    2 抽象类

    在类前面加关键字abstract,方法前面加abstract,抽象方法不能有函数体。

    抽象类的特点:

    (1)可以有字段

    (2)可以有非抽象方法

    抽象类实现多态的代码如下

    using System;
    using System.Collections.Generic;
    
    namespace 多态之抽象类
    {
        abstract class Person
        {
            //抽象方法不能有函数体
            public abstract void SayHello();
        }
    
        class Student : Person
        {
            public override void SayHello()
            {
                Console.WriteLine("我是子类Student重写的抽象方法"); ;
            }
        }
    
        class Teacher : Person
        {
            public override void SayHello()
            {
                Console.WriteLine("我是子类Teacher重写的抽象方法"); ;
            }
        }
    
        class Program
        {
            static void Main(string[] args)
            {
                List<Person> clist = new List<Person>();
    
                Student st = new Student();
                Teacher th = new Teacher();
                clist.Add(st);
                clist.Add(th);
    
                foreach(Person p in clist)
                {
                    p.SayHello();
                }
    
                Console.ReadKey();
            }
        }
    }
    

    3 接口实现多态

    代码如下

    using System;
    using System.Collections.Generic;
    
    namespace 多态之接口
    {
        public interface IWeapon
        {
            void Fire();
        }
    
        class Gun : IWeapon
        {
            public void Fire()
            {
                Console.WriteLine("我是枪");
            }
        }
    
        class Sword : IWeapon
        {
            public void Fire()
            {
                Console.WriteLine("我是剑");
            }
    
        }
    
        class Tank : IWeapon
        {
            public void Fire()
            {
                Console.WriteLine("我是坦克");
            }
        }
    
        class Program
        {
            static void Main(string[] args)
            {
                List<IWeapon> list = new List<IWeapon>();
    
                Gun gun = new Gun();
                Sword sw = new Sword();
                Tank ta = new Tank();
                list.Add(gun);
                list.Add(sw);
                list.Add(ta);
    
                foreach (IWeapon p in list)
                {
                    p.Fire();
                }
    
                Console.ReadKey();
            }
        }
    }
    

    接口的特点

    (1)接口里的方法不能有修饰符,默认是public

    (2)接口的方法不能有函数体

    (3)接口中不能包含示例字段,不能有构造函数

    (4)接口里的方法被继承的类重写时,不需要用override关键字,接口不能被实例化

    (5)接口之间可以继承,并且可以多继承;接口不能继承于类,但是类可以继承于接口

    (6)一个类可以同时继承一个类,并实现多个接口

    展开全文
  • 多态三种表现形式以及案例分析

    千次阅读 2018-08-30 11:26:59
    首先多态三种表现形式: 继承,重写,父类引用指向子类对象。 下面案例介绍和分析: 父类- HttpServlet public class HttpServlet { public void service() { System.out.println("HttpServlet - ...

    首先多态的三种表现形式:

    继承,重写,父类引用指向子类对象。

    下面案例介绍和分析:

    父类- HttpServlet

    public class HttpServlet {
    	
    	public void service() {
    		System.out.println("HttpServlet - service");
    		doGet();
    	}
    	
    	public void doGet() {
    		System.out.print("HttpServlet - doGet");
    	}
    
    }
    

     子类- MyServlet

    public class MyServlet extends HttpServlet {
    
    	public void doGet() {
    		
    		System.out.println("MyServlet -  do Get");
    	}
    	
    }

    测试类 - Test

    public class Test {
    
    	public static void main(String[] args) {
    		HttpServlet s = new MyServlet();
    		s.service();
    	}
    
    }

    运行测试类后输出结果:

    HttpServlet - service
    MyServlet -  do Get

    代码分析:

     HttpServlet s = new MyServlet();// s 虽然是父类变量的引用,但是指向的是子类对象。
      s.service();// 子类中没有定义service,因此调用的是继承父类的service方法,然后service方法中调用doGet,这时候也是以子类中优先查找重写的doGet方法。

    总结结果:

    父类变量的引用指向的是子类对象,因此调用父类变量的方法或者变量,实际运行的是子类对象中的方法和变量(包括继承父类的,重写父类等)。

     

     

     

     

     

    展开全文
  • C++ 多态的两种形式

    千次阅读 2018-09-19 17:02:26
    编译时多态是静态多态,在编译时就可以确定接口使用的形式。运行时多态是动态多态,具体引用的接口在运行时才能确定。 静态多态和动态多态的区别其实只是在什么时候将函数实现和函数调用关联起来,是...
  • C++ 多态 以及实现多态三种方式

    千次阅读 2014-09-02 21:59:06
    3. C++中实现多态的方式... 1 4. 细说用函数重载实现多态... 2 5. 细说用模板函数实现多态... 3 6. 小结... 4 7. 细说用虚函数实现多态... 4 7.1. 虚函数是怎么回事...
  • PHP5中实现多态的两方法实例function __construct($_name) {$this->setName($_name);}function getName() {return $this->name;}function setName($_name) {$this->name = $_name;}function getDiscount...
  • 静态多态和动态多态的区别其实只是在什么时候将函数实现和函数调用关联起来,是在编译时期还是运行时期,即函数地址是早绑定还是晚绑定的。静态多态是指在编译期间就可以确定函数的调用地址,并生产代码,这就是静态...
  • Java学习--多态三种形式

    千次阅读 2018-05-03 19:41:30
    *多态入门 */ public class pet { public void eat(){ System.out.println("正在吃"); } } /** * @author AdMin * *子类 */ public class penguin extends pet{ public void ea...
  • C++多态的两种形式

    2019-07-12 17:30:19
    https://blog.csdn.net/k346k346/article/details/82774937
  • 一、多态三种实现方式(左父右子) 第一种:父类是普通类 Fu obj = new Zi(); 第二种:父类是抽象类 Father obj = new Child(); 第三种:父类是接口 Animal obj = new Dog(); 二、多态的执行(编译看...
  • 多态的四表现形式

    万次阅读 2019-07-24 10:56:41
    多态的四表现形式 在之前一提到多态,我下意识就是虚函数重写构成的运行时多态。直到看了一篇文章,才反应过来多态有四表现形式。cpp-polymorphism 运行时多态(虚函数) 编译时多态(模板) 重载 类型转换 运行时...
  • 一、多态是继封装、继承之后,面向对象的第大特性。现实事物经常会体现出多种形态,如学生,学生是人的一,则一个具体的同学张三既是学生也是人,即出现两形态。 Java作为面向对象的语言,同样可以描述一个...
  • C++的多态的几种形式

    千次阅读 2013-11-19 14:30:30
    给出“多态”的定义:一个函数调用在不同的上下文环境(context,可以编译上下文也可以使 运行上下文)中被绑定到...按照这个定义,“虚拟函数,重载,模板”这个很容易归为多态的行列,但是“转型”就有一些勉强了。
  • C++多态三种实现方式

    千次阅读 2020-10-14 19:52:01
    多态实现方式分为块:重载、重写、重定义。下面我们来谈一谈他们各自的实现方式和实现原理。 重载 实现方式 重载是在同一作用域内(不管是模块内还是类内,只要是在同一作用域内),具有相同函数名,不同的形参...
  • 多态可以分为重载、改写、多态变量、泛型四种形式。 1、 重载(Overload) 是在一个类里面,方法名字相同,而参数(个数或者类型)不同。 通俗来讲,就是两个函数名相同而类型签名不同,他们之间构成重载关系。 但是...
  • Java中三种多态实现方式

    万次阅读 2018-08-10 09:35:44
    1.普通类  AnimalFu a = new AnimalZi new(); 2.抽象类 animal 是父类抽象类 Animal a = new Cat(); 3.接口 // 学生是类 smoking 是接口  ...多态的特点: 变量:编译看父类 方法:运行看子类...
  • 实现多态的方法 多态性通过派生类重载基类中的虚函数型方法来实现。 可以用不同的方式实现组件中的多态性: 1.接口多态性。 2.继承多态性。 3.通过抽象类实现的多态性。 (继承在前边讲过,所以这里只讲抽象类和接口...
  • 多态的两表现形式

    千次阅读 2018-04-18 15:00:41
    多态的概念:同一个方法名称,执行不同的操作多态的两种形式: 重写和重载重写概念:在继承过程中,子类定义了与父类中名称相同,参数相同,返回值相同的方法称为重写重写时,子类不能比父类的访问权限更严格重写的...
  • 多态是面向对象最重要的...简单来说多态主要有三种形式,分别是虚方法、接口和抽象类,三者各有特点,下面是代码对他们的描述: 1 class Program 2 { 3 static void Main(string[] args) 4 { 5 //1....
  • Java多态实现

    2019-11-25 17:37:32
    多态实现 静态多态(静态绑定/编译器多态): —>函数的重载,且重载条件为:1.同一个类,2.函数名相同,3.参数列表不同; class Animal{ private String name; public Animal(){ } public void eat(){ .....
  • c++中多态实现个条件

    千次阅读 2019-04-11 10:20:20
    #define _CRT_SECURE_NO_WARNINGS #include <iostream> #include <... * 虚函数重写与多态实现个条件 * HeroFighter AdvHeroFighter EnemyFighter */ class HeroFighter//英雄类 {...
  • 多态的四不同形式

    千次阅读 热门讨论 2015-11-03 08:26:02
    在使用多态的时候,用户可以发送一个通用的消息,而实现的细节由接收对象自行决定。这样,同一消息就可以调用不同的方法。多态实现受到继承的支持,利用类继承的层次关系,把具有通用功能的消息存 放在高层次,而...
  • 多态的四布控形式

    千次阅读 2013-04-15 21:55:47
    多态的布控形式:参数多态,包含多态,过载多态,强制多态。其中前两者称为通用多态,后两者称为特定多态。 强制多态(coercion) 编译程序通过语义操作,把操作对象的类型强行加以变换,以符合函数或操作符的...
  • 1 使用父类作为方法形参实现多态 feet(Animal animal) 2 使用父类作为方法返回值实现多态 public Animal sellPet(int choice) { Animal a=null; switch (choice) { case 1: a=new Duck(“小黄鸭”); break; case 2: ...
  • java基础:多态实现方式 很多地方都写着多态要素是: 继承、重写、向上转型。 所以继承实现多态我理解了,那么用接口实现多态的呢,它并不符合多态要素。很困惑,希望大佬来解答一下!
  • 多态实现的机制

    千次阅读 2018-08-28 10:47:35
    多态是C++编程时的一特性,多态性即是对一个接口的多种实现多态可以分为静多态和动多态。所谓静多态就好比函数重载、模板,静多态是在函数编译阶段就决定调用机制,即在编译连接阶段就将函数的入口地址给出。而...
  • 1,用接口实现多态 [code="java"][/code] package com.tarena.framework; import android.graphics.Canvas; import android.graphics.Paint; public interface BaseState { public void draw...
  • java - 多态实现机制

    2019-10-03 05:04:24
    Java提供了编译时多态和运行时多态种多态机制。前者是通过方法重载实现的,后者是通过方法的覆盖实现的。  在方法覆盖中,子类可以覆盖父类的方法,因此同类的方法会在父类与子类中有着不同的表现形式。  在...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 90,911
精华内容 36,364
关键字:

多态实现的三种形式