Python面向对象、封装、继承、多态

1、私有属性和私有方法【实现封装】：

（1）两个下划线开头的属性是私有的（private）。其他为公共的（public）。

（2）类内部可以访问私有属性（方法）

（3）类外部不能直接访问私有属性（方法）

（4）类外部可以通过“_类名__私有属性（方法）名”访问私有属性（方法）

【注】方法本质上也是属性，只不过是可以通过（）执行而已。

class Employee:
    __company = '你好！'   #私有类变量
    def __init__(self,name,age):
        self.name = name
        self.__age = age  #两个下划线开头的属性是私有的（private）
    def __work(self):     #私有方法
        print('好好工作，努力赚钱！')
        print('年龄：{0}'.format(self.__age))
e = Employee('mary',18)
print(e.name)
print(e._Employee__age)  #类外部可以通过“_类名__私有属性（方法）名”访问私有属性（方法）、
e._Employee__work()
print(Employee._Employee__company)

输出：
mary
18
好好工作，努力赚钱！
年龄：18
你好！

2、@property装饰器

@property可以将一个方法的调用方式变成“属性调用”。

#输入错误时
class Employee:
    def __init__(self,name,salary):
        self.__name = name
        self.__salary = salary
    @property
    def salary(self):
        return self.__salary
    @salary.setter
    def salary(self,salary):
        if 1000<salary<50000:
            self.__salary = salary
        else:
            print('输入错误！薪水在1000-50000这范围')
e = Employee('Mary',30000)
print(e._Employee__name)
print(e.salary)
e.salary = -2000  #修改值 
print(e.salary)

输出：
Mary
30000
输入错误！薪水在1000-50000这范围
30000

#输入正确时
class Employee:
    def __init__(self,name,salary):
        self.__name = name
        self.__salary = salary
    @property
    def salary(self):
        return self.__salary
    @salary.setter
    def salary(self,salary):
        if 1000<salary<50000:
            self.__salary = salary
        else:
            print('输入错误！薪水在1000-50000这范围')
e = Employee('Mary',30000)
print(e._Employee__name)
print(e.salary)
e.salary = 2000  #修改值 
print(e.salary)

输出：
Mary
30000
2000

3、面向对象的三大特征：

（1）封装（隐藏）：隐藏对象的属性和实现细节，只对外提供必要的方法。

（2）继承：可以让子类具有父类的特性，提高了代码的重用性。（如：父有ABC，子可以是ABC、ABCF、ABCR，必须包含ABC）

（3）多态：指同一个方法调用由于对象不同会产生不同的行为。（如：同样是休息方法，人不同休息方法不同，张三休息是睡觉，李四休息是玩游戏）

4、继承：

格式：class  子类类名（父类1[，父类2，……]）：

                   类体

如果在类定义中没有指定父类，则默认父类是object类。

定义子类时，必须在其构造函数中调用父类的构造函数。调用格式：

父类名.__init__(self, 参数列表)

示例：

class Person:
    def __init__(self,name,age):
        self.name = name
        self.__age = age  #私有属性
    def say_age(self):
        print('年龄，年龄，我也不知道')
class Student(Person):
    def __init__(self,name,age,score):
        Person.__init__(self,name,age)  #必须显示调用父类初始化方法，不然解释器不会去调用
        self.score = score
print(Student.mro())         #方法解析顺序
s = Student('Mary',18,60)
s.say_age()
print(s.name)
print(s._Person__age)
print(dir(s))

输出：
[<class '__main__.Student'>, <class '__main__.Person'>, <class 'object'>]
年龄，年龄，我也不知道
Mary
18
['_Person__age', '__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'name', 'say_age', 'score']

5、类成员的继承和重写：
（1）成员继承：子类继承了父类除构造方法之外的所有成员。

（2）方法重写：子类可以重新定义父类中的方法，这样就会覆盖父类的方法，称为“重写“。

class Person:   #父类
    def __init__(self,name,age):
        self.name = name
        self.__age = age  #私有属性
    def say_age(self):
        print('我的年龄：',self.__age)   #类内部可以访问私有属性
    def say_introduce(self):
        print('我的名字是{0}'.format(self.name))
class Student(Person):  #子类继承父类
    def __init__(self,name,age,score):
        Person.__init__(self,name,age)  #必须显示调用父类初始化方法，不然解释器不会去调用
        self.score = score
    def say_introduce(self):
        """重写了父类的方法"""
        print('报告老师，我的名字是：{0}'.format(self.name))
s = Student('Mary',18,60)
s.say_age()
s.say_introduce()

输出：
我的年龄： 18
报告老师，我的名字是：Mary

6、查看类的继承层次结构

通过类方法mro()或者类的属性__mro__可以输出这个类的继承层次结构。

class A:pass
class B(A):pass
class C(B):pass
print(C.mro())

输出：
[<class '__main__.C'>, <class '__main__.B'>, <class '__main__.A'>, <class 'object'>]

7、dir()可以查看指定对象所有的属性。

8、__str__方法用于返回一个对于“对象的描述”，对应于内置函数str()经常用于print()方法，帮助我们查看对象的信息，__str__()可以重写。

class Person:   #默认继承object类
    def __init__(self,name):
        self.name = name
    def __str__(self):   #重写self.name
        return "名字是：{0}".format(self.name)
p = Person('Mary')
print(p)

输出：
名字是：Mary

9、super()获得父类定义

在子类中，如果想要获得父类的方法时，可通过super()来做。super()代表父类的定义，不是父类对象。

class A:
    def say(self):
        print('A:',self)
class B(A):
    def say(self):
        #A.say(self)   #法一
        super().say()  #法二：super()调用父类的方法
        print('B:',self)
B().say()

输出：
A: <__main__.B object at 0x000001A783AC75C0>
B: <__main__.B object at 0x000001A783AC75C0>

10、多态：多态是方法的多态，属性没有多态。多态的存在有2个必要条件：继承、方法重写。

class Man:
    def eat(self):
        print('饿了，吃饭啦！')
class Chinese(Man):
    def eat(self):
        print('中国人用筷子吃饭')
class English(Man):
    def eat(self):
        print('英国人用叉子吃饭')
class Indian(Man):
    def eat(self):
        print('印度人用右手吃饭')
def manEat(m):
    if isinstance(m, Man):       
        m.eat()   #多态。一个方法调用eat(self)，根据对象不同调用不同的方法。
    else:
        print('不能吃饭')
manEat(Chinese())
manEat(English())
manEat(Indian())

输出：
中国人用筷子吃饭
英国人用叉子吃饭
印度人用右手吃饭

11、特殊方法和运算符重载

（1）常见特殊方法：

 （2）每个运算符实际上都对应了相应的方法：

 

class Person:
    def __init__(self,name):
        self.name = name
    def __add__(self,other):
        if isinstance(other,Person):
            return '{0}--{1}'.format(self.name,other.name)
        else:
            return '不是同类对象，不能相加'
p1 = Person('Mary')
p2 = Person('Bob')
x = p1+p2
print(x)

输出：Mary--Bob

isinstance() 函数来判断一个对象是否是一个已知的类型，类似 type()。 如果对象的类型与参数二的类型（classinfo）相同则返回 True，否则返回 False。

格式：isinstance(object, classinfo)

object -- 实例对象。

classinfo -- 可以是直接或间接类名、基本类型或者由它们组成的元组。

12、特殊属性：

class A:
    pass
class B:
    pass
class C(B,A):
    def __init__(self,nn):
        self.nn = nn
    def cc(self):
        print('cc')
c=C(3)
print(dir(c))
print(c.__dict__)
print(c.__class__)
print(C.__bases__)
print(C.mro())
print(A.__subclasses__())

输出：
['__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'cc', 'nn']
{'nn': 3}
<class '__main__.C'>
(<class '__main__.B'>, <class '__main__.A'>)
[<class '__main__.C'>, <class '__main__.B'>, <class '__main__.A'>, <class 'object'>]
[<class '__main__.C'>]

13、组合

（1）‘is-a’关系，我们可以使用‘继承’。（如：狗是动物）

（2）‘has-a’关系，我们可以使用‘组合’。（如：手机拥有CPU）

#使用继承实现代码的复用
class A1:
    def say_a1(self):
        print('a1,a1,a1')
class B1(A1):
    pass
b1 = B1()
b1.say_a1()

#同样的效果，使用组合实现代码的复用
class A2:
    def say_a2(self):
        print('a2,a2,a2')
class B2:
    def __init__(self, a):
        self.a = a
a2 = A2()
b2 = B2(a2)
b2.a.say_a2()

输出：
a1,a1,a1
a2,a2,a2