无
- 什么是多态，多态有哪些优点，可以在哪些场景使用多态
一种东西具有不同的形态，不同的类具有相同特点归结一个父类，内部都具有相同的方法子类覆盖父类方法
1.扩展性增强 扩展新内容方便
2.灵活性 调用形式不变
统一调用方式
在学习面相对象之前，调用函数都是这样的：函数名()
现在，类中的函数叫做方法，调用的时候是这样的：对象名.方法名()
同样都是函数，但是现在有了两种调用方式。多态可以将方法的调用方式传化成之前函数的调用方式函数名(对象名) ，这样就统一了接口的调用方式
- 以自己的理解简述一下Python中鸭子类型，可以查阅资料，举出一个简单实例(代码实现)
长得像鸭子就是鸭子，
- 什么是封装，封装有哪些优点
封装就是把内部隐藏起来，内部可访问外部不能直接访问，可以通过接口实现
class Student:
def __init__(self,name,age):
self.name=name
self.__age=age
def get(self):
return self.__age
stu=Student('zzf',20)
print(stu.__dict__)
# print(stu._Student__age)
# print(stu.get())
封装方法
lass A:
def __f1(self):
print("f1 run")
def run_f1(self):
self.__f1()
a = A()
a.run_f1()
封装后父类的方法不会被子类覆盖
lass A:
# def __f2(self):
# print('a_f')
# class B(A):
# def __f2(self):
# # super().__f2()
# print('B_f')
# def test(self):
# # super().f2()
# self.__f2()
#
# b=B()
# b.test()
装饰器
@property可以伪装成属性讲方法转向封装的属性位置
@setter 可以伪装成属性将封装的属性进行设置，前缀与property的方法名一致
@deleter 删除属性，前缀
class Student:
def __init__(self,name,sex,idCard):
self.name = name
self.sex = sex
self.__idCard = idCard
def get_idCard(self):
return self.__idCard
def set_idCard(self,new_id):
self.__idCard = new_id
@property # 需要掌握
def idCard(self):
return self.__idCard
@idCard.setter #了解的
def idCard(self,new_id):
self.__idCard = new_id
@idCard.deleter # 了解的
def idCard(self):
print("身份证属性被删除了.....")
del self.__idCard
stu = Student("尔康","男","323254554554")
# print(stu.get_idCard())
# stu.set_idCard("xxxx")
print(stu.get_idCard()) # 使用装饰器前
print(stu.name) # 普通属性的访问
print(stu.idCard) # 使用装饰器后
stu.idCard = "aaaaaaa" # 使用装饰器后的修改操作
print(stu.idCard)
del stu.idCard
print(stu.__dict__)
print(Student.__dict__)
4.完成综合体设计(整合今天所有知识点)
题：
两个基础的宠物类 -- Cat类，Dog类，Pig类
属性：name(名字)、type(品种)
name、type均为私有属性(对内可见，对外不可见)
type属性为成员属性(由构造器__init__方法赋初值)
但type对外又是可读可写(利用property装饰器实现)
name属性初始化操作由父类完成(子类利用super()来实现)
方法：eat(self)
均拥有eat的方法(父级继承)
但实现体分别可以体现出 "吃猫粮"、"吃狗粮"、"吃猪粮"不同点(不同的实现)
一个宠物的父类 -- Pet类
属性：name(名字)
name为私有属性(对内可见，对外不可见)
name属性为成员属性(由构造器__init__方法赋初值)
但name对外又是可读可写(利用property装饰器实现)
方法：eat(self)
拥有eat的方法(没有方法的实现体，利用abc模块实现)
一个主人类 -- Master类
属性：name(名字)、pet(宠物)
name、pet均为私有成员属性(具体操作同上面属性的操作)
方法：feed(self)
拥有feed方法(方法只有self一个参数，没有多余的参数)
feed方法实现要求
-- "某某"主人准备好宠物粮食
-- "某某品种"的"某某宠物"来进食
-- 吃...(调用宠物自身的eat方法)
注：""括起来的某某都是要被替换为具体的数据的
创建三个宠物主人，分别养的是不同的三种宠物
三个主人进行喂食的时候，对应养的宠物就会完成进食
其他细节自由补充
import abc
class Pet(metaclass=abc.ABCMeta):
def __init__(self,name):
self.__name=name
@abc.abstractmethod
def eat(self):
print('宠物在吃')
@property
def getname(self):
return self.__name
@getname.setter
def setname(self,newname):
self.__name=newname
class Cat(Pet):
def __init__(self, getname,type):
super().__init__(getname)
self.__type=type
@property
def gettype(self):
return self.__type
@gettype.setter
def setname(self, newtype):
self.__name = newtype
def eat(self):
print('猫在吃')
cat=Cat('tom','cat')
class Pig(Pet):
def __init__(self, getname,type):
super().__init__(getname)
self.__type=type
@property
def gettype(self):
return self.__type
@gettype.setter
def setname(self, newtype):
self.__name = newtype
def eat(self):
print('猪在吃')
pig=Pig('佩琪','pig')
class Dog(Pet):
def __init__(self, getname,type):
super().__init__(getname)
self.__type=type
@property
def gettype(self):
return self.__type
@gettype.setter
def setname(self, newtype):
self.__name = newtype
def eat(self):
print('狗在吃')
dog=Dog('哮天犬','dog')
class Master:
def __init__(self,name,pet):
self.__name=name
self.__pet=pet
@property
def getname(self):
return self.__name
@property
def getpet(self):
return self.__pet
def feed(self):
print(self.getname,'准备好食物')
print(self.getpet,'正在进食')
self.siyang.eat()
mas1=Master('杨戬','dog')
mas2=Master('egon','Pet')
mas3=Master('alex','Pet')
mas1.siyang=dog
mas2.siyang=pig
mas3.siyang=cat
mas1.feed()
mas2.feed()
mas3.feed()