本篇文章重点讲解Python的面向对象，包括Python中如何定义类、对象、封装、继承、多态等
封装
封装，是给类中的属性提供get、set方法
语法格式：
def set方法(self)：
代码块
def get方法(self):
代码块
eg：
def setName(self,name):
self.__name=name
def getName(self):
return self.__name
get、set装饰器
get方法装饰器：@property
set方法装饰器：@属性名.setter
调用：直接通过对象.属性名即可
注意：get方法修饰器必须写到set方法修饰器前面
eg：
@property
def name(self):
return self.__name
@name.setter
def name(self,name):
self.__name=name
类 和 对象
定义类：
语法
class 类名 (父类)：
代码块
注意：()可有可无
eg：
class Person:
#这是一个类
创建对象(实例)：
注意：Java语言在实例化对象是，采用new关键字,而Python语言不需要。
语法
对象名=类名()
eg：
person=Person()
调用类属性和方法：
对象名.属性
对象名.方法()
isinstance() 语法：
isinstance() 是检测一个对象是否是一个类的实例
语法格式：
isinstance(对象，类)，结果返回True和False
eg：
isinstance(person，Person)，结果为True
self
self 指的是调用该函数的对象
函数中默认参数self，该默认的参数self指的是调用该函数的对象
注意：
self 和调用函数对象的内存地址一致
如果是多个对象，调用同一个函数，self地址不一致
属性
属性：分为类属性和对象属性
类属性
可以通过类名或者对象访问，写在类里面，语法：变量名=变量值
class Person:
name="张三" # name是类属性
修改类属性：
只能通过类修改，不能通过对象修改，语法：类名.变量名=变量
注意：如果通过对象对属性进行重新赋值，实际上是给该对象又重新定义了一个属性名一样的变量！！！
对象属性
p1=Person()
p1.name="张三" # name是对象属性
添加对象属性：
-
类外面添加对象属性，语法：对象名.属性名=值，注意：该方式添加的属性，只能属于该对象
-
类里面添加对象属性，语法：变量名=变量值，注意：该方式添加的属性，属于所有类对象
-
__init__() 方法中添加对象属性，语法：self.属性名=值，用在__init__()初始化方法中
获取对象属性：
-
类外面获取对象属性，语法：对象名.属性名
-
类里面获取对象属性，语法：self.属性名，用在函数中
类属性和对象属性的区别？
-
类属性直接通过类名就可以调用，比如：
Person.name -
对象属性必须通过对象名调用，比如：
p1.name
属性修饰符：私有属性、公共属性
公共属性：
没有任何修饰符，该类型的属性可以被任意一个对象所调用
比如：
name="张三"
私有属性：
不能通过对象调用，也不能通过类名调用，只能在本类中调用，类似Java语言中的private，
私有属性如果想要在外部调用，则需提供get和set方法，私有属性通过双下划线修饰__
eg：
__name="张三" #这是一个私有属性
私有属性和私有方法（在这里我就一起讲了哈）
-
设置私有属性和方法：
在属性名和方法名前面加两个下划线__
定义为私有属性和私有方法，不能被子类继承
-
获取和修改私有属性的值
获取，定义getXXX()
修改，定义setXXX()
方法
对象方法：
定义在类中的函数被称为方法，所有的实例都可以访问
注意：对象方法，必须默认传递一个参数self，类似java中的this关键字
调用：只能通过对象调用
eg：
class Person:
def eat(self):
代码块
#调用
person=Person()
person.eat()
类方法：
被 @classmethod 修饰的方法，被称为类方法
参数：cls
调用：可以通过类调用
eg：
@classmethod
def sleep(cls):
print("睡觉")
#调用
Person.sleep()
静态方法：
被 @staticmethod 修饰的方法，被称为静态方法
参数：无参数
调用：可以通过类和对象调用
@staticmethod
def playDD():
print("打豆豆")
#调用
Person.playDD() #类名调用
person.playDD() #对象调用
构造方法：
构造方法 是以双下划线__开头，双下划线__结尾，方法名叫init，构造方法不需要自己调用，在实体化对象时调用，和Java中的构造方法一样
语法格式：
def __init__(self,参数)：
代码块
eg：
def __init__(self,name,age):
self.__name=name
self.__age=age
魔法方法：
__XX__() 函数叫做魔法方法，指的是具有特殊功能的函数
__init__() 初始化对象，在创建一个对象时默认被调用，不需要手动调用，带参数，类似于Java语言中的构造方法
__str__() print输出对象时，默认打印的是对象在内存中的地址，如果类中定义__str__方法，则会打印__str__方法中的内容，类似于Java语言中的toString() 方法
封装 - 代码体现：
"""
类和对象
"""
# 定义类
class Person(object):
# 定义属性【类属性】：可以用类或者对象调用
name = "张三"
__cardPass = "775885"
# 给私有属性提供get和set方法
def setCardPass(self, cardPass):
self.__cardPass = cardPass
def getCardPass(self):
return self.__cardPass
# 类方法
@classmethod
def sleep(cls):
print(f"{cls.name}正在睡觉")
# 静态方法
@staticmethod
def playDD():
print("正在打豆豆")
# 构造方法，初始化方法
def __init__(self, age, gender):
# 在初始化方法中给对象添加属性
self.age = age
self.gender = gender
# 定义方法
def eat(self):
print(f"{self.name}吃月饼")
print(self)
# 魔方方法，类似java中的toString()方法
def __str__(self):
return f"{self.name}, {self.age}, {self.gender}"
# 实例化对象
person = Person(11, "男")
person2 = Person(22, "女")
# print(person)
print(person2)
# 调用属性【类属性】
# print(person.name)
# print(Person.name)
# 修改类属性的值
# person.name = "李四" # 注意：该种方式不能修改类属性的值
# Person.name = "李四"
# print(person.name)
# print(Person.name)
# 调用函数
# person.eat()
# person2.eat()
# 添加对象属性
# 01.类外面添加:该属性只能被当前对象使用
# person.age=22
# print(person.age)
# print(person2.age)
# person.eat()
#调用不来
# print(person.__cardPass)
# print(person2.__cardPass)
# person.setCardPass("123456")
# print(person.getCardPass())
# 调用类方法
# Person.sleep()
# person.sleep()
# 调用静态方法
# Person.playDD()
# person.playDD()
继承
继承语法：
-
单继承：
父类，class 父类(object) (在python中，所有类默认继承object类)
子类，class 子类(父类)
-
多继承：
子类，class 子类(父类1，父类2)
通过语法格式可以看出Python语言支持多继承，Java语言只支持单继承
查看一个类的继承关系使用：类名.__bases__属性
多继承特点：一层一层获取，先找自己的类中，再从继承关系中找
注意：如果一个类继承多个父类，优先继承父类1的同名属性和方法
查看一个类的继承关系，类.__mro__
issubclass()
issubclass()方法作用:
检测一个类是否是另外一个类的子类
语法：
issubclass（子类，父类）
方法重写
像Java语言一样，Python语言也同样支持方法的重写 override
注意：如果子类重写了父类的同名属性和方法，则会调用子类中的同名属性和方法
子类调用父类的同名属性和方法，在子类的同名方法中调用，语法：父类.方法(self)；super()，调用父类方法，super().方法()
继承 - 代码体现：
"""
继承
"""
# 定义父类
class Father(object):
money = 2222.22
def cook(self):
print("会炒菜")
def eat(self):
print("会吃")
class Mother(object):
money = 22222.22
def cook(self):
print("会煮面条")
def playMJ(self):
print("打麻将")
class Son(Mother, Father):
money = 22.22
def cook(self):
# 调用父类的cook方法
# 01
# Father.cook(self)
# Mother.cook(self)
# 02
super().cook()
print("煮泡面")
son = Son()
print(son.money)
son.cook()
# son.eat()
# son.playMJ()
# 查看类的继承关系
# print(Son.__mro__)
多态
多态 的概念，和Java中的概念是一样的。
多态是一种使用对象的方式，子类重写父类方法，调用不同子类对象的相同父类方法，可以产生不同的执行效果。
步骤：
-
定义父类，提供父类方法
-
定义子类，重写父类方法
-
传递子类对象给调用者，返回不同的结果
class Person: def __init__(self,name): self.__name=name @property def name(self): return self.__name @name.setter def name(self,name): self.__name=name class Boy: def __init__(self,name): self.__name=name @property def name(self): return self.__name @name.setter def name(self,name): self.__name=name class Girl: pass def eat(obj): print("%s正在吃饭"%obj.name) p=Person("战三") b=Boy("小孩子") g=Girl() eat(g)，参数p、b都没有问题，但是g就会有问题
多态 - 代码体现：
"""
多态
水：
气体：
液体：
固体：
"""
class Water(object):
def use(self):
pass
class Gas(Water):
def use(self):
print("这是气体的水，可以用来蒸饺子")
class Liquid(Water):
def use(self):
print("这是液体的水，可以用来煮饺子")
class Solid(Water):
def use(self):
print("这是固体的水，可以用来冻饺子")
class Person(object):
def cook(self, water):
water.use()
person = Person()
gas = Gas()
liquid = Liquid()
solid = Solid()
person.cook(solid)
995
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
