多态

多态

关注
发信
关注(28)粉丝(399)

面向对象的晋级补充

组合：

-就是一个类的对象具备某一个属性，该属性的值是指向另一个类的对象

组合用来解决类与类之间代码冗余的问题。

class Course:
    def __init__(self, name, period, price):
        self.name = name
        self.period = period
        self.price = price

    def tell_info(self):
        mag = f"""
        课程名：{self.name}
        课程周期：{self.period}
        课程价格：{self.price}"""
        print(mag)


class OldboyPeople:
    school = 'oldboy'

    def __init__(self, name, age, sex):
        self.name = name
        self.age = age
        self.sex = sex


class OldboyStudent(OldboyPeople):
    def __init__(self, name, age, sex, stu_id):
        OldboyPeople.__init__(self,name,age,sex)
        self.stu_id = stu_id

    def choose_course(self):
        print(f'{self.name} is choosing course')


class Teacher(OldboyPeople):
    def __init__(self,name,age,sex,level):
        super().__init__(name,age,sex)
        self.level = level
        def score(self,stu,num):
            stu.score = num
            print(f'老师{self.name}为学生们{stu.name}打分{num}')
#创建课程
python = Course('python','5mouths',3000)
python.tell_info()
linux = Course('linux运维','5mouths',800)
linux.tell_info()

stu1 = OldboyStudent('tank',19,'male',1)
teal = Teacher('nick',18,'male',10)
#组合， 将学生对象的一个属性赋值为另一个对象
stu1.course = python
teal.course = linux
stu1.course.tell_info()
teal.course.tell_info()

总结：

    继承:
        类与类的关系,一种什么是什么的关系,子类与父类是从属关系.

    组合:
        对象与对象的关系,一种什么有什么的关系,一个对象拥有另一个对象.
    组合：可以理解成多个人去造一个机器人，有的人造头、有的人造脚、有的人造手、有的人造躯干，大家都完工后，造躯干的人把头、脚、手拼接到自己的躯干上，因此一个机器人便造出来了
class People:
    def __init__(self, name, age, sex):
        self.name = name
        self.age = age
        self.sex = sex

    def add_course(self, course_obj):
        self.course_list.append(course_obj)

    def tell_all_course(self):
        for course_obj in self.course_list:
            course_obj.tell_course_info()
            pass


class Teacher(People):
    def __init__(self, name, age, sex):
        super().__init__(name, age, sex)
        self.course_list = []


class Student(People):
    def __init__(self, name, age, sex):
        super().__init__(name, age, sex)
        self.course_list = []


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

    def tell_course_info(self):
        print(f'''
        课程名称： {self.course_name}
        课程周期： {self.course_peirod}
        课程价格： {self.course_price}
        ''')


teal = Teacher('nick', 18, 'male')
stu1 = Student('小丁',20 , 'female')
python =  Course('python',6,2.0)
linux = Course('linux',6,1.0)

teal.add_course(python)
teal.add_course(linux)
teal.tell_all_course()

封装：

1.保护隐私

2.隔离复杂的过程，实现功能

提示：在编程语言里，对外提供的接口--入口，就是函数，称为接口函数，这与接口的概念还不一样，接口代表一组接口函数的集合体。
        封装指的是把一堆属性(特征与技能)封装到一个对象中.
        存数据的目的是为了取, 对象可以"."的方式获取属性.

        比喻: 对象就好比一个袋子, 袋子里面装一堆属性.

    2.为什么要封装?
        封装的目的为了方便存取,可以通过对象.属性的方式获取属性.

    3.如何封装
        特征: 变量 ---> 数据属性
        技能: 函数 ---> 方法属性

        在类内部,定义一堆属性(特征与技能).
        通过 对象.属性 = 属性值

一层封装：

类名 .+ 实例名.就是访问隐藏属性的接口

访问机制限制(多层封装）:

在类内部定义，凡是以__开头的数据属性，方法属性都会被python内部隐藏，让外部不能·直接访问类内部的__开头的属性

注意：__x,时发生变形：_类名__x形式
class X:
    __n = 0 # 变形为self._A__X
    def __init__(self):
        self.__x =10
    def __foo(self):
        print('from X')
    def bar(self):
        self.__foo()
  # 只有在类内部才可以通过__foo的形式访问到.

自动变形的特点：

  1. #### 类中定义的__x只能在内部使用，如self.__x，引用的就是变形的结果。
  2. #### 这种变形其实正是针对内部的变形，在外部是无法通过__x这个名字访问到的。

  3. 在子类定义的__x不会覆盖在父类定义的__x，因为子类中变形成了：_子类名__x,而父类中变形成了：_父类名__x，即双下滑线开头的属性在继承给子类时，子类是无法覆盖的。

注意：对于这一层面的封装（隐藏），我们需要在类中定义一个函数（接口函数）在它内部访问被隐藏的属性，然后外部就可以使用了

要注意的问题是：

  1. 这种机制也并没有真正意义上限制我们从外部直接访问属性，知道了类名和属性名就可以拼出名字：_类名__属性，然后就可以访问了，

    变形的过程只在类的定义时发生一次,在定义后的赋值操作，不会变形

    在继承中，父类如果不想让子类覆盖自己的方法，可以将方法定义为私有的

class X:
    def __fa(self):
        print('from X')
    def test(self):
        self.__fa()
class B(X):
    def __fa(self):
        print('from B')

b = B()
b.test()

from X

注：__名字，这种语法只在定义的时候才有变形的效果，如果类或对象已经产生了，就不会有变形的效果了

私有模块：python并不会真的阻止你访问私有的属性，模块也遵循这种约定，以单下划线开头，那么from module import *时不能被导入该变量

property:

property装饰器用于将被装饰的方法伪装成一个数据属性，在使用时可以不加括号而被直接使用。

class Foo:
    def func(self):
        pass
    @property
    def size(self):
        return 100
foo_obj = Foo()
print(foo_obj.size)
--100
#不加括号
property:
    1.什么是property
        python内置的装饰器, 主要是给类内部的方法使用.

    2.为什么要用property
        使用它的目的,是将类内部的方法 (def 方法名()) 变成了 (def 方法).
        在对象调用某个方法时,将对象.方法()变成对象.方法(看起来想一个普通的数据属性)

    3.如何使用property
        @property

property属性的定义和调用要注意一下几点：

  1. 定义时，在实例方法的基础上添加 @property 装饰器；并且仅有一个self参数

  2. 调用时，无需括号

多态：

  • 多态是在定义角度

  • 多态性是在调用角度（使用角度）

多态指的是一类事物有多种形态（一个抽象类有多个子类，因而多态的概念依赖与继承）

注意：多态与多态性是两种概念

多态性是指具有不同功能的函数可以使用相同的函数名，这样就可以用一个函数名调用不同内容的函数。

在面向对象方法中一般是这样表述多态性：向不同的对象发送同一条消息，不同的对象在接收时会产生不同的行为（即方法）。

也就是说，每个对象可以用自己的方式去响应共同的消息。所谓消息，就是调用函数，不同的行为就是指不同的实现，即执行不同的函数。

如：序列数据类型有多种形态：字符串，列表，元组

多态性的优点：

1.增加程序的灵活性

2.增加程序的可扩展性

抽象类:

-abc模块

目的：强制子类必须遵循父类的一套标准

python不会强制要求子类必须遵循父类的一套标准，所以出现抽象类

import abc
class File(metaclass=abc.ABCMeta):
    def click(selfself):
        pass
class Text(File):
    def click(self):
        print('open file')

class ExeFile(File):
    def click(self):
        print('execute file')

text = Text()

exe_file = ExeFile()
text.click()
exe_file.click()
多态的目的:
        多态也称之为多态性, 在程序中继承就是多态的表现形式.
        多态的目的是为了, 让多种不同类型的对象, 在使用相同功能的情况下,调用同一个名字的方法名.
        父类: 定义一套统一的标准.
        子类: 遵循父类统一的标准.
        多态的最终目的: 统一子类编写的规范, 为了让使用者更方便调用相同功能的方法

总结：

多态：同一种事物的多种形态，动物分为人类，猪类（在定义角度）

多态性：一种调用方式，不同的执行效果（多态性）

鸭子类型:

-在不知道当前对象是何物的情况下，但是你长的像鸭子，那你就是鸭子类型，

在python中,不推荐使用抽象类强制限制子类的定义,但是推荐类都遵循鸭子类型

继承：

-耦合性太高，程序的可扩展性差

鸭子类型：

-耦合度低，程序的可扩展性强

多态炫技：

str1 = '1234'
list1 = [1,2,3]
def LEN(d):
    return d.__len__()
print(LEN(str1))
print(LEN(list1))
02-13 01:14
Powered by LMLPHP ©2025 多态 0.069643