类与对象,类的继承,类的派生,类的组合,多态

6.18-6.19自我总结

面向对象编程

1.类与对象

在python中先有类再有对象,类和对象,你可以看成,类是把对象的相同特征和相同方法汇总再一起,再根据类来生成对象,这个对象具有类的特征与方法

1.类的命名

class 类名:#这里类名必须用驼峰体进行命名有些特殊情况除外
    name = a #特征
    def __init__(self): self #对于生成的对象来说是生成的对象,对于类来说是个要传的形参,且__init__在运行类的时候他会调用函数
        pass
    def func():#func为方法.其在命名对象时候不会进行调用
        pass
类的调用
对象 = 类名()

2.对象的查找顺序

#先查找对象他本身,如果没有,再去类里面找,如果还没有就报错
#一.自身有类也有
class a:
    name = 'sb'
    def __init__(self,name):
        self.name = name
        
b = a('2b')
print(b.name)
#结果是2b
#自己没有类有
class a:
    name = 'sb'
    def __init__(self,name):
        self.xx = name
b = a('2b')
print(b.name)
#结果是sb        
                 

3.生成好后的对象进行值修改

用.把对于的值取出来再进行赋值修改,或者直接生成一个同名的对象把原来的覆盖掉

2.类的继承

1.父类,子类

继承是一种新建类的方式，新建的类称为子类，被继承的类称为父类

2.继承写法

class fu:
    print('from fu')
class son(fu): #命名中()内的内容则是这个类的其相对的父类,不进行处理默认传无参的父类
    pass
a = son()
print(a)
#from fu

3.查找顺序

#先查找对象他本身,如果没有,再去类里面找,如果还没就去父类的本身找,在去父类的类中找,以此类推.直到没有会报错
#菱形继承除外

3.类的派生

在父类和子类的基础上,子类再父类的基础上需要有更多的特征的时候这时候我们引入的派生

1.只有一个父类的时候

class fu:
    def __init__(self,name,age,money):
        self.name = name
        self.age = age
        self.money = money

#在他子类我们要加个车选项
#第一种写法
class son(fu):
    def __init__(self,name,age,money,car):
        super().__init__(name,age,money)
        self.car = car
son_1 =son(1,2,3,4)
print(son_1.car)
#第二种写法
'''
严格以来继承属性查找关系
super()会得到一个特殊的对象，该对象就是专门用来访问父类中的属性的（按照继承的关系）
super().__init__(不用为self传值)
super的完整用法是super(自己的类名,self),在python2中需要写完整，而python3中可以简写为super()
'''
class son(fu):
    def __init__(self,name,age,money,car):
        super(son,self).__init__(name,age,money)
        self.car = car
son_1 =son(1,2,3,4)
print(son_1.car)

2.有多个父类的时候

class fuone:
    def __init__(self,name,age):
        self.name = name
        self.age = age
class futwo:
    def __init__(self,money):
        self.money = money

class son(fuone,futwo): #不进行处理默认传无参的父类
    def __init__(self,name,age,money):
    # super(son, self).__init__(naem,age)等效与fuone.__init__(fuone,name,age)让父类不为无参
    #super我能力有限,只能做到他取第一个父类,没法做到他取第二个父类,可能他只能取第一个父类
        fuone.__init__(fuone,name,age)
        futwo.__init__(futwo,money)
son = son(1,2,3)
print(son.money)

#不做处理
class fuone:
    print('123')
    def __init__(self,name,age):
        self.name = name
        self.age = age
class futwo:
    print('123')
    def __init__(self,money):
        self.money = money

class son(fuone,futwo): #不进行处理默认传无参的父类,且自动导入了第一个,需要传和第一个一样的参数个数
    pass
'''
123
123
'''

4.类的组合

主要就是通过类的方法进行组合,而且方法内传的是类名

# 组合：组合在一起
# 简单的选课系统
class people:
    def __init__(self, name, gender):
        self.name = name
        self.gender = gender

    def eat(self):
        print(f'{self.name}开始吃了')


class student(people):
    def __init__(self, student_id, name, gender):
        self.student_id = student_id
        super(student, self).__init__(name, gender)

    def choose_course(self, course):  # python对象
        self.course = course  # 组合  # 把对象当作变量值来用，当作形参/实参/返回值。
        print(f'{self.name}选课{course.name}成功')


class teacher(people):
    def __init__(self, level, name, gender):
        self.level = level
        super(teacher, self).__init__(name, gender)

    def scored(self, student, course, score):
        print(f'老师{self.name}给{student.name}课程{course.name}打分{score}')


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


class admin(people):
    def create_course(self, name, price):
        course = course(name, price)
        print(f'管理员{self.name}创建了课程{name}')
        return course


# 课程
# python = course('python', '8888')
# linux = course('linux', '6666')

# 学生
zhubajie = student('01', 'zhubajie', 'male')
sunwukong = student('02', 'sunwukong', 'male')

# 老师
nick = teacher('1', 'nick', 'male')
tank = teacher('2', 'tank', 'female')

# 管理员
egon = admin('egon', 'male')

# 业务逻辑

# 1. 创建课程
python = egon.create_course('python', '8888')
print(python.__dict__)
linux = egon.create_course('linux', '6666')
print(linux.__dict__)

# 2. 学生选择课程
zhubajie.choose_course(python)


# 3. 老师给学生打分
nick.scored(zhubajie,python,'0')

5.多态

1.定义

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

1. 序列数据类型有多种形态：字符串，列表，元组
2. 动物有多种形态：人，狗，猪

2.使用示范

import abc


class animal(metaclass=abc.abcmeta):  # 同一类事物:动物
    @abc.abstractmethod  # 上述代码子类是约定俗称的实现这个方法，加上@abc.abstractmethod装饰器后严格控制子类必须实现这个方法
    def talk(self):
        raise attributeerror('子类必须实现这个方法')


class people(animal):  # 动物的形态之一:人
    def talk(self):
        print('say hello')


class dog(animal):  # 动物的形态之二:狗
    def talk(self):
        print('say wangwang')


class pig(animal):  # 动物的形态之三:猪
    def talk(self):
        print('say aoao')


peo2 = people()
pig2 = pig()
d2 = dog()

peo2.talk()
pig2.talk()
d2.talk()

3.注意事项

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

多态性是指具有不同功能的函数可以使用相同的函数名，这样就可以用一个函数名调用不同内容的函数。在面向对象方法中一般是这样表述多态性：向不同的对象发送同一条消息，不同的对象在接收时会产生不同的行为（即方法）。也就是说，每个对象可以用自己的方式去响应共同的消息。所谓消息，就是调用函数，不同的行为就是指不同的实现，即执行不同的函数。