面向对象

面向对象

面向对象：万物皆对象，把一切看成对象，都可以用对象的属性和方法来描述事务

对象的两个特征：属性和方法

什么是类：把拥有相同属性和行为的对象分为一组即为一个类，类是用来创建实例对象的

类的创建语句 class 语句

class 类名（继承列表）:
    '''类的文档字符串'''
    __init__初始化方法
    实例方法
    类变量
    类方法（@classmethod）
	静态方法(@staticmethod) 
    
#对象创建，调用类的构造方法，每个创建的对象都有自己作用域，可以为该实例添加实例变量
#构造方法 类名（[调用传参]）
对象 = 类名（[实参列表]）

初始化方法

初始化方法
  作用:
    对新创建的对象添加属性

  格式:
    class 类名(继承列表):
        def __init__(self, 形参列表):
            语句块
  说明:
    1. 初始化方法名必须为'__init__' 不可改变
    2. 初始化方法会在构造函数创建实例后自动调用,且将实例自身通过第一个参数self传入'__init__'方法
    3. 构造函数的实参将通过__init__方法的形参列表传入到'__init__'方法中
    4. 初始化方法必须返回None

实例方法

实例方法(instance method)
  定义语法:
    class 类名(继承列表):
        def 实例方法名(self, 形参列表):
            语句块     
 作用:
    用于描述一个对象的行为,让此类型的全部对象都拥有相同的行为
  说明:
    1. 实例方法的实质是函数,是定义在类内的函数
    2. 实例方法至少有一个形参,第一个形参绑定调用这个方法的实例,一般命名为'self'           

析构方法

析构方法:
  class 类名(继承列表):
      def __del__(self):
          ....
作用:
    在对象销毁时释放对象占用的资源
  说明:
    析构方法会在对象销毁前被自动调用
    python语言建议不要在对象销毁时做任何事情,因为销毁的时间难以确定，不建议在析构方法中任何操作        

类变量

类变量
  类变量是类的属性,此属性属于类,不属于类的实例

  作用:
    通常用来存储该类创建的对象的共有属性
  说明:
    类变量可以通过该类直接访问
    类变量可以通过类的实例直接访问(取值)
    类变量可以通过此类的对象的__class__属性间接访问

类方法 @classmethod

类方法 @classmethod
  类方法是用于描述类的行为的方法,类方法属于类,不属于该类创建的实例对象

  说明:
    1. 类方法需要使用@classmethod装饰器定义
    2. 类方法至少有一个形参,第一个形参用于绑定类,约定写为'cls'
    3. 类和该类的实例都可以调用类方法
    4. 类方法不能访问此类创建的对象的实例属性

静态方法 @staticmethod

静态方法@staticmethod
  静态方法是定义在类的内部的函数,此函数的作用域是类的内部

  说明:
    1. 静态方法需要使用@staticmethod装饰器定义
    2. 静态方法与普通函数定义相同,不需要传入'self'和'cls' 参数
    3. 静态方法只能该类或类的实例调用
    4. 静态方法不能访问类变量和实例变量

实例对象预置属性和方法

属性	说明
__dict__	绑定存储此实例对象的属性的字典
__class__	绑定创建此实例对象的类
实例对象的方法
isinstance(对象, 类或元组)	判断实例对象是否属于某个类或某些类的一个类的实例
type(对象)	返回一个对象的类

类的预置属性和方法

属性	说明
__doc__	类的文档字符串
__slots__	限定一个类创建的实例只能有固定的实例属性，__slots__属性是一个列表,列表的值是字符串
__base__	用来绑定此类的基类（父类）
__mro__	在多继承中， 用来保存父类的调用顺序,能够保证每个父类都会被调用,而且只被调用一次
类的方法
issubclass(cls, 类或元组)	判断此类是否属于某个类或某些类的一个类的子类

__slots__的用法

# slots.py

# 此示例示意类内的__slots__列表的用法
class Human:
    # 限制Human类的对象只能有"name", 和"age"属性,不能有其它属性
    __slots__ = ['name', 'age']
    def __init__(self, n, a):
        self.name, self.age = n, a
    def show_info(self):
        print(self.name, self.age)

s1 = Human("Tarena", 15)
s1.show_info()  # Tarena 15
#s1.Age = 16  # 报错
#s1.show_info()  # 'Human' object has no attribute 'Age'
# print(s1.__dict__)  #__slots__类创建的属性没有__dict__属性

面向对象的三大特征

面向对象的三大特征：继承，封装，多态

继承

继承是从已有的类中派生出新的类,新类具有原类的属性和行为,并能扩展新的能力

作用: 用继承派生机制,可以将一些共有功能加在基类中,实现代码的共享

class Human(object):
    '''此类用于描述人类的共性'''
    def say(self, what):
        print("say:", what)

    def walk(self, distance):
        print("走了", distance, "公里")

class Student(Human):
    def study(self, subject):
        print("正在学习:", subject)

h1 = Human()
h1.say("天真蓝")
h1.walk(5)

s1 = Student()
s1.say("学习有点累")
s1.walk(1)
s1.study("Python")

多继承

多继承是指一个子类继承自两个或两个以上的父类(基类)

说明:
1. 一个子类同时继承自多个父类,父类中的方法可以同时被继承下来
2. 如果两个父类中有同名的方法,而在子类中又没有覆盖此方法,调用结果难以确定

# multi_inherit.py

# 此示例示意多继承的语法
class Car:
    def run(self, speed):
        print("汽车以", speed, "km/h的速度行驶")

class Plane:
    def fly(self, height):
        print("飞机以海拔", height, "米高度飞行")

class PlaneCar(Car, Plane):
    """PlaneCar类同时继承自汽车类和飞机类"""


p1 = PlaneCar()
p1.fly(10000)
p1.run(300)

覆盖

覆盖是指在有继承关系的类中,子类中实现了与基类同名的方法,在子类的实例调用该方法时,实际调用的是子类中覆盖版本,这种现象叫做覆盖

# override.py

# 此示例示意覆盖的语法
class A:
    def work(self):
        print("A.work被调用")

class B(A):
    def work(self):
        '''此方法会覆盖父类的work方法'''
        print("B.work被调用")

b = B()
b.work()  # B.work被调用

a = A()
a.work()  # A.work被调用

super函数

super(cls, obj) 返回绑定超类的实例(要求obj必须是cls类型的实例)

super() 返回绑定超类的实例，必须在方法内调用

# super_init.py

# 此示例示意用super函数显式调用基类的初始化方法
class Human:
    def __init__(self, n, a):
        self.name = n
        self.age = a
        print("Human.__init__被调用")

    def show_info(self):
        print("姓名:", self.name)
        print("年龄:", self.age)

class Student(Human):
    def __init__(self, n, a, s=0):
        super().__init__(n, a)
        self.score = s
        print("Student.__init__被调用")
        
    def show_info(self):
        super().show_info()
        print("成绩:", self.score)

s = Student("小张", 20, 100)
s.show_info()

封装 enclosure

封装是指隐藏类的实现细节,让使用者不用关心类的实现细节
封装的目的是让使用者通过尽可能少的方法或属性来操作对象

私有属性和方法

python类中以双下划线(’__’) 开头,不以双下划线结尾的标识符为私有成员,私有成员只能使用方法来进行访问和修改

以’__’ 开头的属性为私有属性

以’__’ 开头的方法为私有方法

# enclosure.py

class A:
    def __init__(self):
        self.__p1 = 100  # 私有属性

    def __m(self):
        '''这是私有方法,此方法只能用此类的方法来调用,不能在其它地方调用'''
        print("A.__m方法被调用")

    def dowork(self):
        '''此方法可以调用私有实例变量和实例方法'''
        self.__m()
        print("dowork内.self.__p1=", self.__p1)

class B(A):
    '''此类示意子类不能调用父类的私有成员'''
    def test(self):
        self.__m()  # 出错
        print(self.__p1)  # 出错

a = A()
# print(a.__p1)  # 错误,不允许访问私有属性
# a.__m()  # 无法调用
a.dowork()

b = B()
# b.test()  # 出错

多态

多态, 不同的 子类对象调用 相同的 父类方法，产生 不同的 执行结果，可以增加代码的外部 调用灵活度，
多态以 继承 和 重写 父类方法 为前提
多态是调用方法的技巧，不会影响到类的内部设计

# poly.py

# 此示例示意多态中的多态
class Shape:
    '''此类描述图形类的共有属性和方法'''
    def draw(self):
        print("Shape.draw被调用")
class Point(Shape):  # 点类
    def draw(self):
        print("Point.draw被调用")
class Circle(Point):
    def draw(self):
        print("Circle.draw被调用")

def my_draw(s):
    s.draw()  # 此处显示出多态中的动态

s1 = Circle()
s2 = Point()
my_draw(s2)
my_draw(s1)