Python基础—12-面向对象（02）

面向对象

面向对象三大特点

  • 封装：既可对数据结构进行封装，又可对处理数据的方法进行封装
  • 继承：强调的父子类的关系
  • 多态：不同对象调用相同的方法，会有不同的响应

类的继承

  • 相关概念

    • 继承：父类的属性和方法，子类直接拥有，称为继承
    • 派生：子类在父类的基础上衍生出新的特征(属性和行为)
    • 总结：其实他们是一回事，只是描述问题的侧重点不同(继承强调相同点，派生强调不同点)

  • 继承语法

    # class Animal(object):
# 当没有指定父类时，默认继承object
class Animal:
    def __init__(self, name):
        self.name = name

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

# 继承自Animal
class Dog(Animal):
    pass

d = Dog('旺财')
# 可以拥有父类的方法
d.eat()
# 也可以拥有父类的属性
print(d.name)

     

  • 派生示例

    class Animal:
    def run(self):
        print('小动物喜欢成天跑个不停')

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

tom = Cat()

tom.run()
# 多出来的行为
tom.eat()

# 多出来的属性
tom.color = '蓝色'
print(tom.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()
        # 类名及self可以不传
        super().eat()
        print('不过俺喜欢吃鱼')

jiafei = Cat()
jiafei.run()
jiafei.eat()

     

  • 多继承：一个子类可以拥有多个父类

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

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

class C(A, B):
    def eat(self):
        # 这种方案是默认的继承顺序进行选择的父类方法
        # super().eat()
        # 人为指定调用某个父类的方法
        B.eat(self)

c = C()
c.eat()

     

访问权限

  • 权限

    • 公有的：类中的普通的属性和方法，默认都是公有的；可以在类内、类外、子类中使用
    • 私有的：定义时在前面添加两个'_'，就变成了私有的；只能在类内使用，不能在类外及子类中使用

  • 示例：

    class Person:
    def __init__(self, name):
        self.name = name
        self.__age = 20

    def eat(self):
        print('民以食为天')

    def __test(self):
        print('__test')
        
    
xiaoming = Person('小明')
print(xiaoming.name)
xiaoming.eat()
# 不能在类外使用
print(xiaoming.__age)
xiaoming._Person__test()
print(xiaoming.dict)
# 尽管可以这样访问私有属性，但是强烈建议不要这样使用
print(xiaoming._Person__age)

class Man(Person):
    def introduce(self):
      # 不能在子类中使用
      # print(self.__age)
      print('我叫{}'.format(self.name))
      self.eat()   
        
m = Man('诸葛')
m.introduce()

     

类属性

  • 说明：定义类时，写在方法外的属性，通常会写在类的开头，这样的属性称为类属性

  • 示例：

    class Person:
      # 类属性，通过类名访问，属于整个类，而不是某个对象
      # nation = '中国'

      # 限制可以使用的属性，提高访问的效率
      # 也可以提高访问速度，减少内存使用
      __slots__ = ('name', 'age', 'nation')

      def __init__(self, name):
          self.name = name
          self.nation = 'china'
        
p1 = Person('小明')
p2 = Person('小红')
print(p1.name, p2.name)
print(Person.nation)
# p1.nation = 'china'
print(p1.nation)
print(p2.nation)
# print(Person.nation)

p1.age = 20
# p1.height = 180

# 特殊的类属性
# 表示类名的字符串
print(Person.__name__)

# 表示父类构成的元组
print(Person.__bases__)

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

# 限制可以使用的属性
print(Person.__slots__)

     

类方法

  • 说明：

    • 定义时使用classmethod装饰器装饰的方法
    • 使用时通过类名调用

  • 作用：

    • 可以创建对象或者简洁的创建对象
    • 对外提供简单易用的接口

  • 示例1：创建对象

    class Person:
      def eat(self):
          print('我喜欢吃麻辣烫，不要麻椒和辣椒')

      @classmethod
      def test(cls):
          print(cls)
          print('类方法')

      # 创建对象，或者简洁的创建对象
      @classmethod
      def create(cls):
          p = cls()
          p.age = 1
          return p

  p1 = Person()
  p1.eat()

  # 通过类名调用
  Person.test()
  # 创建或简洁的创建对象
  p2 = Person.create()
  print(type(p2))

     

  • 示例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()
    
he = Number.pingfanghe(3, 4)
print(he)

     

静态方法

  • 说明：

    • 使用staticmethod装饰器装饰的方法(方法没有cls参数)
    • 通过类名进行调用

  • 示例：

    class Person:
    @staticmethod
    def test():
        print('static method test')

    # 创建对象
    @staticmethod
    def create():
        p = Person()
        return p
    
Person.test()
p = Person.create()
print(p)

     

  • 总结：

    • 凡是静态方法完成的功能都可以是类方法完成
    • 若方法中没有使用到类名(cls)，可以使用静态方法

多态特性

  • 定义：不同的对象，调用相同的方法，有不同的响应，称为多态

  • 示例：

    class Animal:
    def run(self):
        pass
    
class Dog(Animal):   
    def run(self):
          print('狗通常走S型')
        
class Cat(Animal):
    def run(self):
          print('猫平时走猫步，偶尔突然加速')

def test(obj):
    obj.run()
    
d = Dog()
c = Cat()
test(d)
test(c)

     

属性函数

  • 说明：将成员方法当做属性一样进行访问

  • 作用：保护特定属性，或者对特定属性进行处理

  • 示例：

    class User:
      def __init__(self, username, password):
          self.username = username
          self.__password = password

      # 该方法可以像成员属性一样访问
      @property
      def password(self):
          print('有人想查看密码')
          return '想偷看密码，没门'
          # return self.__password

      # 在设置密码时，会自动调用
      @password.setter
      def password(self, password):
          print('@password.setter', password)
          self.__password = '加密' + password + '加密'
        
u = User('xiaoming', '111111')
# print(u.password())
print(u.password)

# 设置密码，会自动调用setter方法
u.password = 'abcde'

     

posted @ 2018-09-20 16:24  Sunwj_Monkey  阅读(200)  评论(0)  编辑  收藏  举报