说明：仅供学习使用，请勿用于非法用途，若有侵权，请联系博主删除
 
 
作者：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形式多态地构建对象。
 

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

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）一个类可以同时继承一个类，并实现多个接口

首先多态的三种表现形式：
 
继承，重写，父类引用指向子类对象。
 
下面案例介绍和分析：
 
父类- 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方法。
 
总结结果：
 
父类变量的引用指向的是子类对象，因此调用父类变量的方法或者变量，实际运行的是子类对象中的方法和变量（包括继承父类的，重写父类等）。