面向对象

 

无

1. 什么是多态，多态有哪些优点，可以在哪些场景使用多态

  一种东西具有不同的形态，不同的类具有相同特点归结一个父类，内部都具有相同的方法子类覆盖父类方法

 1.扩展性增强 扩展新内容方便

2.灵活性  调用形式不变

统一调用方式

在学习面相对象之前，调用函数都是这样的：函数名()
现在，类中的函数叫做方法，调用的时候是这样的：对象名.方法名()
同样都是函数，但是现在有了两种调用方式。多态可以将方法的调用方式传化成之前函数的调用方式函数名(对象名) ，这样就统一了接口的调用方式

1. 以自己的理解简述一下Python中鸭子类型，可以查阅资料，举出一个简单实例(代码实现)

长得像鸭子就是鸭子，

1. 什么是封装，封装有哪些优点

   封装就是把内部隐藏起来，内部可访问外部不能直接访问，可以通过接口实现

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()