面向过程：功能上封装，C语言
面向对象：属性和行为上封装，Java语言
面向对象三大特征：封装，继承（方法重写），多态
一、类
1.1 类和对象
1.1.1 类的组成
1.1.2 类的定义
class student():
school = '北京'# 类属性
def __init__(self, xm, age):# 实例属性
self.name = xm
self.age = age
# 实例方法
def show(self):
print("实例方法show()")
print(f'{self.name},今年：{self.age}')
@staticmethod
def sm():
print("静态方法，不能调用实例属性，也不能调用实例方法")
@classmethod
def cm(cls):
print('类方法，不能调用实例属性，也不能调用实例方法')
stu = student('whh', 18)
print(type(stu))
print('实例属性：name,age=',stu.name,stu.age)
print('类属性：school=',student.school)
stu.show()
student.cm()
student.sm()
1.1.3 动态绑定属性和方法
stu1 = student('whh', 18)
stu2 = student('czh', 18)
print('stu1',stu1.name,stu1.age)
print('stu2',stu2.name,stu2.age)
def introduce():
print('我是一个普通函数，我被动态绑定成stu2对象的方法')
#动态绑定属性和方法
stu2.gen='男'
stu2.fun=introduce
print('stu2:',stu2.name,stu2.age,stu2.gen)
stu2.fun()
1.1.4 权限控制
class student():
def __init__(self,name,age,gen):
self._name=name #受保护的，只能本类和子类访问
self.__age=age #私有的，只能本身使用
self.gen=gen #普通的实例属性，类本身，内部，外部，子类都可以访问
def _fun1(self): #受保护的
print('子类及本身可以访问')
def __fun2(self): #私有的
print('只能定义的类可以访问')
def show(self): #普通的实例方法
self._fun1()
self.__fun2()
print(self._name,self.__age)
stu = student('whh',18,'女')
print(stu._name)
#print(stu.__age)
stu._fun1()
#stu.__fun2()
#私有的实例属性和方法访问
print(stu._student__age)
stu._student__fun2()
print(dir(stu))
1.1.5 属性设置
class student():
def __init__(self,name,gen):
self.name=name
self.__gen=gen
#讲方法转成属性使用
@property
def gen(self):
return self.__gen
@gen.setter
def gen(self,value):
if value!='男'and value!='女':
print('性别有误，已将性别设置为默认值男')
self.__gen='男'
else:
self.__gen =value
stu = student('whh','女')
print(stu.name,stu.gen)
stu.gen='xx'
print(stu.name,stu.gen)
二、继承
2.1 单继承
class person():
def __init__(self,name,age):
self.name=name
self.age=age
def show(self):
print(f'大家好，我叫：{self.name},我今年：{self.age}岁')
class student(person):
def __init__(self,name,age,stuno):
super().__init__(name,age)#调用父类初始化方法
self.stuno=stuno
class doctor(person):
def __init__(self,name,age,department):
super().__init__(name,age)#调用父类初始化方法
self.department=department
stu=student('whh',18,1001)
stu.show()
doctor=doctor('czh',20,'外科')
doctor.show()2.2 多继承
class fasthera():
def __init__(self,name):
self.name=name
def showa(self):
print('父类a中方法')
class fastherb():
def __init__(self, age):
self.age = age
def showb(self):
print('父类b中方法')
class son(fasthera,fastherb):
def __init__(self,name,age,gen):
fasthera.__init__(self,name)
fastherb.__init__(self,age)
self.gen=gen
son=son('whh',20,'女')
son.showa()
son.showb()2.3 方法重写
#方法重写
class person():
def __init__(self,name,age):
self.name=name
self.age=age
def show(self):
print(f'大家好，我叫：{self.name},我今年：{self.age}岁')
class student(person):
def __init__(self,name,age,stuno):
super().__init__(name,age)#调用父类初始化方法
self.stuno=stuno
def show(self):
super().show()
print(f'我是大学生，我的学号是：{self.stuno}')
class doctor(person):
def __init__(self,name,age,department):
super().__init__(name,age)#调用父类初始化方法
self.department=department
def show(self):
super().show()
print(f'我是医生，我的部门是：{self.department}')
stu=student('whh',18,1001)
stu.show()
doctor=doctor('czh',20,'外科')
doctor.show()三、多态
#多态
class person():
def eat(self):
print('人')
class cat():
def eat(self):
print('猫')
class dog():
def eat(self):
print('狗')
def fun(obj):
obj.eat()
person = person()
cat =cat()
dog=dog()
#不关心对象的数据类型，只关心对象是否具有同名方法
fun(person)
fun(cat)
fun(dog)
