面向对象 --- 类的组合，封装，多态

目录

• 组合
  • 1.什么是组合
  • 2.为什么要使用组合？
• 封装
  • 1.什么是封装？
  • 2.为什么要封装？
  • 3.如何封装？
• 访问限制机制
  • 1.访问限制机制是什么？
  • 2.访问限制机制的目的？
• property
  • 1.什么是property
  • 2.为什么要用property
  • 3.如何去使用property
• 多态
• 抽象类
  • 1.什么是抽象类
  • 2.使用的目的
  • 3.如何使用
  • 鸭子类型：
    • 1.什么是鸭子类型
  • 多态炫技操作

组合

1.什么是组合

组合指的是一个对象中的属性，是另一个对象。

好处：提高程序的可扩展性

就是定义多个类，然后将类实例化，在通过对类添加的行式来将需求的类添加到子类里边。

总结：

继承是一种类与类的关系，一种什么是什么的关系。，子类与父类是从属关系

组合是对象与对象的关系，是一种什么有什么的关系，一个对象拥有另一个对象。

2.为什么要使用组合？

提高可扩展性，组合目的和继承一样，为了减少代码冗余

'''
选课系统需求:
    1.学生类,老师类, 学生和老师都有课程属性, 每一门课程都是一个对象.
        课程: 课程名字,课程周期,课程价钱

    2.学生和老师都有选择课程的功能, 还有打印所有课程的功能.
'''
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)
        print(course_list)

    # 打印当前对象中所有课程的课程信息
    def tell_all_course(self):
        # 拿到当前对象的课程列表,列表中存放的是一个个的课程对象
        for course_obj in self.course_list:

            # 每一个课程对象调用查看课程信息的方法
            course_obj.tell_course_info()

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_period, course_price):
        # 课程名称周期价格
        self.course_name = course_name
        self.course_period = course_period
        self.course_price = course_price

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


tea1 = Teacher('tank', 17, 'male')
stu1 = Student('张全蛋', 20, 'female')
python_obj = Course('python', 6, 2.0)
linux_obj = Course('linux', 6, 1.0)

# 添加python与linux课程
tea1.add_course(python_obj)
# tea1.add_course(linux_obj)

tea1.tell_all_course()

封装

面向对象的精髓

继承，封装，多态

1.什么是封装？

封：比如把一个袋子封起来。

装：比如把一堆小猫小狗装进袋子里。

封装指的是把一堆属性（对象的特征与属性）封装到一个对象中

存数据的目的就是为了取，对象可以”.“的方式获取属性

比喻：对象就好比是一个袋子袋子里面装一堆属性

2.为什么要封装？

封装的目的是为了方便存取，可以通过对象.属性的方式获取属性。

3.如何封装？

特征：变量--》数据类型

技能：函数--》方法属性

在类内部，定义一堆属性（特征与技能），通过对象.属性 = 属性值 去封装属性

访问限制机制

面向对象的核心

1.访问限制机制是什么？

在类内部定义，凡是以 _开头的数据属性与方法属性，都会被python内部隐藏起来，让外部的不能直接访问类内部的_开头的属性，比如：__name = 'tank'

2.访问限制机制的目的？

一推隐私的属性与不能被外部轻易访问的属性，可以隐藏起来，不被外部直接调用

好处：对重要数据获取的逻辑更加严谨，进而保证了数据的安全。

隐私属性可以通过封装一个接口，在接口内做业务逻辑的处理，再把数据返回给调用者

注意：再python中，不会强制限制属性的访问，类内部__开头的属性，只是做了一种变形，若想访问限制后的属性，调用变形后的名字即可。

class ATM:
    # 1.插卡
    def __insert_card(self):
        print('插卡')
        pass

    # 2.输入密码
    def __input_pwd(self):
        print('密码验证')
        pass

    # 3.输入取款金额
    def __input_money(self):
        print('输入金额')
        pass

    # 4.开始吐钱
    def __get_money(self):
        print('执行吐钱')
        pass

    # 5.打印账单
    def __print_flow(self):
        print('打印账单')
        pass

    # 取钱直接接口
    def withdraw(self):
        self.__insert_card()
        self.__input_pwd()
        self.__input_money()
        self.__get_money()
        self.__print_flow()
        print('取款程序执行完毕!')
# 

atm = ATM()
atm.withdraw()

property

1.什么是property

python内置的装饰器，主要是给类内部的方法使用的，

2.为什么要用property

使用它的目的是将类内部的方法（def 方法名）变成了（def方法），

在对象

注意：不能对被装饰过的方法属性修改

3.如何去使用property

@property

'''
计算人体的bmi: bmi值 = 体重 / (身高 * 身高)


'''
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 * self.height)

    # 了解
    @property
    def get_name(self):
        return self.name

    # 改
    @get_name.setter
    def set_name(self, val):
        self.name = val

    # 删除
    @get_name.deleter
    def del_name(self):
        del self.name

p = People('jason', 200, 1.6)
print(p.bmi())  # 打印动词,看起来不合理
print(p.bmi)  # ---> 在调用的时候不用写成p.bmi(),只需要写成p.bmi。

# 注意: 不能对被装饰过的方法属性修改.

# 了解: 若真要通过此方法修改属性,可以通过另一种方式修改.
print(p.get_name)
p.set_name = 'tank'
print(p.get_name)
# p.del_name()
# print(p.get_name)
del p.del_name
print(p.get_name)

多态

1.什么是多态

同一种事物的多种形态。

2.多态的目的

多态也称之为多态性，在程序中继承就是多态的表现形式。

多态的目的是为了让多种不同类型的对象，在使用相同功能的情况下，调用同一个名字的方法

父类：定义一套统一的标准。

子类：遵循父类统一的标准。

多态的最终目的：统一子类编写的规范，为了让使用者更方便调用相同功能的方法

3.如何实现多态

注意：在python中，不会强制要求子类必须遵循父类的一套标准，所以出现了抽象类。

抽象类

1.什么是抽象类

是一个模块 abc模块，全称：abstract_class

2.使用的目的

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

3.如何使用

import abc

import abc

class Animal(metaclass=abc.ABCMeta):

    # 吃
    @abc.abstractmethod     # @abc.abstractmethod只会让定义过的执行标准，其他的不会强制执行
    def eat(self):
        pass

    # 喝
    @abc.abstractmethod
    def drink(self):
        pass

    # 叫
    @abc.abstractmethod
    def speak(self):
        pass

# 猪
class Pig(Animal):
    # 吃
    def eat(self):
        print('猪在吃饭')
        pass

    # 喝
    def drink(self):
        pass

    def speak(self):
        print('哼哼哼~~~')

    # 派生
    def run(self):      # 没有被@abc.abstractmethod定义，不需要强制执行
        pass

鸭子类型：

1.什么是鸭子类型

在不知道当前对象是何物的情况下，但是你长得想鸭子，呢么你就是鸭子

在python中，不推荐使用抽象类

多态炫技操作

# 猪
class Pig:
    # 吃
    def eat(self):
        print('猪在吃饭')
        pass
    # 喝
    def drink(self):
        pass
    def speak(self):
        print('哼哼哼~~~')


# 猫
class Cat:
    # 吃
    def eat(self):
        print('猫在吃饭')
        pass
    # 喝
    def drink(self):
        pass
    def speak(self):
        print('喵喵喵~~')

# 狗
class Dog:
    # 吃
    def eat(self):
        print('狗在吃饭')
        pass
    # 喝
    def drink(self):
        pass
    def speak(self):
        print('汪汪汪~~~')

dog = Dog()
cat = Cat()
pig = Pig()

def BARK(animal):
    animal.speak()

BARK(dog)
BARK(cat)
BARK(pig)