面向对象

面向对象是一种编程思想, 即按照真实世界的思维方式构建软件系统.

定义类

class 类名[(父类)]:
    类体

创建对象

用类创建对象的过程称为实例化, 是将类这个抽象的概念具体到该类实物的过程.

class Car:  # class Car(object):
    pass    # 类体


car = Car()

类的成员

• 实例变量 -- 对象个体特有的"数据".

• 构造方法 -- __init__ 用来创建和初始化实例变量.

• 实例方法 -- 某个实例或对象个体特有的方法.

• 类变量 -- 变量属于类, 不属于单个对象.

• 类方法 -- @classmethod 方法属于类, 不属于实例.

  class Dog:
      family = "犬科"  # 创建和初始化类变量family
  
      def __init__(self, name, age, sex='M'):  # 定义构造方法
          self.name = name  # 创建和初始化实例变量name
          self.age = age    # 创建和初始化实例变量age
          self.sex = sex    # 创建和初始化实例变量sex
  
      @classmethod  # 装饰器
      def show_family(cls):  # 定义类方法
          print(cls.family)
  
      def show_info(self):  # 定义实例方法
          print(self.name, self.age, self.sex)
  
      def bark(self, sound):
          print(self.name, "在叫:", sound, sep='')
  
  
  d = Dog("球球", 2)
  Dog.show_family()  # 犬科
  d.show_info()      # 球球 2 M
  d.bark("汪!")      # 球球在叫:汪!
  

面向对象的特性

封装性

• 私有变量:

  防止外部调用者随意存取类的内部数据(成员变量), 内部数据会被封装为"私有变量".

• 私有方法:

  不可以在类的外部访问私有方法.

• 属性:

  为了实现对象的封装, 在一个类中成员变量应该被设计为私有的, 然后通过公有方法访问.

  class Account:
      __interest_rate = 0.0568  # 私有类变量
  
      def __init__(self, owner, amount):
          self.owner = owner      # 公有实例变量
          self.__amount = amount  # 私有实例变量
  
      @property
      def amount(self):  # 定义amount属性的get()方法. 方法名就是属性名, 即amount.
          return self.__amount
  
      @amount.setter
      def amount(self, amount):  # 定义set()方法, 使用@属性.setter修饰器进行修饰.
          self.__amount = amount
  
      def __get_info(self):  # 私有实例方法
          print("{0} 金额: {1} 利率: {2}. ".format(self.owner,
                                               self.__amount,
                                               Account.__interest_rate))
  
      def desc(self):  # 公有实例方法
          self.__get_info()
  
  
  account = Account("Tony", 800.0)
  print(account.amount)  # 800.0
  account.desc()         # Tony 金额: 800.0 利率: 0.0568.
  account.amount = 500.0
  account.desc()         # Tony 金额: 500.0 利率: 0.0568. 
  

继承性

1. 子类继承父类: 特殊类拥有一般类的全部数据和操作.

   class Animal:
       def __init__(self, name):
           self.name = name  # 实例变量
           print("Animal_1")
   
       def show_info(self):
           print(self.name)
   
   
   class Cat(Animal):
       def __init__(self, name, age):
           super(Cat, self).__init__(name)  # 首先找到父类, 然后把父类的对象转换为子类的对象.
           self.age = age
           print("Cat_1")
   
       def show_info(self):
           super(Cat, self).show_info()
           print(self.age)
           # print(self.name, self.age) 方法重写
   
   cat = Cat("Tom", 2)
   cat.show_info()
   animal = Animal("John")
   animal.show_info()
   
   # Animal_1
   # Cat_1
   # Tom
   # 2
   # Animal_1
   # John
   

2. 多继承

   class Horse:
       def __init__(self, name):
           self.name = name
           
       def show_info(self):
           print(self.name)
           
       def run(self):
           print("马跑...")
   
   
   class Donkey:
       def __init__(self, name):
           self.name = name
   
       def show_info(self):
           print(self.name)
   
       def run(self):
           print("驴跑...")
           
       def roll(self):
           print("驴打滚...")
   
   
   class Mule(Horse, Donkey):
       def __init__(self, name):
           super(Mule, self).__init__(name)
   
   
   m = Mule("骡宝莉")
   m.show_info()  # 继承Horse的方法
   m.run()        # 继承Horse的方法
   m.roll()       # 继承Donkey的方法
   

多态性

多态性指对象可以表现出多种形态.

1. 在多个子类继承父类, 并重写父类方法后, 这些子类所创建的对象之间就是多态的.

2. Python 支持鸭子类型测试^[1], Python解释器不检查发生多态的对象是否继承了同一个父类, 只要它们有相同的方法, 它们之间就是多态的.

   class Animal:
       def speak(self):
           print("某种叫声")
   
   
   class Cat(Animal):
       def speak(self):
           print("猫叫")
   
   
   class Dog(Animal):
       def speak(self):
           print("狗叫")
   
   
   class Car:
       def speak(self):
           print("鸣笛")
   
   
   def start(obj):
       obj.speak()  # obj对象指向访问的属性名或方法
   
   
   an1 = Cat()
   an2 = Dog()
   car = Car()
   start(an1)
   start(an2)
   start(car)
   

---

1. 一个东西如果它看起来像鸭子, 走起来像鸭子, 叫起来也像鸭子, 那么它就是鸭子. ↩︎

标签：__,name,Python,self,面向对象,amount,print,def
来源： https://www.cnblogs.com/khrushchefox/p/16600348.html