面向对象编程基础

一时失言乱红尘 2021-10-29 06:56 456阅读 0赞

**类和对象**  
– 简单的说， 类是对象的蓝图和模版，而对象是类的实例。  
**定义类：**

class student(object):
    		    # __init__是一个特殊方法用于在创建对象时进行初始化操作
    		    #通过这个方法让我们可以为学生对象绑定name和age两个属性
    		    def __init__(self,name, age):
    		        self.name = name
    		        self.age = age
    		    def study(self,course_name):
    		        print('%s正在学习%s.'%(self.name,course_name))
    	
    		        #pep 8要求标识符的名字用全小写 多个单词用下划线连接
    		        #但是很多程序员和公司更倾向于使用驼峰命名法`

**创建和使用对象**  
当我们定义好一个类之后，可以通过下面的方式来创建对象并给对象发消息。

def main():
        # 创建学生对象并指定姓名和年龄
        stu1 = Student('骆昊', 38)
        # 给对象发study消息
        stu1.study('Python程序设计')
        # 给对象发watch_av消息
        stu1.watch_av()
        stu2 = Student('王大锤', 15)
        stu2.study('思想品德')
        stu2.watch_av()
     if __name__ == '__main__'
     	main()

**访问可见性问题**  
—在Python中，属性和方法的访问权限只有两种，也就是公开的和私有的，如果希望属性是私有的，在给属性命名时可以用两个下划线作为开头

class Test:
    
        def __init__(self, foo):
            self.__foo = foo
    
        def __bar(self):
            print(self.__foo)
            print('__bar')
    def main():
        test = Test('hello')
        # AttributeError: 'Test' object has no attribute '__bar'
        test.__bar()
        # AttributeError: 'Test' object has no attribute '__foo'
        print(test.__foo)
    
    if __name__ == "__main__":
        main()

\*\*\*\* Python不允许实例化的类访问私有数据，但你可以使用 object.\_className\_\_attrName（ 对象名.\_类名\_\_私有属性名 ）访问属性

***练习***

import time
    class Clock(object):
        """数字时钟"""
    
        def __init__(self, hour=0, minute=0, second=0):
            """初始化方法
    
            :param hour: 时
            :param minute: 分
            :param second: 秒
            """
            self._hour = hour
            self._minute = minute
            self._second = second
    
        def run(self):
            """走字"""
            self._second += 1
            if self._second == 60:
                self._second = 0
                self._minute += 1
                if self._minute == 60:
                    self._minute = 0
                    self._hour += 1
                    if self._hour == 24:
                        self._hour = 0
    
        def __str__(self):
            """显示时间"""
            return '%02d:%02d:%02d' % \
                   (self._hour, self._minute, self._second)
    
    
    def main():
        clock = Clock(23, 59, 58)
        while True:
            print(clock)
            time.sleep(0.2)
            clock.run()
    
    
    if __name__ == '__main__':
        main()

***面向对象进阶***  
@property装饰器：  
—我们之前的建议是将属性命名以单下划线开头，通过这种方式来暗示属性是受保护的，不建议外界直接访问，那么如果想访问属性可以通过属性的getter（访问器）和setter（修改器）方法进行对应的操作。如果要做到这点，就可以考虑使用@property包装器来包装getter和setter方法，使得对属性的访问既安全又方便

class Person(object):
    
        def __init__(self, name, age):
            self._name = name
            self._age = age
    
        # 访问器 - getter方法
        @property
        def name(self):
            return self._name
    
        # 访问器 - getter方法
        @property
        def age(self):
            return self._age
    
        # 修改器 - setter方法
        @age.setter
        def age(self, age):
            self._age = age
    
        def play(self):
            if self._age <= 16:
                print('%s正在玩飞行棋.' % self._name)
            else:
                print('%s正在玩斗地主.' % self._name)
    
    
    def main():
        person = Person('王大锤', 12)
        person.play()
        person.age = 22
        person.play()
        # person.name = '白元芳'  # AttributeError: can't set attribute
    
    
    if __name__ == '__main__':
        main()

***\_\_slots\_\_魔法***  
—Python是一门动态语言。通常，动态语言允许我们在程序运行时给对象绑定新的属性或方法，当然也可以对已经绑定的属性和方法进行解绑定。但是如果我们需要限定自定义类型的对象只能绑定某些属性，可以通过在类中定义\_\_slots\_\_变量来进行限定。需要注意的是\_\_slots\_\_的限定只对当前类的对象生效，对子类并不起任何作用。

class Person(object):
    
        # 限定Person对象只能绑定_name, _age和_gender属性
        __slots__ = ('_name', '_age', '_gender')
    
        def __init__(self, name, age):
            self._name = name
            self._age = age
    
        @property
        def name(self):
            return self._name
    
        @property
        def age(self):
            return self._age
    
        @age.setter
        def age(self, age):
            self._age = age
    
        def play(self):
            if self._age <= 16:
                print('%s正在玩飞行棋.' % self._name)
            else:
                print('%s正在玩斗地主.' % self._name)
    
    
    def main():
        person = Person('王大锤', 22)
        person.play()
        person._gender = '男'
    if __name__ == "__main__":
        main()

***静态方法和类方法***

from math import sqrt
    
    
    class Triangle(object):
    
        def __init__(self, a, b, c):
            self._a = a
            self._b = b
            self._c = c
    
        @staticmethod
        def is_valid(a, b, c):
            return a + b > c and b + c > a and a + c > b
    
        def perimeter(self):
            return self._a + self._b + self._c
    
        def area(self):
            half = self.perimeter() / 2
            return sqrt(half * (half - self._a) *
                        (half - self._b) * (half - self._c))
    
    
    def main():
        a, b, c = 3, 4, 5
        # 静态方法和类方法都是通过给类发消息来调用的
        if Triangle.is_valid(a, b, c):
            t = Triangle(a, b, c)
            print(t.perimeter())
            # 也可以通过给类发消息来调用对象方法但是要传入接收消息的对象作为参数
            # print(Triangle.perimeter(t))
            print(t.area())
            # print(Triangle.area(t))
        else:
            print('无法构成三角形.')
    
    
    if __name__ == '__main__':
        main()

\----Python还可以在类中定义类方法，类方法的第一个参数约定名为cls，它代表的是当前类相关的信息的对象（类本身也是一个对象，有的地方也称之为类的元数据对象），通过这个参数我们可以获取和类相关的信息并且可以创建出类的对象

from time import time, localtime, sleep
    
    
    class Clock(object):
        """数字时钟"""
    
        def __init__(self, hour=0, minute=0, second=0):
            self._hour = hour
            self._minute = minute
            self._second = second
    
        @classmethod
        def now(cls):
            ctime = localtime(time())
            return cls(ctime.tm_hour, ctime.tm_min, ctime.tm_sec)
    
        def run(self):
            """走字"""
            self._second += 1
            if self._second == 60:
                self._second = 0
                self._minute += 1
                if self._minute == 60:
                    self._minute = 0
                    self._hour += 1
                    if self._hour == 24:
                        self._hour = 0
    
        def show(self):
            """显示时间"""
            return '%02d:%02d:%02d' % \
                   (self._hour, self._minute, self._second)
    
    
    def main():
        # 通过类方法创建对象并获取系统时间
        clock = Clock.now()
        while True:
            print(clock.show())
            sleep(1)
            clock.run()
    
    
    if __name__ == '__main__':
        main()

***类之间的关系***  
简单的说，类和类之间的关系有三种：is-a、has-a和use-a关系  
\-----is-a关系也叫继承或泛化，比如学生和人的关系、手机和电子产品的关系都属于继承关系。  
\-----has-a关系通常称之为关联，比如部门和员工的关系，汽车和引擎的关系都属于关联关系；关联关系如果是整体和部分的关联，那么我们称之为聚合关系；如果整体进一步负责了部分的生命周期（整体和部分是不可分割的，同时同在也同时消亡），那么这种就是最强的关联关系，我们称之为合成关系。  
\-----use-a关系通常称之为依赖，比如司机有一个驾驶的行为（方法），其中（的参数）使用到了汽车，那么司机和汽车的关系就是依赖关系。

***继承和多态***  
—提供继承信息的我们称之为父类，也叫超类或基类；得到继承信息的我们称之为子类，也叫派生类或衍生类。子类除了继承父类提供的属性和方法，还可以定义自己特有的属性和方法，所以子类比父类拥有的更多的能力，在实际开发中，我们经常会用子类对象去替换掉一个父类对象，这是面向对象编程中一个常见的行为，对应的原则称之为里氏替换原则。

class Person(object):
        """人"""
    
        def __init__(self, name, age):
            self._name = name
            self._age = age
    
        @property
        def name(self):
            return self._name
    
        @property
        def age(self):
            return self._age
    
        @age.setter
        def age(self, age):
            self._age = age
    
        def play(self):
            print('%s正在愉快的玩耍.' % self._name)
    
        def watch_av(self):
            if self._age >= 18:
                print('%s正在观看爱情动作片.' % self._name)
            else:
                print('%s只能观看《熊出没》.' % self._name)
    
    
    class Student(Person):
        """学生"""
    
        def __init__(self, name, age, grade):
            super().__init__(name, age)
            self._grade = grade
    
        @property
        def grade(self):
            return self._grade
    
        @grade.setter
        def grade(self, grade):
            self._grade = grade
    
        def study(self, course):
            print('%s的%s正在学习%s.' % (self._grade, self._name, course))
    
    
    class Teacher(Person):
        """老师"""
    
        def __init__(self, name, age, title):
            super().__init__(name, age)
            self._title = title
    
        @property
        def title(self):
            return self._title
    
        @title.setter
        def title(self, title):
            self._title = title
    
        def teach(self, course):
            print('%s%s正在讲%s.' % (self._name, self._title, course))
    
    
    def main():
        stu = Student('王大锤', 15, '初三')
        stu.study('数学')
        stu.watch_av()
        t = Teacher('骆昊', 38, '老叫兽')
        t.teach('Python程序设计')
        t.watch_av()
    
    
    if __name__ == '__main__':
        main()

子类在继承了父类的方法后，可以对父类已有的方法给出新的实现版本，这个动作称之为方法重写（override）。通过方法重写我们可以让父类的同一个行为在子类中拥有不同的实现版本，当我们调用这个经过子类重写的方法时，不同的子类对象会表现出不同的行为，这个就是多态