python学习总结---面向对象2

面向对象三大特点

- 封装：既是对数据结构的封装，有是处理数据的方法的封装。
- 继承：强调的父子类的关系。
- 多态：不同对象调用相同的方法，有不同的响应。

类的继承

- 相关概念
  - 继承：父类的方法和属性，子类直接拥有，称为继承。
  - 派生：子类在父类的基础上衍生出新的特征(属性和行为)。
  - 总结：其实他们是一回事，只是描述问题的角度不同(继承强调相同点，派生强调不同点)
- 继承语法：
      # class Animal:
      # 当没有写父类时，默认继承自object
      class Animal(object):
          def __init__(self, name):
              self.name = name

          def run(self):
              print('小动物喜欢一天到晚跑个不停')

      # 继承自另一个类
      class Dog(Animal):
          pass

      d = Dog('旺财')
      # 直接拥有父类的属性
      print(d.name)
      # 也拥有父类的行为
      d.run()
- 派生示例
      class Animal:
          def run(self):
              print('一天到晚不停的跑')

      class Cat(Animal):
          def eat(self):
              print('猫喜欢吃鱼')

      c = Cat()

      # 继承的方法
      c.run()
      # 衍生的发生
      c.eat()
      # 动态添加属性
      c.color = '白色'
      print(c.color)            

- 方法重写
  - 父类的方法完全不合适，可以覆盖重写
  - 父类的不是完全合适，可以添加完善
  - 示例
      class Animal:
          def eat(self):
              print('小动物一天到晚吃个不停')

      	def run(self):
      		print('小动物一天到晚跑个不停')

      class Cat(Animal):
          # 完全不合适，覆盖重写
          def run(self):
              print('俺走的是猫步')

      	# 父类的方法不够完善，需要添加完善
          def eat(self):
              # 保留父类方法中的内容
              # Animal.eat(self)  # 不建议使用
              # super(Cat, self).eat()
              # 简化方案，推荐使用
              super().eat()
              print('俺喜欢吃鱼')

      c = Cat()
      c.run()
      c.eat()
- 多继承：一个类可以有多个父类
      class A:
          def eat(self):
              print('eat func in class A')

      class B:
          def eat(self):
              print('eat func in class B')

          def test(self):
              print('test func in class B')

      class C(A, B):
          def eat(self):
              # 不重写方法，或者使用super，都是按照书写的先后顺序
              # 默认会使用前面的类的方法
              # super().eat()
              # 明确指定调用哪个父类的方法
              B.eat(self)

      c = C()

      c.eat()
      c.test()  

- 访问权限
  - 权限
    - 公有的：类中的普通的属性和方法，默认都是公有的；可以在类外、类内以及子类中使用。
    - 私有的：定义时在前面添加两个下划线即可，只能在本类中使用，类外及子类中不能使用
  - 示例
          class Person:
              def __init__(self, name):
                  self.name = name
                  self.__age = 20

              def test(self):
                  # 可以在类的内部使用
                  print(self.__age)

              def __hello(self):
                  print('hello world!')

          class Man(Person):
              def introduce(self):
                  # 私有属性不能在子类中使用
                  print('我叫{}，今年{}岁'.format(self.name, self.__age))

          p = Person('小明')
          # print(p.name)
          # 当属性前添加两个下划线后，无法在外部访问
          # print(p.age)
          # print(p.__age)
          # print(p.__dict__)
          # 默认加两个下划线的属性名前面添加了'_类名'
          # 不建议访问
          # print(p._Person__age)
          # p.test()

          # p.__hello()

          m = Man('ergou')
          # m.introduce()
          print(m.__dict__)
- 类属性
  - 说明：定义在类中，但是在方法外的属性，通常会放在类的开头，这样的属性称为类属性
  - 示例：
        class Person:
            # 类属性
            # nation = '中国'

            # 限制对象可以使用的属性，可以提高访问的效率
            __slots__ = ('name', 'age', 'nation')

            def __init__(self, name):
                self.name = name
                self.nation = 'china'

      # 通过类名访问类属性
      print(Person.nation)
      p = Person('小明')
      print(p.name)
      # 通过对象也可以访问类属性，但是不建议
      print(p.nation)

      # 特殊的类属性

      # 类名字符串
      print(Person.__name__)

      # 基类组成的元组
      print(Person.__bases__)

      # 类相关的信息
      print(Person.__dict__)

      print(Person.__slots__)

      p.age = 20
      # p.xxx = 'yyy'        

- 类方法
  - 说明：
    - 通过类名调用的方法
    - 定义时通过装饰器classmethod进行装饰的方法
  - 作用：
    - 可以创建对象或简洁的创建对象
    - 可以对外提供简洁易用的接口
  - 示例1：创建对象
          class Person:
              def eat(self):
                  print('我喜欢吃麻辣烫，不要麻椒和辣椒')

              # 定义类方法
              @classmethod
              def test(cls):
                  # cls：表示当前类
                  print(cls, '类方法')

              @classmethod
              def create(cls):
                  p = cls()
                  p.age = 1
                  return p

          xiaoming = Person()
          xiaoming.eat()

          # 类方法通过类名调用
          Person.test()

          # 创建或简洁的创建对象
          xiaohua = Person.create()
          print(xiaohua.age)

- 示例2：对外提供简单易用的接口
      class Number:
          def __init__(self, num1, num2):
              self.num1 = num1
              self.num2 = num2

          def add(self):
              return self.num1 + self.num2

          def sub(self):
              return self.num1 - self.num2

          def mul(self):
              return self.num1 * self.num2

          def div(self):
              if self.num2 == 0:
                  return None
              return self.num1 / self.num2

          @classmethod
          def pingfanghe(cls, num1, num2):
              n1 = cls(num1, num1)
              n12 = n1.mul()

              n2 = cls(num2, num2)
              n22 = n2.mul()

              n3 = cls(n12, n22)
              return n3.add()

      ret = Number.pingfanghe(3, 4)
      print(ret)

- 静态方法
  - 说明：
    - 定义时通过装饰器staticmethod装饰的方法
    - 也是通过类名进行调用
  - 示例
        class Person:
            @staticmethod
            def test():
                print('static method test')

            # 也可以创建对象
            @staticmethod
            def create():
                p = Person()
                p.age = 20
                return p

        Person.test()
        p = Person.create()
        print(type(p))

- 总结：
  - 凡是静态方法能够完成的功能都可使用类方法进行完成
  - 若方法中没有使用到类名(cls)，都可以使用静态方法
- 多态特性
  - 定义：不同的对象，调用调用相同的方法，有不同的响应。
  - 示例：
        class Animal:
            def run(self):
                print('小动物走道都不一样')

        class Dog(Animal):
            def run(self):
                print('狗通常走S型')

        class Cat(Animal):
            def run(self):
                print('猫一般走猫步')

        def func(obj):
            obj.run()

        func(Cat())
        func(Dog())
- 属性函数
  - 说明：将成员方法当做属性一样进行访问。
  - 作用：保护特定属性，或者对属性进行特定的处理。
  - 示例：
        class User:
            def __init__(self, username, password):
                self.username = username
                self.__password = password

            # 可以保护指定的属性
            @property
            def password(self):
                print('有人想偷看密码')
                return '想看密码，没门'

            # 设置属性时，自动调用
            @password.setter
            def password(self, password):
                print('加密存储密码')
                self.__password = '加密' + password + '加密'

        u = User('xiaoming', '123456')
        print(u.username, u.password)

        u.password = 'abcd'
        print(u.__dict__)