面向对象-2

面向对象 - 2

目录

  • 对象独有的功能
  • 动静态的方法
  • 面向对象的三大特性
  • 数据和方法的查找顺序

对象的独有功能

  • 对象独有的数据

    class Person:
        h_type = '鸡类'
        def __init__(self,name):      # 让对象拥有独有的数据
            self.name = name
        def eat(self):
            print('干饭了')
    
    • 对象独有的方法

      对象不需要拥有独有的方法

      针对对象独有的方法 我们无法真正实现
      1.如果在全局则不是独有的
      2.如果在类中则是公共的

      python解释器针对上述问题添加了一个非常牛的特性
      定义在类中的函数默认是绑定给对象的(相当于是对象独有的方法)

      class Person:
          h_type = '鸡类'
          def __init__(self,name):      # 让对象拥有独有的数据
              self.name = name
              
           # 定义在类中的函数 我们称之为方法
          def eat(self):   # 是多个对象公共的方法 也算多个对象独有的方法  对象来调用就会将对象当做第一个参数传入
              print('干饭了' self.name)
      

      就是直接在类中的公共的方法,根据哪个对象来调取,就让这个对象的参数传入,间接的实现独有的方法

动静态方法

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

    1.绑定给对象的方法
    直接在类体代码中编写即可
    对象调用会自动将对象当做第一个参数传入
    类调用则有几个形参就传几个实参
    2.绑定给类的方法
    3.静态方法(普普通通的函数)

    class Student:
        school = '清华大学'
    
        # 绑定给对象的方法
        def run(self):  # self用于接收对象
            print('欢迎Jason来到红浪漫!!!', self)
    
        @classmethod  # 绑定给类的方法
        def eat(cls):  # cls用于接收类
            print('技师66号为Jason服务', cls)
    
        @staticmethod  # 静态方法
        def sleep(a, b):  # 无论谁来调用都必须按照普普通通的函数传参方式
            print('Jason快来呀')
            
            
       stu1 = Student()
        # 调用绑定给类的方法
         Student.eat()  # 类调用会自动将类当做第一个参数传入    eat(Student)
         stu1.eat()  # 对象调用会自动将产生该对象的类当做第一个参数传入  eat(Student)
        # 调用静态方法
         Student.sleep(1,2)
         stu1.sleep(1, 2)     
    

面向对象三大特性——继承

  • 面向对象的三大特性

    1. 继承
    2. 封装
    3. 多态
  • 继承的含义

    场景 含义 事例
    现实生活中 用来描述人与人之间资源的关系 儿子继承父亲的财产(拥有了父亲所有的资源)
    编程世界里 用来描述类与类之间数据的关系 类A继承类B(拥有了类B里面所有的数据和功能)
  • 继承的目的

    场景 目的 事例
    现实生活 占有别人的财产 亲身父亲 干爹 干妈 富婆
    编程世界 为了节省代码编写 可以继承一个类 也可以继承多个类
  • 继承的操作

    class 类名(类名):
        pass
    1.定义类的时候在类名后加括号
    2.括号内填写你需要继承的类名
    3.括号内可以填写多个父类 逗号隔开即可
    """
    	我们将被继承的类称之为: 父类或基类或超类
    	我们将继承类的类称之为: 子类或派生类
    	ps:平时最常用的就是父类和子类
    	"""
    class MyClass(F1,F2,F3):
        pass
    ps:目前掌握从左到右查找每个父类中的属性即可
    
  • 继承的本质

    将多个类的共同数据或功能抽取出来形成一个基类

    继承:从上往下白嫖各个基类里面的资源

    类别 含义
    对象 数据和功能的结合体
    多个对象相同的数据和功能的结合体
    父类 多个类相同的数据和功能的结合体

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

名字查找顺序

场景 查找顺序
不继承 先从对象自身查找 没有的话 再去产生该对象的类中查找
单继承 先从对象自身查找 然后是产生该对象的类 然后是一个个父类

多继承
非菱形继承(最后不会归总到一个我们自定义类上)>>> 深度优先(每个分支都走到底 再切换)
菱形继承((最后归总到一个我们自定义类上)>>>广度优先(只有 最后一个分支才会走最后一个类)
使用类点mro()方法查看该类产生的对象名字的查找顺序

​ 也可以使用类点mro()方法查看该类产生的对象名字的查找顺序

  • 不继承的情况下名字的查找顺序

    class Student:
        school = '清华大学'
        def choice_course(self):
            print('正在选课')
            stu1 = Student()
            print(stu1.school)  # 对象查找school 自身名称空间没有 所以查找的是类的  清华大学
            stu1.school = '北京大学'  # 在自身的名称空间中产生了新的school
            """对象点名字并写了赋值符号和数据值 那么操作的肯定是自己的名称空间"""
            print(stu1.school)  # 北京大学
            print(Student.school)  # 清华大学
    	对象	>>>	类
    

    ​ 对象点名字并写了赋值符号和数据值 那么操作的肯定是自己的名称空间

  • 单继承的情况下名字的查找顺序

        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()
        # obj.name = '我很困!!!'
        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()
    

    只要涉及到对象查找名字 几乎要回到最开始的位置依次查找

  • 多继承的情况下名字的查找顺序

    1. 非菱形继承

      深度优先:

      image

    2. 菱形继承

      广度优先

      image

经典类 与 新式类

类别 含义
经典类 不继承object或其子类的类(什么都不继承)
新式类 继承了object或其子类的类
  • object在python2和python3中的区别

    编辑器 区别
    python2 python2中有经典类和新式类
    经典类没有核心的功能 所以到了python3直接砍掉了
    python3 所有的类默认都会继承object
    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,money,teacher_year):
        # Person.__init__(self,name,age,gender)  # 先调用父类的方法
        super().__init__(name,age,gender)  # super专门用于子类调用父类的方法
        # 在父类的基础上加参数
        self.money = money           
        self.teacher_year = teacher_year
        
        
        
class MyClass(list):
    def append(self,value):
        if value == 'jason':
            raise TypeError('jason不能追加')
            super().append(value)   # 调取父类的append

obj = MyClass()
obj.append(111)
obj.append(222)
obj.append('jason')
obj.append(333)
"""用append添加参数需要经过if 判断,判断之后才能追加"""
posted @ 2022-07-27 17:44  Nirvana*  阅读(19)  评论(0)    收藏  举报