面向对象主要有三大特点：封装、继承和多态的运用以及鸭子类型参考代码（附带参考代码）

最新推荐文章于 2024-07-20 17:12:48 发布

mohanyelong

最新推荐文章于 2024-07-20 17:12:48 发布

阅读量773

点赞数 23

文章标签： python 开发语言 pycharm 学习算法

本文链接：https://blog.csdn.net/mohanyelong/article/details/140474472

版权

                    
                        
                    
                    python每日学习7：面向对象主要有三大特点：封装、继承和多态的运用以及鸭子类型参考代码（附带参考代码） 
 封装 
   封装的定义 
    直接在Student类的内部定义访问数据的函数，这样就把“数据”给封装起来了。这些封装数据的函数是和Student类本身是关联起来的，称之为类的方法。
 
 封装的运用 
 class Student:
    # 类中的属性
    eye = 2

    # name = None
    # score = None

    # 构造方法  在类被定义的使用就会使用
    def __init__(self, n, s):
        # self 类中的变量 全类可用
        # 类中的属性
        self.name = n
        # 私有变量  可以在类的内部去处理  安全一点 不能在外部直接去修改这个值
        self.__score = s
        # 用一个下划线 大家就会认为你是一个私有变量 (常量)
        self._sco = 1
        # print(self.eye)
        # self.print_sco()

    # 私有方法
    def __a(self):
        print("1")

    def set_score(self,new_score):
        self.__score = new_score

    def get_score(self):
        return self.__score

    # 类中的方法
    def print_sco(self):
        self.__a()
        print(f"{self.name}的成绩是{self.__score}")

    def get_grade(self):
        if self.__score>90:
            print("A")
        else:
            print("B")

# def print_sco(stu:Student):
#     print(f"{stu.name}的成绩是{stu.score}")


if __name__ == '__main__':

    # 对象是类的实例  类是对象的抽象
    stu1 = {"name": "zs", "score": 90}
    stu2 = {"name": "ls", "score": 89}
    print_score(stu1)
    print_score(stu2)

    # 实例化一个类
    ls = Student("ls", 90)
    ls.print_sco()
    ww = Student("ww", 88)
    ww.print_sco()
    # print_sco(ls)
    ls.get_grade()

    # 通过类的变量直接去修改变量值
    # ls.__score = 99
    # print(ls.__score)


    # 通过我给的方法去修改
    ls.set_score(100)
    print(ls.get_score())

    print(ls._Student__score)

 
 
 继承 
   继承的定义 
    当定义一个class的时候，可以从某个现有的class继承，新的class称为子类（Subclass），而被继承的class称为基类、父类或超类（Base class、Super class）。
最大的好处是子类获得了父类的全部功能
 
 继承的运用 
 #继承
class Animal(object):
    def __init__(self,leg,height):
        self.leg=leg
        self.height=height
    def run(self):
        print('animal run')

#括号内加入父类
class Dog(Animal):
    def __init__(self,leg,height,bark):
        # self.leg = leg
        # self.height = height
        super().__init__(leg,height)#继承父类的初始化
        self.bark=bark
    def eat(self):
        print('dog eat')
    #方法重写
    def run(self):
        #super(Dog, self).run()#调用父类的方法，相当于再一次运行父类的run
        print('dog run')#此时run运行Dog中的


if __name__ == '__main__':
    #继承
    animal=Animal(4,1)
    dog=Dog(4,1.5,'wang')
    print(dog.run())
    print(animal.run())
    print(dog.eat())
 
 
 多态 
   多态的定义 
    允许不同类的对象对同一消息做出响应，但具体的行为会根据对象的实际类型而有所不同。
 
 多态的运用 
 # 多态 父类的引用指向子类的对象
# 多态的基础条件是继承
def run_twice(animal:Animal):
    animal.run()
    animal.run()
    
#猴子补丁：增加一个类
def drink(self):
    print('animal drink')

if __name__ == '__main__':
    #多态
    animal=Animal(5,4)
    animal=Dog(4,3,'wolf')

    #猴子补丁:强行增加一个属性，破坏了代码的封装性
    animal.rand=2
    print(animal.rand)

    Animal.drink=drink
    animal.drink=()
    # print(animal.drink())
    pass
 
 
 鸭子类型 
 # 鸭子类型
class Duck:
    def __init__(self,name):
        self.name=name
    def bark(self):
        print(f"{self.name} is gaga")
    def swim(self):
        print(f"{self.name} is swim")

class Goose:
    def __init__(self,name):
        self.name=name
    def bark(self):
        print(f"{self.name} is eee")
    def swim(self):
        print(f"{self.name} is fast")
def dshow(duck:Duck):
    duck.bark()
    duck.swim()

if __name__ == '__main__':
    danglao=Duck("danglao")
    ping=Goose("ping")
    dshow(danglao)
    dshow(ping)

 

                