面向对象的三大特征

封装

确保对象中的数据安全

继承

保证了对象的可扩展性

多态

保证了程序的灵活性

封装

封装是面向对象的三大特性之一
封装指的是隐藏对象中一些不希望被外部所访问到的属性或方法

如何隐藏一个对象中的属性？

将对象的属性名，修改为一个外部不知道的名字

如何获取（修改）对象中的属性？

需要提供一个getter和setter方法使外部可以访问到属性
getter 获取对象中的指定属性（get_属性名）
setter 用来设置对象的指定属性（set_属性名）

使用封装，确实增加了类的定义的复杂程度，但是它也确保了数据的安全性
1.隐藏了属性名，使调用者无法随意的修改对象中的属性
2.增加了getter和setter方法，很好的控制的属性是否是只读的

如果希望属性是只读的，则可以直接去掉setter方法
如果希望属性不能被外部访问，则可以直接去掉getter方法

3.使用setter方法设置属性，可以增加数据的验证，确保数据的值是正确的
4.使用getter方法获取属性，使用setter方法设置属性
可以在读取属性和修改属性的同时做一些其他的处理
5.使用getter方法可以表示一些计算的属性

class Dog:'''表示狗的类'''def __init__(self , name , age):self.hidden_name = nameself.hidden_age = agedef say_hello(self):print('大家好，我是 %s'%self.hidden_name) def get_name(self):'''get_name()用来获取对象的name属性'''    # print('用户读取了属性')return self.hidden_namedef set_name(self , name):# print('用户修改了属性')self.hidden_name = namedef get_age(self):return self.hidden_agedef set_age(self , age):if age > 0 :               #可以对修改的属性进行检查self.hidden_age = age    d = Dog('旺财',8)# d.say_hello()# 调用setter来修改name属性
d.set_name('小黑')
d.set_age(-10)# d.say_hello()
print(d.get_age())

创建一个表示矩形的类

class Rectangle:'''表示矩形的类'''def __init__(self,width,height):self.hidden_width = widthself.hidden_height = heightdef get_width(self):return self.hidden_widthdef get_height(self):return self.hidden_height   def set_width(self , width):self.hidden_width = width def set_height(self , height):self.hidden_height = height def get_area(self):return self.hidden_width * self.hidden_height        # r = Rectangle(5,2)
# r.set_width(10)
# r.set_height(20)# print(r.get_area())

可以为对象的属性使用双下划线开头，__xxx
双下划线开头的属性，是对象的隐藏属性，隐藏属性只能在类的内部访问，无法通过对象访问
其实隐藏属性只不过是Python自动为属性改了一个名字
实际上是将名字修改为了，_类名__属性名比如 __name -> _Person__name

# class Person:
#     def __init__(self,name):
#         self.__name = name#     def get_name(self):
#         return self.__name#     def set_name(self , name):
#         self.__name = name        # p = Person('孙悟空')# print(p.__name)       #__开头的属性是隐藏属性，无法通过对象访问
# p.__name = '猪八戒'
# print(p._Person__name)
# p._Person__name = '猪八戒'# print(p.get_name())

继承

定义一个类 Animal（动物）这个类中需要两个方法：run() sleep()

class Animal:def run(self):print('动物会跑~~~')def sleep(self):print('动物睡觉~~~')def bark(self):print('动物嚎叫~~~')

定义一个类 Dog（狗）这个类中需要三个方法：run() sleep() bark()

class Dog:def run(self):print('狗会跑~~~')def sleep(self):print('狗睡觉~~~')def bark(self):print('汪汪汪~~~')

有一个类，能够实现我们需要的大部分功能，但是不能实现全部功能
如何能让这个类来实现全部的功能呢？
① 直接修改这个类，在这个类中添加我们需要的功能

修改起来会比较麻烦，并且会违反OCP原则

② 直接创建一个新的类

创建一个新的类比较麻烦，并且需要大量的进行复制粘贴，会出现大量的重复性代码

③ 直接从Animal类中来继承它的属性和方法

继承是面向对象三大特性之一
通过继承我们可以使一个类获取到其他类中的属性和方法
在定义类时，可以在类名后的括号中指定当前类的父类（超类、基类、super）
子类（衍生类）可以直接继承父类中的所有的属性和方法

通过继承可以直接让子类获取到父类的方法或属性，避免编写重复性的代码，并且也符合OCP原则
所以我们经常需要通过继承来对一个类进行扩展

class Dog(Animal):def bark(self):print('汪汪汪~~~') def run(self):print('狗跑~~~~')    class Hashiqi(Dog):def fan_sha(self):print('我是一只傻傻的哈士奇')        d = Dog()
h = Hashiqi()# d.run()
# d.sleep()
# d.bark()# r = isinstance(d , Dog)
# r = isinstance(d , Animal)
# print(r)

issubclass() 检查一个类是否是另一个类的子类

在创建类时，如果省略了父类，则默认父类为object
object是所有类的父类，所有类都继承自object

class Person(object):pass# issubclass() 检查一个类是否是另一个类的子类
# print(issubclass(Animal , Dog))
# print(issubclass(Animal , object))
# print(issubclass(Person , object))# isinstance()用来检查一个对象是否是一个类的实例
#   如果这个类是这个对象的父类，也会返回True
#   所有的对象都是object的实例
print(isinstance(print , object))

重写

如果在子类中如果有和父类同名的方法，则通过子类实例去调用方法时，
会调用子类的方法而不是父类的方法，这个特点我们成为叫做方法的重写（覆盖，override）

# 定义一个类 Animal（动物）
#   这个类中需要两个方法：run() sleep()
class Animal:def run(self):print('动物会跑~~~')def sleep(self):print('动物睡觉~~~')class Dog(Animal):def bark(self):print('汪汪汪~~~') def run(self):print('狗跑~~~~')    # 创建Dog类的实例
# d = Dog()# d.run()

当我们调用一个对象的方法时，
会优先去当前对象中寻找是否具有该方法，如果有则直接调用
如果没有，则去当前对象的父类中寻找，如果父类中有则直接调用父类中的方法，
如果没有，则去父类的父类中寻找，以此类推，直到找到object，如果依然没有找到，则报错

class A(object):def test(self):print('AAA')class B(A):def test(self):print('BBB')class C(B):def test(self):print('CCC')   # 创建一个c的实例
c = C()
c.test()

继承

class Animal:def __init__(self,name):self._name = namedef run(self):print('动物会跑~~~')def sleep(self):print('动物睡觉~~~')@propertydef name(self):return self._name@name.setter    def name(self,name):self._name = name# 父类中的所有方法都会被子类继承，包括特殊方法，也可以重写特殊方法
class Dog(Animal):def __init__(self,name,age):# 希望可以直接调用父类的__init__来初始化父类中定义的属性# super() 可以用来获取当前类的父类，#   并且通过super()返回对象调用父类方法时，不需要传递selfsuper().__init__(name)self._age = agedef bark(self):print('汪汪汪~~~') def run(self):print('狗跑~~~~')   @propertydef age(self):return self._age@age.setter    def age(self,age):self._age = name        d = Dog('旺财',18) print(d.name)
print(d.age)

多重继承

在Python中是支持多重继承的，也就是我们可以为一个类同时指定多个父类
可以在类名的()后边添加多个类，来实现多重继承
多重继承，会使子类同时拥有多个父类，并且会获取到所有父类中的方法
在开发中没有特殊的情况，应该尽量避免使用多重继承，因为多重继承会让我们的代码过于复杂
如果多个父类中有同名的方法，则会现在第一个父类中寻找，然后找第二个，然后找第三个。。。
前边父类的方法会覆盖后边父类的方法

class A(object):def test(self):print('AAA')class B(object):def test(self):print('B中的test()方法~~')def test2(self):print('BBB')

class C(A,B):pass# 类名.__bases__ 这个属性可以用来获取当前类的所有父类
# print(C.__bases__) (<class '__main__.B'>,)
# print(B.__bases__) (<class 'object'>,)# print(C.__bases__) # (<class '__main__.A'>, <class '__main__.B'>)c = C()c.test()

多态是面向对象的三大特征之一
多态从字面上理解是多种形态
狗（狼狗、藏獒、哈士奇、古牧。。。）
一个对象可以以不同的形态去呈现

# 定义两个类
class A:def __init__(self,name):self._name = name@propertydef name(self):return self._name@name.setterdef name(self,name):self._name = name   class B:def __init__(self,name):self._name = namedef __len__(self):return 10@propertydef name(self):return self._name@name.setterdef name(self,name):self._name = name   class C:passa = A('孙悟空')
b = B('猪八戒')
c = C()

对于**say_hello()**这个函数来说，只要对象中含有name属性，它就可以作为参数传递
这个函数并不会考虑对象的类型，只要有name属性即可

# 定义一个函数
def say_hello(obj):print('你好 %s'%obj.name)

在say_hello_2中我们做了一个类型检查，也就是只有obj是A类型的对象时，才可以正常使用，
其他类型的对象都无法使用该函数，这个函数就违反了多态
违反了多态的函数，只适用于一种类型的对象，无法处理其他类型对象，这样导致函数的适应性非常的差
注意：像isinstance()这种函数，在开发中一般是不会使用的！

def say_hello_2(obj):# 做类型检查if isinstance(obj , A):print('你好 %s'%obj.name)
# say_hello(b)
# say_hello_2(b)

鸭子类型

如果一个东西，走路像鸭子，叫声像鸭子，那么它就是鸭子

len()

之所以一个对象能通过len()来获取长度，是因为对象中具有一个特殊方法__len__
换句话说，只要对象中具有__len__特殊方法，就可以通过len()来获取它的长度

l = [1,2,3]
s = 'hello'# print(len(l))
# print(len(s))
print(len(b))
print(len(c))

笔记为自己总结
来源为：尚硅谷李老师的课

Python学习之封装、继承、多态详解相关推荐

Java基础知识之封装+继承+多态详解
前言这篇博客是基于Java类和对象的基础之上的相关知识点.因为特别重要且语法规则较多,所以想单独总结方便之后复习. 本篇博客涉及知识点思维导图: 目录 1.封装 2.继承 3.多态 1.封装生活中 ...
【Java编程进阶】封装继承多态详解
推荐学习专栏:Java 编程进阶之路[从入门到精通] 文章目录 1. 封装 2. 继承 2.1 继承的语法 2.2 子类重写父类的方法 2.3 子类隐藏父类的方法 2.4 super 关键字 2.5 ...
Python学习二：词典基础详解
作者:NiceCui 本文谢绝转载,如需转载需征得作者本人同意,谢谢. 本文链接:http://www.cnblogs.com/NiceCui/p/7862377.html 邮箱:moyi@moyib ...
【Python学习】 caffe-master 之 mnist 详解
作者:佛山小程序员原文:https://blog.csdn.net/weixin_44192923/article/details/86563313 第一步: 官网下载mnist数据http://y ...
python学习笔记day08 文件功能详解
file.read():读取文件的全部内容 file=open("dang",mode='r+',encoding='utf-8') print(type(file.read()) ...
python怎样实现封装_Python底层封装实现方法详解
Python底层封装实现方法详解这篇文章主要介绍了Python底层封装实现方法详解,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下事实上,pyth ...
python的底层实现_Python底层封装实现方法详解
这篇文章主要介绍了Python底层封装实现方法详解,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下事实上,python封装特性的实现纯属" ...
python 参数类型的多态_【Python】面向对象：类与对象\封装\继承\多态
六.Python面向对象--类与对象\封装\继承\多态 1.什么是面向对象编程 1.1 程序设计的范式:程序可控,易于理解 1.2 抽象并建立对象模型 1.3 程序是不同对象相互调用的逻辑.每个对象在 ...
python多态的三种表现形式_python小结----面向对象的三大特征(封装,继承,多态)
面向对象的三大特征: 封装,继承,多态面向对象的编程思想核心:高类聚,低耦合–程序的设计模式范畴封装什么是封装: 在面向对象编程的思想中,对代码进行高度封装,封装又叫包装封装就是指将数据或者函 ...
c语言编程菲薄拉,C语言设计模式-封装-继承-多态
快过年了,手头的工作慢慢也就少了,所以,研究技术的时间就多了很多时间,前些天在CSDN一博客看到有大牛在讨论C的设计模式,正好看到了,我也有兴趣转发,修改,研究一下. 记得读大学的时候,老师就告诉我们 ...

Python学习之封装、继承、多态详解