- 一、slots
- 二、私有属性和私有方法
- 三、继承
- 1、私有属性、私有方法
- 2、继承的特点（多层继承）
- 3、新式类和经典类
- 四、方法的重写
- 五、多态
- __slots__属性对应的是元组类型的值
- 规定对象可以使用的属性，只有在元组里出现的值，才能设置给对象
class Person(object):
__slots__ = ('name', 'age') # 要的是一个元祖（ ）
def __init__(self, name, age):
self.name = name
self.age = age
p = Person('zhangsan', 18) # 对象P，有姓名和年龄属性
p.addr = '上海'
# 会报错AttributeError: 'Person' object has no attribute 'addr'，要想不报错，需要把addr加入至slots参数中
# 如果没有__slots__方法，不会报错，因为python支持动态类型，加属性是OK的
二、私有属性和私有方法
- 1、私有属性：添加两个下划线（self.__money），这种属性我们称之为私有属性，只能在内部访问，不能在外部访问
- 使用内部方法可以访问，返回该私有属性return self.__money
- print(p._Person__money)可以使用 对象名._类名__私有属性名 来强制访问私有属性，不建议使用该方式
- 2、私有方法：私有方法使用 __ 开始，定义的私有方法__demo只让内部使用，外部无法访问
- p._Person__demo() 可以通过对象名._类名__私有方法名强制访问，不建议使用该方式
import time
class Person(object):
def __init__(self, name, age, money):
self.name = name
self.age = age
# 添加两个下划线，这种属性我们称之为私有属性，只能在内部访问，不能在外部访问
self.__money = money
def get_money(self): # 内部可以访问money，然后外部再调用该方法，作为一个接口（连接内外）
print('{}查询余额了！！！！'.format(time.asctime())) # 查询余额时间
return self.__money
def set_money(self, money):
print('修改余额了！！！')
self.__money = money
def test(self):
self.__demo()
print('加密以后的代码1')
print('加密以后的代码2')
print('加密以后的代码3')
print('加密以后的代码4')
print('加密以后的代码5')
print('我是person里的test函数')
def foo(self): # 定义的私有方法__demo只让内部使用
self.__demo()
# 私有方法使用 __ 开始
def __demo(self):
print('加密第1步')
print('加密第2步')
print('加密第3步')
print('加密第4步')
print('加密第5步')
print('加密第6步')
print('加密第7步')
p = Person('zhangsan', 18, 2000)
p.test()
print(p.get_money())
# p.__demo() 私有方法，外部无法访问
# p._Person__demo() 可以通过对象名._类名__私有属性名强制访问，不建议使用该方式
p.set_money(1500)
print(p.get_money())
# 如果想要访问私有属性，可以使用 对象名._类名__私有属性名 来强制访问
# print(p._Person__money) # 强烈不推荐使用这种方式来访问私有属性
# 私有属性 __money 在外部不能直接访问
# print(p.__money)
# p.__money -= 500
# print(p.__money)
三、继承
1、私有属性、私有方法
- 私有属性不会被子类继承；
- 私有方法也不会被子类继承；
- Student 类继承自 Person 类，就可以使用Person类里的方法；
- s 对象还可以调用自己类的方法
class Person(object):
def __init__(self, name, age):
self.name = name
self.age = age
self.money = 1000
self.__xxx = 'hello' # 私有属性
def eat(self):
print(self.name + '正在吃饭')
def sleep(self):
print(self.name + '正在睡觉')
def __foo(self):
print('fooooooooooooooooooooooooooo')
class Student(Person):
# def __init__(self, name, age, school):
# self.name = name
# self.age = age
# self.school = school
def study(self):
# print(self.__xxx) 私有属性不会被子类继承
# self.__foo() 私有方法也不会被子类继承
print(self.name + '正在学习')
# s = Student('zhangsan', 18, '春天花花幼稚园')
s = Student('zhangsan', 18)
print(s.money) # 1000
# Student 类继承自 Person 类，就可以使用Person类里的方法
s.eat()
# s 对象还可以调用自己类的方法
s.study()
2、继承的特点（多层继承）
父类（基类）、子类（派生类）
- 当调用一个对象的属性或者方法时，会按照__mro__属性指定的属性查找，如果找到了就直接停止；如果最后都没找到，就报错！！！
class Animal(object):
def eat(self):
print('动物正在吃东西')
def sleep(self):
print('动物正在睡觉')
def demo(self):
print('我是animal里的demo方法')
class Person(Animal):
def drive(self):
print('人正在开车')
def make_money(self):
print('挣了一点点点点钱')
class Dog(Animal):
def bark(self):
print('狗正在叫')
class RichPeople(Animal):
def make_money(self):
print('富人挣了好多好多好多钱')
class Boss(object):
def offer(self):
print('老板把公司给你了')
def demo(self):
print('我是boss里的demo方法')
class Student(RichPeople, Person, Boss): # 多继承
def study(self):
print('学生正在学习')
class Teacher(Person):
def teach(self):
print('老师正在上课')
s = Student() # 实例化一个对象s
s.study()
s.drive()
s.eat()
s.make_money()
s.offer()
s.demo() # 我是animal里的demo方法，会按照父类顺序调用
s.xxx() # 会报错，因为所有父类都没有该方法
# (, , , , , )
# 当调用一个对象的属性或者方法时，会按照 __mro__ 属性指定的属性查找，如果找到了就直接停止；如果最后都没找到，就报错！！！
print(Student.__mro__)
3、新式类和经典类
新式类:继承自object的类是新式类
经典类: 没有继承自object的类
在python3以后，如果创建一个类不指定父类，默认继承自object,python3没有经典类
class Person(object):
def test(self):
print('hello')
p = Person()
p.test()
print(Person.__mro__) # (, )
四、方法的重写
- 子类在父类的基础上又扩展了自己的功能：父类名.函数名(参数)，此时需要传参数self
- 即在调用子类test方法前，先调用父类的test方法，即子类扩展了父类的方法，先调父类的方法，再做子类的实现
- super().函数名()
class Person(object):
def __init__(self, name, age):
self.name = name
self.age = age
self.money = 1000
def test(self):
print(self.name + ' say hello')
class Student(Person):
def __init__(self, name, age, school):
# 子类在父类的基础上又扩展了自己的功能
# 父类名.函数名(参数)
# Person.__init__(self, name, age)
# super().函数名()
super().__init__(name, age)
self.school = school
def study(self):
print('学生正在学习')
def test(self):
# Person.test(self) #
super().test() # 在调用子类test方法前，先调用父类的test方法，即子类扩展了父类的方法，先调父类的方法，再做子类的实现
print('hehe')
s = Student('zhangsan', 18, '春田花花幼稚园')
print(s.money)
s.test() # zhangsan say hello hehe此时先调用的是父类的test方法，后调用子类的test方法
# s.study()
五、多态
多态：不同的子类对象，调用相同的父类方法，得到的结果可能不一样
# 1、不使用多态时
class SearchDog(object):
def sd_work(self):
print('搜救犬正在搜索生命')
class PoliceDog(object):
def pd_work(self):
print('警犬正在抓坏人')
class FlyDog(object):
def fd_work(self):
print('飞天犬正在飞')
class Person(object):
def __init__(self, dog=None):
self.dog = dog
def work_with_sd(self):
self.dog.sd_work()
def work_with_pd(self):
self.dog.pd_work()
def work_with_fd(self):
self.dog.fd_work()
p = Person()
sd = SearchDog()
pd = PoliceDog()
fd = FlyDog()
p.dog = sd # 换一条狗就得换相应的方法
p.work_with_sd()
# 2、使用多态时
class Dog(object):
def dog_work(self):
print('狗正在工作')
# 都继承Dog类
class SearchDog(Dog):
def dog_work(self): # 重写Dog方法
print('搜救犬正在搜索生命')
class PoliceDog(Dog):
def dog_work(self):
print('警犬正在抓坏人')
class FlyDog(Dog):
def dog_work(self):
print('飞天犬正在飞')
class BlindDog(Dog):
def dog_work(self):
print('导盲犬正在领路')
class Person(object):
def __init__(self, dog=None):
self.dog = dog
def work_with_dog(self):
self.dog.dog_work() # self.dog找到导盲犬 ，然后调用dog_work()方法，而BlindDog()又重写类该方法
sd = SearchDog()
pd = PoliceDog()
fd = FlyDog()
bd = BlindDog()
p = Person(bd) # 将bd传入，即BlindDog导盲犬，如果调用其他就把参数传入即可
p.work_with_dog() # 导盲犬正在领路
