面向对象(二)
面向对象(二)
昨日回顾
对象概念：数据与功能的组合可以被称为对象
面向过程编程：根据功能编写代码
面向对线编程：根据特点对象编写特定代码
类与对象的概念：拥有相同功能的群体就叫做类，根据对象的抽象概念，类也是个对象
代码定义类：
语法结构
class 类名:
公共的数据
公共的功能
代码产生对象：
类名加括号产生,这个过程我们称之为实例化
对象 = 类名()
对象1 = 类名()
类产生的多个对象都可以访问到类中公共的数据和功能
对象独有的数据
对象.__init__['属性'] = '值'
因为其内部好似一个字典
绑定方法
所以类中定义的函数第一个形参会自动帮你写self
你传入的第一个参数，就默认会作为该字典的k值
class 类名:
def __init__(self, 属性):
对象.属性 = 值
def func(self):
pass
def index(self):
pass
今日学习内容
动态方法与静态方法
动态方法
第一种就是我们昨天学过的
1.绑定给对象
class 类名:
def 对象(self):
调用对象
类调用绑定给对象，传参，有几个就传几个参数
类名.对象(1,2,3)
对象调用绑定给对象的方法，会将对象当做第一个参数传入
对象1.对象()
2.绑定给类的方法
class 类名:
@classmethod
def 对象(cls):
调用对象
类调用绑定给类的方法:会自动将类当做第一个参数传入
print(类名)
类名.对象() 结果相同
对象调用绑定给类的方法:不需要传参，会将产生该对象的类自动当做第一个参数传入
对象1.对象() 结果相同
静态方法
class 类名:
@staticmethod
def 对象(a):
print(a)
1.普普通通的函数:无论谁来调 都必须传固定的参数个数
# 类调用静态方法:要自己传值
类名.对象(对应的参数)
# 对象调用静态方法:要自己传值
对象1.对象(对应的参数)
面向对象三大特性
继承 封装 多态
其中封装和多态更多的表现是一种概念
继承就更变相与实用性
继承的概念
现实生活中:
一切从他人获取的原不属于自己或者自己不拥有的资源，精神都可以算作继承
西撒:继承我最后的波纹吧！
面向对象中
继承原不不属于该类的功能或数据，通过继承的方法去获取。
例子:类A原不不拥有a的值，类b中有a = 1，类A继承类B后，类A就可以调用这个a = 1
继承的意义
现实生活中：物质方面接收馈赠，以更小的付出去完成想要的事物。精神层面获得传承，实现被继承者的目标。
面向对象中：减少代码冗余，提高开发效率，提升代码上限。
例子：类A可以继承类B的功能数据，同时也可以继承类C的功能和数据，继承的数量不受限制。
继承的基本使用
class A(B)
pass
被继承的类:父类，基类 B
继承者的类:子类，派生类 A
继承的本质
减少已有过的资源消耗，直接分享其结果
简单来说，就是为了减少不必要的代码冗余，结束代码量，提高工作上限。
对象：数据与功能的结合体
类：多个具有相同功能的对象的与他们公有的功能的结合体
父类：多个类于其功能的结合体
class Person: # 定义一个类
def __init__(self, name, age, gender): # 使用双下init方法定义需要接收的参数
self.name = name # 用self的变量名name接受传入的形参
self.age = age
self.gender = gender
class Teacher(Person): # 子类继承父类
def teach(self): # 定义函数
print(f'{self.name}老师正在讲课') # 调用父类的参数
class Student(Person): # 子类继承父类
def study(self): # 定义函数
print(f'{self.name}学生正在学习') # 调用父类中的参数
名字的查找顺序
在不继承的情况下
先从对象自己的名称空间中查找，没有则去类里面的名称空间查找
单继承的情况下
经典案例
class A: # 定义一个类
def f1(self): # 定义A类的功能，f1函数
print('from A.f1')
def f2(self): # 定义A类的功能，f2函数
print('from A.f2') # 定义f2类的功能
self.f1() # 运行f1函数
class MyClass(A): # 继承A类
def f1(self): # 自己定义一个f1的函数
print('from MyClass.f1') # f1的功能
obj = MyClass() # 实例化
obj.f2() # 调用f2函数
他的运行路线为
1.在对象名称空间中没有找到
2.在类的名称空间中没有找到
3.在父类A的名称空间中找到了
4.运行f2，先打印'from A.f2'
5.运行self.f1()
6.因为第一次传参self是MyClass()
7.运行f1，打印'from MyClass.f1'
多继承的情况下
Python2与python3的小差距
在python2中，存在经典类，表示该定义的类中不包含内置的(object)
这个object中代表了很多种方法，而python中需要调用这个object
则需要:
将他转成新式类
class MyClass(object):
pass
而python3中只存在新式类。自动添加object
深度优先：一直接找到最后的父类
广度优先：优先走完所有的子类，最后找到父类
派生类
派生类就是子类，子类可以基于父类的功能或数据，增添属于自己的功能或数据
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) # 获取父类中拥有的参数
self.level = level # 重新自己增加需要的参数
self.salary = salary
派生功能前瞻
class MyClass(list): # 调用list父类
def append(self,args): # 重写父类中append内置方法
if args == 123: # 进行判断
print('数字123不能追加') # 打印
return # 直接结束函数
super(MyClass, self).append(args) # 否则执行原来内置方法
obj1 = MyClass()
obj1.append(333)
obj1.append(222)
obj1.append(123)
print(obj1)
小结
搞明白了，最后这个派生功能很有意思，可以决定我是否需要使用本身的内置方法。
浙公网安备 33010602011771号