Python面向对象之继承

对象独有的功能

在类的内部，使用 def 关键字来定义一个方法，与一般函数定义不同，类方法必须包含参数 self, 且为第一个参数，self 代表的是类的实例。

'''
针对对象独有的方法 我们无法真正实现
    1.如果在全局则不是独有的
    2.如果在类中则是公共的
python解释器针对上述问题添加了一个非常牛的特性
    定义在类中的函数默认是绑定给对象的(相当于是对象独有的方法)
'''

# 类定义
class People:
    # 定义基本属性
    name = ''

    # 定义构造方法
    def __init__(self, n, a):  # 让对象拥有独有的数据
        self.name = n
        self.age = a

    def speak(self):  # 是多个对象公共的方法，也算多个对象独有的方法
        print("%s 说: 你困吗？" % self.name)

    def others(self):
        print('%s 今年 %s 岁' % (self.name, self.age))


# 实例化类
p = People('kwan', 18)
p.speak()  # kwan 说: 你困吗？
p.others()  # kwan 今年 18 岁

动静态方法

专门针对在类体代码中编写的函数

1. 动态方法

绑定给对象的方法

>>> class Student:
...     # 绑定给对象的方法
...     def run(self):  # self用于接收对象
...         print(self)
...
>>>
>>> stu = Student()
>>> stu.run()  # 对象调用会自动将对象当作第一个参数传入
<__main__.Student object at 0x00000218BD02C8E0>

'''
直接在类体代码中编写即可 
	对象调用会自动将对象当做第一个参数传入
	类调用则有几个形参就传几个实参 
'''

绑定给类的方法

>>> class Student:
...     # 绑定给类的方法
...     @classmethod  # 定义类方法关键字
...     def eat(cls):  # 参数一般写cls，用于接收类
...         print(cls)
...
>>>
>>> Student.eat()  # 类调用会自动将类当做第一个参数传入
<class '__main__.Student'>
>>> print(Student)
<class '__main__.Student'>
>>>
>>> stu = Student()  # 对象调用会自动将产生该对象的类当做第一个参数传入
>>> stu.eat()
<class '__main__.Student'>

2. 静态方法

即普通的函数，定义之后就不会自动传self，但是括号内有几个参数就必须传几个参数

>>> class Student:
...     # 静态方法
...     @staticmethod  # 定义静态方法关键字
...     def speak(a):  # 无论谁来调用都必须按照普普通通的函数传参方式
...         print(a)
...
>>>
>>> # 类调用静态方法要自己传值
>>> Student.speak(123)
123
>>>
>>> # 对象调用静态方法也要自己传值
>>> stu = Student()
>>> stu.speak(321)
321

继承

基本概念

在面向对象的世界中，从父类继承，就可以直接拥有父类的属性和方法
继承可以减少代码、多复用。
子类可以定义自己的属性和方法

# 在现实生活中继承其实就是用来描述人与人之间资源的关系
eg:
     儿子 继承 父亲的财产 (拥有了父亲所有的资源) 

# 在编程世界里继承其实就是用来描述类与类之间数据的关系   
eg:
     类A 继承 类B (拥有了类B里面所有的数据和功能)

基本使用

被继承的类称之为: 父类或基类或超类
继承类的类称之为: 子类或派生类

ps：平时最常用的就是父类和子类

# 语法格式
class ParentClass1: #定义父类
    pass

class ParentClass2: #定义父类
    pass

class SubClass1(ParentClass1): #单继承
    pass

class SubClass2(ParentClass1,ParentClass2): #多继承
    pass

定义类的时候在类名后加括号

括号内填写你需要继承的类名

括号内可以填写多个父类，逗号隔开即可

继承与抽象

抽象：将多个类共同的数据或功能抽取出来形成一个基类
继承：从上往下白嫖各个基类里面的资源

对象：数据和功能的结合体

类：多个对象相同的数据和功能的结合体

父类：多个类相同的数据和功能的结合体

ps: 类和父类最主要的功能其实就是节省代码

名字的查找顺序

主要涉及到对象查找名字，几乎都是：对象自身>>>类>>>父类

1. 不继承的情况

对象 >>> 类

>>> class Student:
...     school = '清华大学'
...
...     def choice_course(self):
...         print('正在选课')
...
>>>
>>> stu1 = Student()
>>> print(stu1.school)  # 对象查找school 自身名称空间没有 所以查找的是类的  清华大学
清华大学

 """对象点名字并写了赋值符号和数据值，那么操作的肯定是自己的名称空间"""
>>> stu1.school = '北京大学'  # 在自身的名称空间中产生了新的school
>>> print(stu1.school)
北京大学
>>> print(Student.school)
清华大学

2. 单继承的情况

对象 >>> 类 >>> 父类...

# 先从对象自身查找 然后是产生该对象的类 然后是一个个父类
class A:
    # name = 'from A'
    pass


class B(A):
    # name = 'from B'
    pass


class C(B):
    # name = 'from C'
    pass


class MyClass(C):
    # name = 'from MyClass'
    pass


obj = MyClass()
print(obj.name)


'''只要涉及到对象查找名字 几乎要回到最开始的位置依次查找'''
class A1:
    def func1(self):
        print('from A1 func1')

    def func2(self):
        print('from A1 func2')
        self.func1()  # obj.func1()

    class MyClass(A1):
        def func1(self):
            print('from MyClass func1')

    obj = MyClass()
    obj.func2()

3. 多继承的情况

简单的多继承

子类中未找到时，从左到右查找父类

class A:
    name = 'from A'
class B(A):
    name = 'from B'
class C(B):
    name = 'from C'
class MyClass(A, B, C):
    name = 'from MyClass'
    
obj = MyClass()
print(obj.name)

多继承

非菱形继承

即最后不会归总到一个我们自定义类上

深度优先(每个分支都走到底再切换)

class D:
    name = 'from D'
class E:
    name = 'from E'
class F:
    name = 'from F'
class A(D):
    name = 'from A'
class B(E):
    name = 'from B'
class C(F):
    name = 'from C'
class MyClass(A, B, C):
    name = 'from MyClass'
    
obj = MyClass()
print(obj.name)

非菱形

菱形继承

即最后归总到一个我们自定义类上

广度优先(前面几个分支都不会走最后一个类最后一个分支才会走)

class G:
    name = 'from G'
class D(G):
    name = 'from D'
class E(G):
    name = 'from E'
class F(G):
    name = 'from F'
class A(D):
    name = 'from A'
class B(E):
    name = 'from B'
    pass
class C(F):
    name = 'from C'
    pass
class MyClass:
    name = 'from MyClass'
    pass

obj = MyClass()
print(obj.name)

经典类与新式类

经典类

不继承object或其子类的类(什么都不继承)
新式类

继承了object或其子类的类

在python3中所有的类默认都会继承object

也就意味着python3里面只有新式类

在python2中有经典类和新式类

由于经典类没有核心的功能所以到了python3直接砍掉了

以后我们在定义类的时候如果没有想要继承的父类

一般推荐以下写法
class MyClass(object):
pass
目的是为了兼容python2

派生方法

子类中定义类与父类一模一样的方法并且扩展了该功能：派生

class Person:
    def __init__(self,name,age,gender):
        self.name = name
        self.age = age
        self.gender = gender
        
class Teacher(Person):
    def __init__(self,name,age,gender,level,salary):
        super().__init__(name,age,gender)  # super专门用于子类调用父类的方法  
        self.level = level    
        
class Student(Person):
    def __init__(self,name,age,gender,stu_id,class_id):
        super().__init__(name, age, gender)   # super(Teacher,self).__init__(name,age,gender)
        self.stu_id = stu_id
        self.class_id = class_id
        
'''子类继承父类后如果需要扩展可以使用super关键字，这样的子类就叫派生类，本质其实还是子类'''

posted @ 2022-07-27 21:39 梦想有双休阅读(46) 评论(0) 收藏举报

刷新页面返回顶部

yi-chun