第二十六天 组合 封装 多态

Posted gongcheng-

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了第二十六天 组合 封装 多态相关的知识,希望对你有一定的参考价值。

上节内容回顾:

  1.继承

    ps:继承解决的是类与类之间的代码冗余问题

  2.如何继承:先抽象 再继承

  3.Python 中继承的特点:

    1.

      单继承

      多继承

    2.

      新式类

      经典类

今日内容:

  1.组合

  2.封装

  3.多态

一.组合

1.什么是组合

  一个对象的属性是来自另一外一个类的对象,称之为组合

2.为何用组合

  组合也是用来解决类与代码冗余的问题

3.如何用组合

 

class Foo:
    aaa=1111
    def __init__(self,x,y)
        self.x=x
        self.y=y

    def func1(self):
        print(Foo内的功能)

class Bar:
    bbb=2222
    def __init__(self,m,n):
        self.m = m
        self.n = n

    def func2(self):
        print(Bar内的功能)
obj1=Foo(10,20)
obj2=Bar(30,40)

obj1.xxx=obj2
print(obj1.x,obj1.y,obj1.aaa,obj1.func1)

print(obj1.xxx.m,obj1.xxx.n,obj1.xxx.bbb,obj1.xxx.func2)

组合另一个类中的多个对象

class OldboyPeple:
    school = Oldboy
    def __init__(self,name,age,gender):
        self.name = name
        self.age = age
        self.gender = gender

class OldboyStudent(OldboyPleople):
    def choose_course(self):
        print(%s is choosing course%self.name)

class OldboyTeacher(OldboyPeople):
    def choose_course(self):
        stu,num=num
        print(老师%s给学生%s打分%s%(self.name,stu.name,num))

class Course:
    def __init__(self,course_name,course_price,course_period):
        self.course_name = course_name
        self.course_price=course_price
        self.course_period=course_period

    def tell_course(self):
        print(课程名:<%s>价格:[%s] 周期:[%s]%(self.course_name,self.course_price,self.course_period))

python_obj = Course(python开发,3000,5mons)
linux_obj=Course(linux运维,5000,3mons)

stu1=OldboyStudent(egon,18,male)
stu1.course=[]
stu1.courses.append(linux_obj)
stu1.courses.append(python)obj)
stu1.courses[0].tell_course()

二.封装

1.什么是封装

  装指的是吧属性装进一个容器

  封指的是隐藏的意思,但是这种隐藏式对外不内的

2.为何要封装

  封装不是单纯意义的隐藏

  封装数据属性的目的:将数据属性封装起来,类外的使用就无法直接操作该数据属性了

  需要内部开一个接口给使用者,类的实际者可以在接口上附带任何逻辑,从而严格

  控制使用者对属性的操作

 

  封装函数属性的目的:隔离复杂度

3.如何封装

  只要在属性前加上__开头,该属性就会被隐藏起来,该隐藏具备的特点:

    1.只要一种语法意义上的变形,即__开头的属性会在检测语法时发生变形,_类名__属性名.

    2.这种隐藏是对外不对内的,因为在类内部检测语法时所有的代码统一都会发生变形

    3.这种变形值在检测时发生一次,在类定义之后新增的__开头的属性并不会发生变形

    4.如果父类不想让子类覆盖自己的属性,可以在属性前加__开头.

#其实这仅仅这是一种变形操作且仅仅只在类定义阶段发生变形
#类中所有双下划线开头的名称如__x都会在类定义时自动变形成:_类名__x的形式:

class A:
    __N=0 #类的数据属性就应该是共享的,但是语法上是可以把类的数据属性设置成私有的如__N,会变形为_A__N
    def __init__(self):
        self.__X=10 #变形为self._A__X
    def __foo(self): #变形为_A__foo
        print(from A)
    def bar(self):
        self.__foo() #只有在类内部才可以通过__foo的形式访问到.

#A._A__N是可以访问到的,
#这种,在外部是无法通过__x这个名字访问到。

内部调用

class ATM:
    def __card(self):
        print(插卡)
    def __auth(self):
        print(用户认证)
    def __input(self):
        print(输入取款金额)
    def __print_bill(self):
        print(打印账单)
    def __take_money(self):
        print(取款)

    def withdraw(self):
        self.__card()
        self.__auth()
        self.__input()
        self.__print_bill()
        self.__take_money()

a=ATM()
a.__card(self)
a.withdraw()

隐藏的属性可以被内部使用

class ATM:
    def __card(self):
        print(插卡)
    def __auth(self):
        print(用户认证)
    def __input(self):
        print(输入取款金额)
    def __print_bill(self):
        print(打印账单)
    def __take_money(self):
        print(取款)

    def withdraw(self):
        self.__card()
        self.__auth()
        self.__input()
        self.__print_bill()
        self.__take_money()

a=ATM()
a.__card(self)
a.withdraw()

三.property装饰器.

property是一种特殊的属性,访问它时会执行一段功能(函数)然后返回值

  即:可以把函数结果作为属性被返回.

例一:BMI指数(bmi是计算而来,但很明显它听起来是一个属性而非方法,如果我们将其做成一个属性,更便于理解)

 

成人的BMI数值:

过轻:低于18.5

正常:18.5-23.9

过重:24-27

肥胖:28-32

非常肥胖:高于32

  体质指数(BMI)=体重(kg)?身高2(m)

  EX:70kg ?(1.75??1.75) = 22.86

class People:
    def __init__(self,name,weight,height):
        self.name=name
        self.weight=weight
        self.height=height

    @property
    def bmi(self):
        return self.weight / (self.height ** 2)

obj=People(egon,70,1.82)
obj.height=1.85

print(obj.bmi)

property的需要了解的用法

class People:
    def __init__(self,name)
        self.__name=name

    @property
    def name(self)
        return<name:%s>self.name

    @name.setter
    def name(self,new_name):
        if type(new_name)is not str:
            print(名字必须是str类型")
            return
        self.__name=new_name
    
    @name.deleter
    def name(self)
        del self.name
obj=People(egon)
print(obj.name)

obj.name=123
print(obj.name)

def obj.name
print(obj.__dict__)

四.多态,

1.什么是多态

  同一事物的多种形态

2.为何要用多态

  多态性:指

import abc

class Animal(metaclass=abc.ABCMeta):
    @abc.abstractmethod
    def speak(self):
        pass

# Animal() # 父类不能实例化,因为父类本身就是用来制定标准的
class People(Animal):
    def speak(self):
        print(say hello)
    # def jiao(self):
    #     print(‘say hello‘)

class Dog(Animal):
    def speak(self):
        print(汪汪汪)

class Pig(Animal):
    def speak(self):
        print(哼哼哼)


peo=People()
dog1=Dog()
pig1=Pig()
#
#
peo.speak()
dog1.speak()
pig1.speak()
def speak(animal):
    animal.speak()

speak(peo)
speak(dog1)
speak(pig1)

 

的是可以在不用考虑对象具体类型的前提下而直接使用对象的方法

3.如何用多态

 




以上是关于第二十六天 组合 封装 多态的主要内容,如果未能解决你的问题,请参考以下文章

第二十六天打卡

javaSE第二十六天

团队冲刺第二十六天

团队冲刺第二十六天

蓝桥杯31天真题冲刺|题解报告|第二十六天

20200731 千锤百炼软工人第二十六天