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

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.注意事项

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

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