面向对象

十八、面向对象（oop）

面向过程编程POP（Procedure-Oriented Programming）

面向对象编程OOP（Object Oriented Programming）

（1）类的定义：

​ 第一种定义方式

​ class Car:

​ pass

​ 第二种定义方式

​ class Car():

​ pass

​ 第三种定义方式

​ class Car(object):

​ pass

（2）类的实例化

​ class Car():

​ pass

​ obj = Car()

（3）类的基本结构

​ 类中有两种成员：

​ 成员属性

​ 成员方法

（4）类的命名推荐使用大驼峰命名法，即每个单词的首字母大写

（5）面向对象编程的三大属性：封装、继承、多态

注：类中的代码啊可以直接执行，但是严禁使用，不要直接把代码裸漏在类中，把相应的逻辑放在成员方法中处理；

class Car:
	pass
	
class Car():
	pass

class Car(object):
	pass

obj = Car()

1、面向对象之封装

（1）类中的封装：成员属性、成员方法

（2）成员属性的定义：

​ 公有属性：成员属性的定义公有的成员属性，就是直接定义：mycolor = “1234”

​ 私有属性：成员属性的定义私有的成员属性，通过两个下划线定义：__mycolor = “1234”

（3）成员方法的定义：

​ 公有方法：成员方法的定义公有的成员属性，就是直接定义：def myFunc() :

​ 私有方法：成员方法的定义私有的成员属性，通过两个下划线定义：def __myFunc()：

（4）封装等级

​ 公有成员既能在类外调用，也能在类内调用

​ 私有成员只能在类内进行调用，不能在类外进行调用

（5）类中的绑定方法（方法在类的内部）

​ 绑定到对象：对象调用方法时，系统自动把该对象当成参数进行传递

​ 绑定到类：对象或者类调用方法时，系统自动把该类当成参数进行传递

（6）注：对象在调用方法时，系统会自动把该对象当成参数传递到该方法中，为了保证形参和实参一一对应，在定义方法的时候，要叫形参self，这个方法也叫绑定方法（绑定到对象）

（7）实例化的对象能动态添加公有的成员属性和成员方法

​ 注：动态添加的只能是公有的属性和方法，不能是私有的属性和方法

（8）通过__dict__方法查看对象或者类当中的成员，返回一个字典

​ 对象只会返回对象中的成员属性和成员方法

​ 类中只会返回类中的成员属性和成员方法

（9）对象调用的优先级

​ 调用对象的成员时，先看看自己有没有该成员

​ 有就现调用自己，没有就调用类中的，类中没有就报错

（10）类和对象之间的注意点

​ 类中的成员只归属于当前这个类本身，对象可以调用其中的公有成员，但不能进行修改和删除，类中的成员不属于对象中，对象和类是两个不同的空间。

​ 类无法调用对象中的相关成员，但是对象可以调用类中的公有成员

# 公有属性和私有属性
class Car:
    color = "黑色的"
    __logo = "the car"

    def drive(self):
        print("我的小车可以载货，可以超速跑高速", self.color)

    def __info(self):
        print("我的车牌是保密的，价格和耗油量也是保密的")


obj = Car()
print(obj.color)
obj.drive()

# 添加成员属性
obj.color = "白色的"
print(obj.color)
print(Car.__dict__)
print(obj.__dict__)

# 添加成员方法
def chegulu(color):
    print("{}车轱辘".format(color))

obj.chegulu = chegulu
obj.chegulu("红色的")

# 对象方法调用对象动态添加(或类内的成员属性)的成员属性
def chegulu(obj, msg):
    print("{}车轱辘{}".format(obj.color, msg))

obj.chegulu = chegulu
obj.chegulu(obj, "霸气")

# 通过types的MethodType创建一个绑定方法，自动传递obj对象
# 使用方式types.MethodType(函数，对象)当调用方法时，自动把对象当成参数传递给该方法
import types
def chegulu(self, msg):
    print("{}车轱辘{}".format(self.color, msg))

obj.chegulu = types.MethodType(chegulu, obj)
obj.chegulu("超奇葩")

# 动态添加匿名函数
obj.yinqinggai = lambda: print("红色的引擎盖")
obj.yinqinggai()
print(obj.__dict__)

1.1 私有成员和删除成员的相关操作

（1）私有成员的定义和使用上面已经提过，这里不再赘述

（2）删除成员通过del方法删除：del + 要删除的成员属性或成员方法

​ 注：删除时应注意对象中是否创建了该属性或方法，其次再去类中删除

（3）使用私有成员的两种方式

​ 第一种：私有成员的改名策略[_类名__成员名]（不推荐使用）

​ 第二种：利用类内的公有方法间接调用私有成员 (推荐)

class Plane():
    captain = "阿萨德"
    __airsistem = 3
    def fly(self):
        print("飞机会飞，百公里蚝油200升1")

    def fly2(self):
        print("飞机会费，百公里耗油200升2")

    def __plane_info(self):
        print("飞机上的空姐数量是保密的，个数%d" % (self.__airsistem))

    def __plane_info2(self):
        print("飞机上的空姐数量是保密的，个数%d" % (self.__airsistem))

    def pub_info(self):
        print(self.__airsistem)
        self.__plane_info()

    def pub_info2(self):
        print(self.__airsistem)
        self.__plane_info2()

obj = Plane()
obj.fly()
# Plane.fly2()
print(Plane.__dict__)

# 通过私有成员改名策略实现调用私有成员
print(obj._Plane__airsistem)
print(Plane._Plane__airsistem)

obj._Plane__plane_info()
Plane._Plane__plane_info2()

# 通过类内的公有方法调用私有成员
obj.pub_info()
Plane.pub_info2()

# 删除成员属性
obj.captain = "阿什顿"
print(obj.__dict__)
del obj.captain
print(obj.captain)
print(obj.__dict__)

# 删除方法
obj.func = lambda: print("开飞机是为了赚钱")
obj.func()
del obj.func
print(obj.__dict__)
del Plane.captain
print(obj.__dict__)

# 注意点
obj.fly = lambda: print("112233")
del Plane.fly
del obj.fly
obj.fly()

1.2 构造方法

魔术方法：在python中通过双下划线（__）包起来定义的方法都叫魔术方法（Magic Method）

类中定义__init__方法的是构造函数

触发：实例化对象，初始化的时候触发

功能：为对象添加成员

参数：参数不固定，至少一个self参数

返回值：无

类可以是一个，对象可以是多个，可以通过一个类实例化多个不同的对象

每创建一个对象，都会单独占用一个空间，创建的越多，占用的空间就越大

# 基本语法
class MyClass():
    def __init__(self):
        self.name = "阿三"

obj = MyClass()
print(obj.name)

# 带有多个参数的构造方法
class MyClass():
    def __init__(self, name):
        self.name = name

obj = MyClass("阿飞")
print(obj.name)