美文网首页
15-笔记整理(面向对象3)

15-笔记整理(面向对象3)

作者: 李小萌mmm | 来源:发表于2018-08-02 20:54 被阅读0次

    1.重写

    继承后,子类可以拥有除父类继承的内容以外的其他的内容
    
    1.关于方法
    1).在子类中可以直接添加其他的方法
    2).重写:
    a.完全重写
    重新实现从父类继承下来的方法,重写后,子类再调用这个方法的时候,就调用子类的
    b.保留父类实现的功能,再添加新的功能
    
    对象和类调用方法的过程:先看当前类是否存在这个方法,没有才看父类有没有这个方法;
                        如果父类没有就看父类的父类有没有,直到找到基类(object)为止
    
    """
    
    
    class Animal(object):
        """动物类"""
        def __init__(self):
            self.age = 0
            self.color = ''
    
        def eat(self):
            print('吃东西')
    
        def shout(self):
            print('叫唤')
    
        @classmethod
        def get_number(cls):
            return 100
    
    
    class Dog(Animal):
        """狗类"""
        def look_after(self):
            print('看家')
    
        #  重写父类的shout
        def shout(self):
            print('汪汪汪~')
    
        # 重写父类eat方法
        def eat(self):
            # 保留父类eat的功能
            super().eat()
            print('吃骨头')
    
        @classmethod
        def get_number(cls):
            # 保留父类的类方法的功能的时候,还是super().类方法
            print(super().get_number())
    
    
    if __name__ == '__main__':
        dog = Dog()
        dog.age = 3
        print(dog.color)
        dog.shout()
        dog.look_after()
        dog.eat()
    
        an = Animal()
        # 继承后,父类不能使用在子类中添加的属性和方法
        # an.look_after()
        an.eat()
    
        Dog.get_number()
    

    2.添加属性

    """
    对象属性的继承:是通过继承init方法来继承的对象属性
    
    给当前类添加对象属性: 重写init方法。
                       注意:如果要保留父类的对象属性,需要使用super()去调用父类的init方法
    
    多态:同一个事物有多种形态。
    方法的多态:子类继承父类的方法,可以对方法进行重写,一个方法就有多种形态(多态的表现)
    类的多态:继承产生多态
    """
    
    class Person(object):
        """人类"""
        def __init__(self, name, age=0, sex=''):
            self.name = name
            self.age = age
            self.sex = sex
    
        def eat(self):
            print('人在吃饭')
    
    
    class Staff(Person):
        # init方法的参数:保证在创建对象的时候就可以给某些属性赋值
        def __init__(self, name='', age=0, salary=0):
            super().__init__(name, age)
            self.salary = salary
    
        def eat(self):
            print('员工在吃饭')
    
    class Scientist(Person):
        def eat(self):
            print('科学家在吃饭')
    
    
    if __name__ == '__main__':
        p1 = Person('李四',sex='女')
        p1.eat()
    
        s1 = Staff(age=18)
        s1.sex = '男'
        print(s1.name)
        s1.salary = 10000
        print(s1.salary)
        s1.eat()
    
    
    # 练习:
    """
    声明人类,有属性,名字、年龄、性别、身高
    要求创建人的对象的时候可以给名字、性别、年龄赋初值
    
    再创建学生类继承自人类,拥有人类的所有的属性,再添加学号、成绩、电话属性
    要求创建学生对象的时候可以给名字、年龄和电话赋初值
    """
    class Person2:
        """人类"""
        a = 10
    
        def __init__(self, name, sex, age):
            self.name = name
            self.age = age
            self.sex = sex
            self.height = 0
    
    
    class Student(Person2):
        """学生类"""
        b = 100
    
        def __init__(self, name='', age=0, tel='00'):
            super().__init__(name, age=age, sex='女')
            self.study_id = '00'
            self.score = 0
            self.tel = tel
    
    
    stu = Student('李四')
    stu.sex = '男'
    print(stu.age)
    
    p1 = Person2('张三', '男', 18)
    

    3.运算符的重载

    1.重载:一个类中可以有多个名字相同的方法,但是参数不一样,就叫重载。python中不支持
    """
    class Student:
    
        # python不支持方法的重载
        # def run(self):
        #     print('人在跑')
        def run(self, name):
            print('%s在跑' % name)
    
    """
    2.运算符重载(重新定义运算符运算的过程)
    >、<
    大于和小于符号只需要重载其中的一个,另外一个的结果,直接是重的结果取反
    >
    +、-
    """
    class Student2:
        def __init__(self, name='', age=0, height=0):
            self.name = name
            self.age = age
            self.height = height
    
        #   重载: >
        """
        self > other
        """
        def __gt__(self, other):
            # 比较对象1>对象2的时候是比较的他们的height属性
            return self.height > other.height
            # return self.age > other.age
            # return id(self) > id(other)
    
        # 重载:<
        def __lt__(self, other):
            return self.age < other.age
    
        # 重载: +
        def __add__(self, other):
            return self.age + other.age
    
        # 重载: -
        def __sub__(self, other):
            return self.height - other.height
    
    
    if __name__ == '__main__':
        stu = Student()
        stu.run('余婷')
    
        stu1 = Student2('aa', 18, height=170)
        stu2 = Student2('bb', 20, height=140)
    
        if stu1 > stu2:
            print('学生1大于学生2啊啊')
    
        if stu1 < stu2:
            print('学生1大于学生2')
        else:
            print('学生2小于学生1')
    
        print(stu1 + stu2)
        print(stu1-stu2)
    
        print(100+200)
        print('abc'+'abc')
    
    

    4.内存管理

    '''python内存管理原理
    内存中有两个特殊的区域:栈,堆
    栈:栈中的内存是系统自动管理(内存的开辟和内存的释放)
    堆:堆中的内存都需要写程序去开辟和释放的
    
    原理?:推中的数据到底是什么时候释放的?
    看一个对象有几个引用,当一个值没有引用的时候,值对应的内存空间就会被释放
    (引用计数机制) 引用;存储对象地址的变量
    '''
    class Person:
    
        def run(self):
            print('正在跑')
    
    
    if __name__ == '__main__':
        #p =Person()
        #p.run()
        #删除对象的唯一的引用,对象会销毁
        #del p
        #注意;将对象添加到容器中,对象的引用会加1
        p3 = Person()
        lists =[p3]
        del p3
        lists[0].run()
        # del list[0]
        # del lists
        lists[0]=1
        lists[0].run()
    

    5.包

    封装:
    对一个功能的封装--->用函数
    对多个功能的封装 --> 模块和类
    对多个数据进行封装 --- 类,字典
    对多个类进行封装 --->模块
    对多个模块进行封装 ---> 包

    相关文章

      网友评论

          本文标题:15-笔记整理(面向对象3)

          本文链接:https://www.haomeiwen.com/subject/paasvftx.html