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

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

#先查找对象他本身,如果没有,再去类里面找,如果还没有就报错
#一.自身有类也有
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        

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

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

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

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)

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
'''

# 组合：组合在一起
# 简单的选课系统
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')

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

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

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