Python面向对象

Python面向对象

类和对象

class Person:
    def __init__(self,name,age):
        self.name=name #类的成员属性
        self.age=age
        print("构造函数")
    def get_name(self):
        print(self.name)
    def get_age(self):
        print(self.age)

p =Person("张三",18)
p.get_name()
p.get_age()

打印结果：

构造函数
张三
18

成员方法都会默认有参数self，调用的时候不需要传递self

特殊方法和参数

__init__方法

__init__是一个内置的方法
当对象创建的时候就会自动执行__init__方法

# 定义类
class Person:
    def __init__(self):
        print('执行了init方法')

# 创建对象
p1 = Person()
p2 = Person()

输出：

执行了init方法
执行了init方法

一旦创建了该类的对象就会执行__init__方法

__str__方法

类似于Java中的toString()方法
__str__也是类的内置方法

class Person:
    def __init__(self,name,age):
        self.name=name #成员属性
        self.age=age
        print("构造函数")

    def __str__(self):
        return "name={},age={}".format(self.name,self.age)
    def get_name(self):
        print(self.name)
    def get_age(self):
        print(self.age)

p =Person("张三",18)

print(p)

name=张三,age=18

私有化

将属性或者方法设置为不能在外部访问，就是私有化
私有化包括：属性私有化、方法私有化

属性私有化

属性私有化格式，注意是两个下划线__
self.__属性名 = 属性值

class Circle:
    def __init__(self,radius):
        # 半径
        self.radius = radius
        # 私有化圆周率属性 
        self.__PI = 3.1415926


    def perimeter(self):
        '''
        求圆的周长
        :return: 圆的周长
        '''
        return 2 * self.__PI * self.radius

私有化作用：保证类中数据安全

方法私有化

方法的私有化方式和属性私有化方式一样

class Person:
    def __say_hello(self):
        print('hello')

继承

继承指的是一个对象直接使用另一个对象的属性或方法
继承的格式：
class 子类名(父类名):

class Person:
    def __init__(self,name,age):
        self.name=name #成员属性
        self.age=age
        print("构造函数")

    def __str__(self):
        return "name={},age={}".format(self.name,self.age)
    def get_name(self):
        print(self.name)
    def get_age(self):
        print(self.age)
    def eat(self):
        print(f"{self.name}吃饭")

#学生类继承Person
class Student(Person):
    def __init__(self,name,age,height):
        super().__init__(name,age)
        self.height=height #定义自己的属性height



s=Student("张三",18,180)
s.eat()

输出结果：

张三吃饭

多继承

当一个类从多个父类继承属性和方法时，就称为多继承。
多继承格式:
class 子类(父类1,父类2...)

class Animal:
    def __init__(self, name):
        self.name = name

    def eat(self):
        print(f"{self.name} is eating.")

    def sleep(self):
        print(f"{self.name} is sleeping.")


class Flyable:
    def fly(self):
        print(f"{self.name} is flying.")


class Swimmable:
    def swim(self):
        print(f"{self.name} is swimming.")


class Duck(Animal, Flyable, Swimmable):
    def __init__(self, name):
        super().__init__(name)


duck = Duck("Donald")
duck.eat()   # 输出: Donald is eating.
duck.sleep()   # 输出: Donald is sleeping.
duck.fly()   # 输出: Donald is flying.
duck.swim()   # 输出: Donald is swimming.

注意，在多继承的情况下，当多个父类中具有相同名称的方法时，解释器将按照方法解析顺序（Method Resolution Order，MRO）来确定使用哪个方法。在上述示例中，Python的默认MRO算法会按照类定义时的顺序来解析方法。在这个例子中，Duck类首先从Animal类继承方法，然后是Flyable类，最后是Swimmable类（按照括号的顺序从前往后）。

多态

"""
多态案例
"""
# 父类
class Human:
    def eat(self):
        print('人类吃饭')

# 中国人
class ZhHuman(Human):
    def eat(self):
        print('中国人使用筷子吃饭')

# 美国人
class UsHuman(Human):
    def eat(self):
        print('美国人使用刀叉吃饭')

# 非洲人
class AfricaHuman(Human):
    def eat(self):
        print('非洲人直接用手吃恩希玛')


# 函数
def someone_eat(someone):
    '''
    接收一个具备吃eat功能的对象
    '''
    someone.eat()


# 创建四个对象
human = Human()
zh_human = ZhHuman()
us_human = UsHuman()
africa_huamn = AfricaHuman()

# 调用translate方法
someone_eat(human)
someone_eat(zh_human)
someone_eat(us_human)
someone_eat(africa_huamn)

鸭子类型

一只鸟走起来像鸭子、游泳起来像鸭子、叫起来也像鸭子，那么这只鸟可以被称为鸭子。这就是鸭子类型Duck Typing
对于上述多态中的的someone_eat

class Dog:
    def eat(self):
        print('狗吃骨头')

# 函数
def someone_eat(someone):
    '''
    接收一个具备吃eat功能的对象
    '''
    someone.eat()

dog = Dog()
someone_eat(dog)

someone_eat需要传递一个具备eat方法的对象，但是Dog也具备eat功能,所以也可以传递运行
这是由于python是动态类型语言，不能像C++、Java等静态类型语言一样，限制传递的数据类型
只要运行时发现dog对象有这个功能，就可以在函数中使