五.面向对象

1 面向对象

什么是面向对象？
譬如生产一个橱柜，需要三个属性
1）橱柜外形
2）橱柜尺寸
3）橱柜油漆
4）橱柜的功能--储物

这就是一个橱柜的图纸，在面向对象中，我们就叫类，
根据这个图纸生产出的橱柜，就是它的一个对象，或者实例。

这就是面向对象。

在程序中：

• 类class
  类是抽象的概念，是万事万物的抽象，是一类事物的共同特征的集合。

• 对象instance、object
  对象是类的具体，是一个实体

*属性，它是对象状态的抽象

*操作，它是对象行为的抽象

Python的类的定义

class ClassName:
    语句块
# 1.必须使用class关键字
# 2.类名必须是用大驼峰命名
# 3.类定义完成后，就产生了一个类对象，绑定到了ClassName上

示例1

class MyClass:
    """A example class"""
 x = 'abc' #类属性
 def foo(self): #类属性，也是方法
 print(self.x)
        return 'My Class'
# 类本身也是对象，就叫类对象吧，所以它也有自己的属性和方法
print(MyClass.x)
print(MyClass.foo)
print(MyClass.__doc__)
print(MyClass.__name__)
print(MyClass.__dict__) # 通过__dict__() 可以查看类拥有的属性和方法，这个对象也有，作用与类的类似
''''
输出结果
abc
<function MyClass.foo at 0x7fcc035191f0>
A example class
MyClass
{'__module__': '__main__', '__doc__': 'A example class', 'x': 'abc', 'foo': <function MyClass.foo at 0x7fcc035191f0>, '__dict__': <attribute '__dict__' of 'MyClass' objects>, '__weakref__': <attribute '__weakref__' of 'MyClass' objects>}
'''

示例2

class Person:
    COUNTRY="中国"
 def __init__(self, name, age, address):
        # 使用双下划线命名代表私有化，不能直接在外部访问
 # 当然Python中的私有化也只是假私有,这个下边将 self.__name = name
        self.__age = age
        self.address = address
    def getName(self):
        return self.__name
    def setName(self,name):
        self.__name = name
    def getAge(self):
        return self.__age
    def setAge(self, age):
        self.__age = age
    def getAddress(self):
        return self.address
    def setAddress(self,address):
        self.address = address
if __name__ == '__main__':
    p = Person("张三", 22, "北京") # 实例化一个变量,先隐藏调用__new__()创建实例，然后调用__init()__初始化
 name = p.getName()  # 因为是私有变量，所以不能直接通过p.__name获取，需要调用提供的获取方法
 age = p.getAge()
    address = p.address # p.address没有私有化，所以可以直接使用
 print(f"姓名:{name},年龄:{age},地址:{address}")
    # 前面说python中的私有是假私有，怎么回事呢？我们通过p.__dict__ 看下
 print(p.__dict__)
    # 输出结果 {'_Person__name': '张三', '_Person__age': 22, 'address': '北京'}
 # 原来python的私有化，就是改了名,那么我们调用下 print(p._Person__name) # 虽然可以这样调用，但在正式环境，还是慎用
 # 类有__dict__,对象也有，而且我们通过对象同样可以访问类中的属性， print(p.COUNTRY)
    # 那么对象的属性查找顺序是怎样的呢？
 #实例使用.访问属性，会先找自己的dict，找不到会找上层类的dict #如果直接使用__dict__[变量名] 访问变量，将不会按照上面顺序查找了,如下 print(p.__dict__['address'])

2 封装

组装：将数据和操作组装到一起。
隐藏数据：对外只暴露一些接口，通过接口访问对象。
如上面的示例，就是封装的体现

3 装饰一个类

示例

def setnameproperty(name):
    def _setnameproperty(cls):
        cls.NAME = name
        return cls  #必须返回类
    return _setnameproperty

@setnameproperty('My Class')
class MyClass:
    pass
print(MyClass.NAME)
print(MyClass.__dict__)

类方法和静态方法

def setnameproperty(name):
    def _setnameproperty(cls):
        cls.NAME = name
        return cls  #返回类
    return _setnameproperty


@setnameproperty('My Class')
class MyClass:
    x = 123
    def __init__(self):
        print('init')
    def foo(self):
        return 'foo'

    @staticmethod # 使用这个装饰器修饰的方法就是静态方法
    def bar():
        print('bar')

    @classmethod # 使用这个装饰器修饰的方法就是类方法
    def clsmtd(cls):
        print('{}的x=={}'.format(cls.__name__, cls.x))


# print(MyClass.NAME)
# print(MyClass.__dict__)

MyClass.bar()
print(MyClass.__dict__)
MyClass.clsmtd()
a = MyClass()
a.clsmtd() #隐式为a.__class__.clsmtd() 类方法等价于java中的静态方法

在java中静态方法就是类方法，Python则不同，python中的静态方法指的的则是一般函数，为该类管辖，但从实质意义上无法归于该类，Python中有单独的类方法。
可以理解为挂名在该类的的方法，较少使用。

类方法，不需要实例化，只要类定义存在，即可调用
ClassName.clsmtd()
ClassName().clsmtd()

访问控制

• 公有属性(public)

• 私有属性(Private)：
  两个下划线代表私有，但并非真的私有，实质是Python解释器将其改变为_类名__变量名

• 保护的(Protect)
  一个下划线是一种约定，称为保护变量。

5 对象的销毁

类中可以定义__del__方法，称为析构函数(方法)
作用：销毁类的实例的时候调用，以释放占用的资源

由于Python实现了垃圾回收机制，这个方法不能确定合适执行，必要时使用del语句删除实例，来手动调用这个方法。

6 方法的重载

在其他面向对象的高级语言中，都有重载的概念
所谓重载，就是同一个方法名，但是参数数量、类型不一样，就是同一个方法的重载。
但Python只有重写，没有重载！
Python中，方法(函数)定义中，形参非常灵活，不需要指定类型，就算指定了类型也只是一个说明而非约束。
参数个数也不固定(可变参数)。一个函数的定义可以实现很多种不同形式的实参调用。
所以Python不需要方法的重载。

7 类的继承

Python3所有的类父类都是Object

查看继承的特殊属性和方法：

属性	描述
_base_	类的基类
_bases_	类的基类元组
_mro_	显示方法查找顺序，基类的元组
_subclasses_()	类的子类列表

Python支持多继承
Python使用MRO(methon resoultion order)解决基类搜索顺序
MRO有三个搜索算法
1）经典算法，从左到右，深度优先策略
2）新式类算法，经典算法的升级，重复的只保留最后一个
3）C3算法，在类被创建出来的时候，就计算出一个MRO有序列表。2.3版本后支持，
Python3唯一支持的算法。

示例

# 父类或者超类
# 在Python3中object是所有类的父类，默认定义的类都继承这个object类
# 但在定义类时，还是直接写明
class Person(object):
    def __init__(self, name, age):
        self.__name = name
        self.__age = age
    def eat(self):
        print("吃饭")
    def sleep(self):
        print("睡觉")
# 子类继承父亲类
class Student(Person):
    def __init__(self, name, age, school):
        super().__init__(name,age) # 使用super关键字调用父类的init方法
 self.__school = school
    def eat(self): # 重写父类方法
 print("在学校食堂吃饭")
    def learn(self):
        print("上课学习")
stu = Student("张三",18,"北京大学")
stu.eat()
stu.sleep() # 虽然子类中没有实现sleep()方法，但继承了父类，所以可以直接调用
stu.learn()
"""
在学校食堂吃饭
睡觉
上课学习
"""

8 多态

多态：不同的子类对调用相同的父类方法，产生不同的执行结果

    多态 可以 增加代码的灵活度
    以 继承和重写父类方法为前提

示例1

class Person(object):
    def __init__(self, name):
        self.name = name
        
    def working(self,):
    	pass

class Teacher(Person):
	def __init__(self, name):
        super().__init__(name)
        
	def wrking(self):
		print("I am a teacher")

class Student(Person):
	def __init__(self, name):
        super().__init__(name)
        
	def wrking(self):
		print("I am a Student")

# 1. 创建一一个Teacher对象和一个Student对象
teacher = Teacher()
student = Student()

teacher.working()
student.working()

示例2：

class Animal(object):
    def food(self):
        pass
    
    
class Dog(Animal):
    def food(self):
        return "骨头"
     
     
class Cat(Animal):

    def food(self):
        return "鱼"
  
  
class Person(object):

    def feedAnimal(self,animalObject): 
        food = animalObject.food()
        print(f"喂{food}")
        
if __name__ == '__main__':
    # 多态的体现
    p = Person()
    dog = Dog()
    cat = Cat()
    p.feedAnimal(dog)
    p.feedAnimal(cat)

封装、继承、多态是面向对象的三要素