Python3 与 C# 面向对象之～继承与多态

代码裤子：https://github.com/lotapp/BaseCode

在线编程：https://mybinder.org/v2/gh/lotapp/BaseCode/master
在线预览：http://github.lesschina.com/python/base/oop/2.继承与多态.html

2.继承

2.1.单继承

在OOP中，当我们定义一个Class的时候，可以从某个现有的Class继承

新的Class称为子类，而被继承的class称为 基类 或者 父类

Python的继承格式 ==>
xxx(base_class)

小明兴高采烈的听着老师开新课，不一会就看见了一个演示Demo：

In [1]:

class Animal(object):
    def eat(self):
        print("动物会吃")

class Cat(Animal):
    # 注意一下Python的继承格式
    pass

class Dog(Animal):
    pass

def main():
    cat = Cat()
    dog = Dog()
    cat.eat()
    dog.eat()

if __name__ == "__main__":
    main()

动物会吃
动物会吃

当听到老师说：“ 私有的属性方法 不会被子类继承 ”的时候，小明心里一颤，联想到之前讲的 类属性、 实例属性、 实例方法、 类方法、 静态方法，于是赶紧写个Demo验证一下：

In [2]:

class Animal(object):
    # 类属性
    name = ‘动物‘

    def __init__(self):
        # 实例属性
        self.age = 1

    def __bug(self):
        """实例私有方法"""
        print("我是动物类身上的私有方法：bug")

    def eat(self):
        """实例方法"""
        print("我是实例方法，动物会吃哦～")

    @classmethod
    def call(cls):
        """类方法"""
        print("我是类方法，动物会叫哦")

    @staticmethod
    def play():
        """静态方法"""
        print("我是静态方法，动物会玩耍哦")

class Dog(Animal):
    pass

def main():
    dog = Dog()
    # 实例属性
    print(dog.age)
    # 实例方法
    dog.eat()

    # 类属性
    print(dog.name)
    # 类方法
    dog.call()
    Dog.call()
    Animal.call()

    # 静态方法
    dog.play()
    Dog.play()
    Animal.play()

if __name__ == ‘__main__‘:
    main()

1
我是实例方法，动物会吃哦～
动物
我是类方法，动物会叫哦
我是类方法，动物会叫哦
我是类方法，动物会叫哦
我是静态方法，动物会玩耍哦
我是静态方法，动物会玩耍哦
我是静态方法，动物会玩耍哦

来张图就懂了，不是 私有的 都能访问：

这时候，小明老高兴了，单回头一想 ==> 不科学啊，dog应该有其对应的方法吧，C#有 虚方法重写，Python怎么搞？在 子类里面又 怎么调用父类方法呢？

对于小明的提示老师很高兴，于是点名小潘来写一个子类调用父类的demo（老师昨天从窗户里看见小潘有预习）：

In [3]:

# 调用父类的方法
class Father(object):
    def eat(self):
        print("文雅的吃饭")

class Son(Father):
    def eat(self):
        # 调用父类方法第1种（super().方法）
        super().eat()

class GrandSon(Son):
    def eat(self):
        # 调用父类方法第2种（记得传self）
        Son.eat(self)

def main():
    xiaoming = Son()
    xiaoming.eat()

    xiaoli = GrandSon()
    xiaoli.eat()

if __name__ == ‘__main__‘:
    main()

文雅的吃饭
文雅的吃饭

一般我们使用 super().方法来调用父类方法

第二种方法 类名.方法(self)千万别忘记传self哦

对了，C#是用base关键词，别搞混了

小明这时候可不高兴了，风头怎么能被小潘全部抢走呢，赶紧问问旁边同样预习的伟哥

不一会儿淡定的发了份重写父类方法的demo给老师：

In [4]:

# 重写父类方法==>子类和父类有同名方法
class Father(object):
    def __init__(self, name):
        self.name = name

    def eat(self):
        print("%s喜欢文雅的吃饭" % self.name)

class Son(Father):
    def __init__(self, name):
        super().__init__(name)

    def eat(self):
        print("%s喜欢大口吃饭大口喝酒" % self.name)

def main():
    xiaoming = Father("小明")
    xiaoming.eat()

    xiaopan = Son("小潘")
    xiaopan.eat()

if __name__ == "__main__":
    main()

小明喜欢文雅的吃饭
小潘喜欢大口吃饭大口喝酒

老师半喜半忧的说道：“小明同学啊，你也老大不小了，怎么跟孩子一样啊？案例不错，但是怎么能人身攻击人家小潘了？”

当子类和父类都存在相同的 eat()方法时，我们说，子类的 eat()覆盖了父类的 eat()

在代码运行的时候，总是会调用子类的 eat() 这样，我们就获得了继承的另一个好处： 多态

2.2.多继承 ¶

在讲 多态之前，我们先引入一下Python的 多继承 对，你没有听错

Java、C#都是单继承，多实现。Python和C++一样，可以多继承，先不要吐槽， 规范使用其实很方便的

来个案例看看：

In [5]:

# 多继承引入
class Father(object):
    def eat(self):
        print("文雅的吃饭")

class Mom(object):
    def run(self):
        print("小碎步")

class Son(Father, Mom):
    pass

def main():
    son = Son()
    son.eat()
    son.run()

if __name__ == ‘__main__‘:
    main()

文雅的吃饭
小碎步

继承可以把父类的所有功能都直接拿过来，这样就不必重0开始写代码，子类只需要新增自己特有的方法，也可以把父类不适合的方法覆盖重写

注意一个情况，如果父类里面有同名方法咋办了？到底调哪个呢？

使用 子类名.__mro__可以看在调方法的时候搜索顺序

一般同名方法都是 先看自己有没有，然后看继承顺序，比如这边 先看Mom再看Father

In [6]:

# 如果父类里面有同名方法怎么知道调哪个？
class Father(object):
    def eat(self):
        print("文雅的吃饭")

class Mom(object):
    def eat(self):
        print("开心的吃饭")

class Son(Mom, Father):
    pass

def main():
    son = Son()
    son.eat()
    print(Son.__mro__)  # 一般同名方法都是先看自己有没有，然后看继承顺序，比如这边先看Mom再看Father

if __name__ == ‘__main__‘:
    main()

开心的吃饭
(<class ‘__main__.Son‘>, <class ‘__main__.Mom‘>, <class ‘__main__.Father‘>, <class ‘object‘>)

Python的多继承最好是当C#或者Java里面的接口使用，这样结构不会混乱( 特殊情况除外)

来个例子：

class Animal(object):
    pass

class Flyable(object):
    """飞的方法"""
    pass

class Runable(object):
    """跑的方法"""
    pass

class Dog(Animal, Runable):
    pass

class Cat(Animal, Runable):
    pass

class Bird(Animal, Flyable):
    pass

class Dack(Animal, Runable, Flyable):
    """鸭子会飞也会跑"""
    pass

和C#一样，Python的 父类构造函数不会被继承

其实从资源角度也不应该被继承，如果有1w个子类，那每个子类里面都有一个父类方法，想想这是多么浪费的一件事情？

2.3.C#继承 ¶

下课后，小明认真思考总结，然后对照Python写下了C#版的继承：

定义一个人类

public class Person
{
    public string Name { get; set; }
    public ushort Age { get; set; }

    public Person(string name, ushort age)
    {
        this.Name = name;
        this.Age = age;
    }
    public void Hi()//People
    {
        Console.WriteLine("Name: " + this.Name + " Age: " + this.Age);
    }
    public virtual void Show()//People
    {
        Console.WriteLine("Name: " + this.Name + " Age: " + this.Age);
    }
}

定义一个学生类

public class Student : Person
{
    #region 属性
    /// <summary>
    /// 学校
    /// </summary>
    public string School { get; set; }
    /// <summary>
    /// 班级
    /// </summary>
    public string StrClass { get; set; }
    /// <summary>
    /// 学号
    /// </summary>
    public string StrNum { get; set; }
    #endregion

    #region 构造函数
    /// <summary>
    /// 调用父类构造函数
    /// </summary>
    /// <param name="name"></param>
    /// <param name="age"></param>
    public Student(string name, ushort age) : base(name, age)
    {

    }
    public Student(string name, ushort age, string school, string strClass, string strNum) : this(name, age)
    {
        this.School = school;
        this.StrClass = strClass;
        this.StrNum = strNum;
    }
    #endregion

    /// <summary>
    /// new-隐藏
    /// </summary>
    public new void Hi()//Student
    {
        Console.WriteLine("Name: " + this.Name + " Age: " + this.Age + " School: " + this.School + " strClass: " + this.StrClass + " strNum: " + this.StrNum);
    }
    /// <summary>
    /// override-覆盖
    /// </summary>
    public override void Show()//Student
    {
        Console.WriteLine("Name: " + this.Name + " Age: " + this.Age + " School: " + this.School + " strClass: " + this.StrClass + " strNum: " + this.StrNum);
    }
}

调用一下：

Person p = new Student("app", 10, "北京大学", "001", "01001");
p.Hi(); p.Show();

Console.WriteLine();

Student s = p as Student;
s.Hi(); s.Show();

结果:

Name: app Age: 10
Name: app Age: 10 School: 北京大学 strClass: 001 strNum: 01001
Name: app Age: 10 School: 北京大学 strClass: 001 strNum: 01001
Name: app Age: 10 School: 北京大学 strClass: 001 strNum: 01001

2.4C#接口的多实现 ¶

定义两个接口：

public interface IRun
{
    //什么都不用加
    void Run();
}

public interface IEat
{
    void Eat();
}

定义一个Dog类来实现两个接口，这样dog就有了run和eat的方法了

var dog = new Dog();
dog.Eat();
dog.Run();

结果：

狗狗吃
狗狗跑

3 多态 ¶

3.1.Python ¶

说多态之前说说类型判断，以前我们用 type() or isinstance()

判断一个变量和另一个变量是否是同一个类型==> type(a)==type(b)

判断一个变量是否是某个类型==> type(a)==A or isinstance(a,A)

In [7]:

# 判断一个变量是否是某个类型 ==> isinstance() or type
class Animal(object):
    pass

class Dog(Animal):
    pass

def main():
    dog = Dog()
    dog2 = Dog()
    print(type(dog) == Dog)
    print(type(dog) == type(dog2))
    print(type(dog))

    print(isinstance(dog, Dog))
    print(isinstance(dog, Animal))
    # arg 2 must be a type or tuple
    # print(isinstance(dog, dog2))

if __name__ == ‘__main__‘:
    main()

True
True
<class ‘__main__.Dog‘>
True
True

小明老高兴了，终于讲解多态了，不禁问道：“ 多态的好处是啥？”

小潘瞥了一眼小明～“废话，肯定为了 屏蔽子类差异用的啊，像简单工厂不就干的这个事？"

小明楞了楞，眼巴巴的看着老师继续讲课。

设计模式我们会找个专题讲讲，现在给你们说的是Python的基础。

Python是动态语言的“ 鸭子类型”，它并不要求严格的继承体系。

一个对象只要“看起来像鸭子，走起路来像鸭子”，那它就可以被看做是鸭子（最后会贴一个案例）

C#实现多态有很多方式，比如虚方法，比如抽象类，比如接口等等...

小明迷迷糊糊的问道：“那 Python怎么实现多态呢？”

老师看了一眼打断他讲课的小明，然后继续说道～来个简单案例：

In [8]:

class People(object):
    def eat(self):
        print("人类会吃饭")

class Father(object):
    def eat(self):
        print("优雅的吃饭")

class Teacher(object):
    def eat(self):
        print("赶时间的吃饭")

# C# 或者 Java里面 写成 eat(People obj)
def eat(obj):
    obj.eat()

def main():
    teacher = Teacher()
    father = Father()
    eat(teacher)
    eat(father)

if __name__ == ‘__main__‘:
    main()

赶时间的吃饭
优雅的吃饭

多态的好处在于，如果这时候我再来个Son子类，有eat()方法编写正确，不用管原来的代码是如何调用的

这次小明懂了，为了装一下，说道：”老师老师，我记得C# 或者 Java里面是写成 eat(People obj) 的吧？“

老师欣慰的笑了一下，说道：”记得刚才说的 填鸭式吗？Python这么写有个好处哦，我们来看个案例，然后你自己总结“

In [9]:

class People(object):
    def eat(self):
        print("人类会吃饭")

class Father(object):
    def eat(self):
        print("优雅的吃饭")

class Teacher(object):
    def eat(self):
        print("赶时间的吃饭")

class Dog(object):
    def eat(self):
        print("舔着吃")

def eat(obj):
    obj.eat()

def main():
    teacher = Teacher()
    father = Father()
    eat(teacher)
    eat(father)

    # 我们添加一个不是People子类的Dog类，只要有eat方法，参数一样就可以直接调
    dog = Dog()
    eat(dog)

if __name__ == ‘__main__‘:
    main()

赶时间的吃饭
优雅的吃饭
舔着吃

小明突然大声说道：”老师老师，我知道了，Python这是吧类的继承和接口继承融合起来了啊，实现多态就相当于C#里面的接口实现多态啊！！！“

老师点评道：”你姑且可以这么理解，这些我们后面还会继续说的，这种填鸭式的手段刚开始的确会有点不方便，用着用着你就会觉得挺方便的“


小明认真思考总结，然后对照Python和小潘一起写下了 C#版的多态：

3.2.C#虚方法实现多态 ¶

定义一个人类：

public class Person
{
    #region 字段+属性
    /// <summary>
    /// 姓名
    /// </summary>
    private string _name;
    public string Name
    {
        get
        {
            return _name;
        }

        set
        {
            _name = value;
        }
    }
    /// <summary>
    /// 性别
    /// </summary>
    private bool _gender;
    public bool Gender
    {
        get
        {
            return _gender;
        }

        set
        {
            _gender = value;
        }
    }
    /// <summary>
    /// 年龄
    /// </summary>
    public short Age { get; set; }
    #endregion

    #region 构造函数
    public Person() { }
    public Person(string name, bool gender)
    {
        this.Name = name;
        this.Gender = gender;
    }
    public Person(string name, bool gender, short age) : this(name, gender)
    {
        this.Age = age;
    }
    #endregion

    #region 方法
    /// <summary>
    /// 打招呼
    /// </summary>
    public virtual void SaiHi()
    {
        Console.WriteLine("我是一个人类！");
    }
    #endregion
}

定义一个女孩类：

public class Gril : Person
{
    #region 构造函数
    public Gril() { }
    public Gril(string name, bool gender) : base(name, gender) { }
    public Gril(string name, bool gender, short age) : base(name, gender, age) { }
    #endregion

    /// <summary>
    /// 重写父类方法
    /// </summary>
    public override void SaiHi()
    {
        string genderStr = Gender == true ? "男孩" : "女孩";
        Console.WriteLine($"你好，我叫{Name}，今年{Age}岁了，我是一个腼腆的小{genderStr}");
    }
}

定义一个男孩类：

public class Boy : Person
{
    #region 构造函数
    public Boy() { }
    public Boy(string name, bool gender) : base(name, gender) { }
    public Boy(string name, bool gender, short age) : base(name, gender, age) { }
    #endregion

    //public void SaiHi()
    public override void SaiHi()
    {
        string genderStr = Gender == true ? "男孩" : "女孩";
        Console.WriteLine($"你好，我叫{Name}，今年{Age}岁了，我是一个腼腆的小{genderStr}");
    }
}

调用：

static void Main(string[] args)
{
    Person[] persons = { new Person(), new Boy("铁锅", true, 13), new Gril("妞妞", false, 22) };
    foreach (var item in persons)
    {
        //看看item里面到底放的是什么
        Console.WriteLine(item.ToString());
        item.SaiHi();
        Console.WriteLine();
    }
}

结果：

Polymorphism1.Person
我是一个人类！
Polymorphism1.Boy
你好，我叫铁锅，今年13岁了，我是一个腼腆的小男孩
Polymorphism1.Gril
你好，我叫妞妞，今年22岁了，我是一个腼腆的小女孩

3.3.C#抽象类实现多态 ¶

定义一个动物类：

public abstract class Animal
{
    /// <summary>
    /// 抽象类中可以有正常的方法
    /// </summary>
    public void Action()
    {
        Console.WriteLine("动物可以动");
    }

    /// <summary>
    /// 抽象方法必须在抽象类中
    /// </summary>
    public abstract void Call();
}

定义一个猫科动物类（子类必须实现父类抽象方法，如果不实现，那么该类也必须是抽象类）

/// <summary>
/// 猫科动物---子类必须实现父类抽象方法，如果不实现，那么该类也必须是抽象类
/// </summary>
public abstract class Feline : Animal
{
}

定义一个猫类

public class Cat : Feline
{
    /// <summary>
    /// 子类必须实现父类抽象方法，如果不实现，那么该类也必须是抽象类
    /// </summary>
    public override void Call()
    {
        Console.WriteLine("喵喵叫~~~");
    }
}

定义一个狗类

public class Dog : Animal
{
    /// <summary>
    /// 子类必须实现抽象类中的抽象方法
    /// </summary>
    public override void Call()
    {
        Console.WriteLine("汪汪叫~~~");
    }
}

调用：

Animal[] animals = { new Dog(), new Cat() };
foreach (var item in animals)
{
    item.Call();
}

结果：

汪汪叫~~~
喵喵叫~~~

3.4.C#接口实现多态 ¶

定义一个跑的接口：

public interface IRun
{
    /// <summary>
    /// 接口中可以声明属性，方法，索引器等
    /// </summary>
    //string Name { get; set; }

    void Runing();
}

定义一个猫类：

public class Cat : IRun
{
    public void Runing()
    {
        Console.WriteLine("飞快的跑着上树");
    }
}

定义一个学生类：

public class Student : IRun
{
    public void Runing()
    {
        Console.WriteLine("飞快的跑着去上课");
    }
}

调用：

IRun[] objs = { new Student(), new Cat() };
foreach (var item in objs)
{
    item.Runing();
}

结果：

飞快的跑着去上课
飞快的跑着上树

原文地址：https://www.cnblogs.com/dotnetcrazy/p/9219226.html

时间： 2024-11-10 14:03:54

Python3 与 C# 面向对象之～继承与多态的相关文章

javascript面向对象：继承、多态

继承 js中同样可以实现类的继承这一面向对象特性,继承父类中的所有成员(变量和属性),同时可扩展自己的成员,下面介绍几种js中实现继承的方式: 1,对象模仿:通过动态的改变 this 指针的指向,实现对父类成员的重复定义,如下: function ClassA(paramColor) { this.color = paramColor; this.sayColor = function() { alert(this.color); } } function ClassB(paramColor,

php 面向对象之继承、多态和静态方法

<?php //继承:子类可以继承父类的一切 //特点:单继承 //父类 class Ren { public $name; public $sex; public $yuyan; function Say() { echo $this->name."正在讲话!"; } } //美国人的子类 class America extends Ren { public $ziben; //子类对父类的方法重写 function Say() { parent::Say(); //调用

Python 面向对象编程——继承和多态

1.1   继承和多态 1.1.1   继承 当我们定义一个class的时候,可以从某个现有的class继承,新的class称为子类(Subclass),而被继承的class称为基类.父类或超类(Base class.Super class). >>> class Animal(object): ...    def run(self): ...        print('Animal is running...') #父类 ... >>> class Dog(Ani

面向对象(4)--继承和多态

一.继承 继承的类称为子类,被继承的类称为基类,父类,或超类. 继承的优点: 简化了代码 提高了代码的健壮性 提高了代码的安全性 多态的前提 缺点:耦合与内聚.耦合性越低,内聚性越高,代码越好. 比如,有一个Animal类,有个run方法: In [1]: class Animal: ...: def run(self): ...: print('我正在跑步!!!') ...: 当我们需要创建Dog和Cat类时,可以直接继承Animal: In [3]: class Dog(Animal): .

PHP中面向对象的继承和多态基本用法

Extends 继承: 特点:单继承 一个子类只能有一个父类,一个父类可以有多个子类 例子: Class Ren { Public $name; Public $sex; Public $yuyan; Function say() { Echo $this->name.”正在讲话”: } } 美国人的子类: Class amercia extends Ren { Function say() { Parent::say();    调用父类的say()方法 Echo “hello”;    子类

面向对象：继承、多态

1.继承   子类名:父类名 子类可以继承父类所有的公共方法和属性 一个父类可以有无数个子类.后辈类 一个子类只能有一个亲爹 父类.基类子类.派生类.超类        --不同种说法 2.多态 virtual   虚方法 override  重写 overload 重载 用法: class grandfa { public string p() { return "奶奶"; } } -- class father:grandfa { public virtual string peo

面向对象编程——继承和多态（四）

在OOP程序设计中,当我们定义一个class的时候,可以从某个现有的class继承,新的class称为子类(Subclass),而被继承的class称为基类.父类或超类(Base class.Super class). 比如我们已经编写了一个名为Animal的class,有一个run()方法可以直接打印: class Animal(object): def run(self): #为啥没有__init__,因为不需要初始化,就self一个参数. print("Animal is running.

python 面向对象四 继承和多态

一.继承 1 class Animal(object): 2 def run(self): 3 print('Animal is running...') 4 5 class Dog(Animal): 6 7 def run(self): 8 print('Dog is running...') 9 10 def eat(self): 11 print('Eating meat...') 12 13 dog = Dog() 14 dog.run() 1 Dog is running... 当子类

面向对象（继承，多态）

二维数组的定义格式:第一种:直接给定了每一个一维数组中数组长度数据类型[][] 数组名称 = new 数据类型[m][n]第二种:给定了多少个一维数组,长度动态给定数据类型[][] 数组名称 = new 数据类型[m][] ;第三种:二维数组中直接给定元素值数据类型[][] 数组名称 = {{元素1,元素2},{元素1,元素2}-} 如何遍历二维数组 int [][] arr = {{11,22},{33,44},{55,66}} ; 外层循环:控制的是二维数组长度,内存循环,一维数组长度 代码

Java面向对象，继承，多态

1,继承 Java 中通过 extends 关键字可以继承一个类,implements可以继承多个接口.继承允许创建等级层次的类. 继承的机制提高了代码的复用性,让类与类之间产生了关系,有了这个关系,才有了多态的特性. 注:Java支持单继承,但是可以多层继承. 子类可以拥有父类的非private的方法和属性,子类可以继承父类的方法,也可以重写父类的方法,还可以对父进行拓展. 增加了类之间的联系,即提高了耦合. 一般格式为: class 父类 { } class 子类 extends 父类 {