封装的引入
一、出现封装的原因:我们需要一种方式来加强数据的安全性。1、属性不能随意修改。2、属性不能改为任意的值。
二、封装是面向对象的三大特性之一
三、封装指隐藏一些对象中不希望被外部访问到的属性或方法
四、我们也可以提供给一个getter()和setter()的方法使外部可以访问到属性或方法
1、gettre()获取对象中指定的属性。 2、setter()用来设置对象指定的属性
五、使用封装，确实是增加了类定义的复杂程度，但是它也确保了数据的安全性
1、隐藏属性名，使调用者无法随意修改对象中的属性
2、增加了getter()和setter()很好控制了是否是只读的
3、使用setter()设置属性，可以在做一个数据的验证
4、使用getter()方法获取属性，使用setter()方法设置属性可以在读取属性和修改属性的同时做一些其他的处理
六、可以为对象的属性使用双下划线开头__xxx。双下划线开头的属性，是对象的隐藏属性，隐藏属性只能在类的内部访问无法通过对象访问。
七、其实隐藏属性只不过是python自动为属性改个名字 ——>_类名__属性名 例如 __name -> _person__name
八、这种方式实际上依然可以在外部访问，所以这种方式我们一般不用。一般我们会将一些私有属性_开头
九、一般情况下使用_开头的属性都是私有属性，没有特殊情况下不要修改私有属性
# 封装的概念:就是为了数据的安全，形成了一个默认的规则，告诉你的协同开发者这个属性很重要，不要随意修改。
class Car():
def __init__(self, name, color):
self.name = name
self.color = color
def run(self):
print('汽车跑起来了')
def dididi(self):
print('汽车鸣笛了')
car = Car('法拉利', '红色')
car.name = '中华田园犬'
car.run()
car.dididi()
封装一`
封装一
class Car():
def __init__(self, name, color):
# self._name = name # 私有属性
self.__name = name # 隐藏属性 不可读的属性
self.color = color
def run(self):
print('汽车跑起来了')
def dididi(self):
print('汽车鸣笛了')
car = Car('法拉利', '红色')
#car.__name = '中华田园犬'
car.run()
car.dididi()
print(car._Car__name)
封装二
class Car():
def __init__(self, name, color):
# self._name = name # 私有属性
self._name = name # 隐藏属性 不可读的属性
self.color = color
# getter方法 提供给你访问这个属性的方法
def get_name(self):
return self._name
# setter方法 提供给你修改这个属性的方法
def set_name(self, name):
self._name = name
def run(self):
print('汽车跑起来了')
def dididi(self):
print('汽车鸣笛了')
car = Car('法拉利', '红色')
# car.__name = '中华田园犬'
car.run()
car.dididi()
# print(car._Car__name)
print(car.get_name())
car.set_name('宝马')
print(car.get_name())
property装饰器
一、我们可以使用@property装饰器来创建只读属性。
@property装饰器会将方法转换为相同名称的只读属性可以与所定义的属性配合使用，这样可以防止属性被修改
class Car():
def __init__(self, name, color):
self._name = name
self.color = color
@property
def name(self):
return self._name
@name. setter
def name(self, name):
self._name = name
def fun(self):
print('汽车启动')
def md(self):
print('汽车鸣笛')
car = Car('法拉利', '红色')
# print(car.name) # 访问属性
car.fun() # 调用方法
print(car.name)
car.name = '玛莎拉蒂'
print(car.name)
继承的简介
一、继承是面向对象的三大特性之一。
二、通过继承我们可以使一个类获取到其他类中的属性和方法
三、在定义类时，可以在类名后面的括号中指定当前类的父类（超类，基类）
四、继承提高了类的复用性，让类与类之间产生关系。有了这个关系才有了多态的特性
class Doctor():
name = ''
age = ''
def study(self):
print('治病救人')
class Soldire():
name = ''
age = ''
def study(self):
print('保家卫国')
pass
继承的引入
class DW(object): # 括号中没写，默认继承object
def sleep(self):
print('动物会跑')
def fun(self):
print('动物会喝水')
class Dog(DW):
pass
dog = Dog()
dog.fun()
dog.sleep()
# 检测实例是否是一个类的实例
print(isinstance(dog, Dog)) # 输出为True
print(isinstance(dog, DW)) # 输出为True
# 检测一个类是否是一个类的父类
print(issubclass(Dog, DW))
print(issubclass(DW, object))
方法的重写
一、如果在子类中和父类同名的方法，则通过子类实例去调用方法时，会调用子类的方法而不是父类的方法，这个特点我们称之为方法的重写（覆盖）
二、当我们调用一个对象的方法时: 1、会优先去当前对象中寻找是否具有该方法，如果有则直接调用
2、如果没有，则去当前对象的父类中寻找，如果父类中有则直接调用父类中的方法
3、如果没有，则去当前父类中的父类寻找，以此类推，直到找到object，如果依然没有找到就报错了。
# 方法的重写必须建立在继承的基础之上。
# object是最大的父类
class A(object):
name = 'A'
def test(self):
print('A.....')
class B(A):
def test(self):
print('B.....')
class C(B):
pass
c = C()
c.test()
print(c.name)
super()方法的使用
一、supre()可以获取当前类的父类
二、并且通过supre()返回对象调用父类方法时不需要传递self。
三、super这个方法的使用时建立在两个基础之上
1、必须有父类的继承
2、必须有方法的重写
class Animal(object):
def sleep(self):
print('动物会睡觉')
def run(self):
print('动物会喝水')
class Dog(Animal):
def sleep(self): # 方法的重写
print('狗会睡觉')
super().sleep() # super()的作用，将被覆盖的父类方法重新调用 只能继承一级父类
dog = Dog()
dog.run()
dog.sleep()
多重继承
一、在Python中是支持多重继承的，也就是我们可以为一个类同时制定多个父类。
二、可以在类名后面的括号中添加多个类来实现多重继承。
三、多重继承，会使子类同时拥有多个父类，并且获取所有父类中的方法。
四、在开发中如果没有特殊情况 应该尽量避免使用多重继承，因为多重继承会让我们的代码更加复杂。
五、如果多个父类中有同名的方法，则会先在第一个父类中寻找，然后找第二个，然后找第三个…前面会被后面覆盖。
class Person1(object):
def cn(self):
print('很会吹牛')
def cool(self):
print('貌赛潘安')
class Person2(object):
def pmp(self):
print('很会拍马屁')
def cool(self):
print('赛过刘德华')
class Son(Person1, Person2):
pass
son = Son()
son.cn()
son.pmp()
son.cool()
# 解耦合的原则:就是不希望太多的代码成为彼此牵连的代码
# 解耦合的作用:方便维护，提高了解决问题的效率，降低了问题解决的难度