面向对象 小结
1:面向对象:就是一种编程思想 简称oop,指挥某某完成能完成的功能

2:面向对象与面向过程的优缺点 :
面向过程: 优点: 复杂问题简答化(一步一步解决), 流程化,
缺点:机械化 扩展性差 牵一发动全身
面向对象: 优点:提高了扩展性 复用性 可维护性提高
缺点:无法预知完成的结果 令程序复杂程度变高了

3:应用场景;
面向对象:适合扩展性高的程序 适合需求经常修改增加的程序
面向过程:适合扩展性低的程序

4:类和对象
对象:属性和技能的结合体
类:一系列相同属性和相同技能的集合体
注意:在面向对象的过程中,是先产生类,然后再去产生对象.

5:面向对象编程的思考过程
如果遇到面向对象的问题,首先想到的需要哪些对象,这些对象具备哪些属性和技能,再根据这些属性和技能去创建类,最后在创建对象出来

6:类和对象的创立
class Axxx: # 创建类 class
pass
A() # 创建对象

7:初始化__init__方法
定义:为对象属性设置初始值的函数
class A:
def __init__(self,属性名称,属性名称) # 这些是对象的初始值定义
self.属性名称 = 属性名称
self.属性名称 = 属性名称
def skill(self): # 这是技能(方法)函数
pass
a = A (属性名称1,)
a.属性名称 == A(属性名称1)
创建对象的时候时内部发生的事情:
首先会创建出一个名称空间 用来保存对象数据 ,此时自动调动__init__函数 ,自动把对象本身和属性绑定在一起.
注意点:有__init__函数时 传参不能为空,传入与__init__相对应的参数

8:绑定方法与非绑定方法
绑定方法:实质就是绑定函数
绑定方法---绑定到对象的方法 :类中默认的都是绑定到对象的方法
特点:参数的第一个必须是self 表示当前对象本身,使用对象来调用,调用时会自动传入对象
绑定方法- --绑定到类方法:用classmethon装饰器的方法,,,
特点:参数的第一个必须是cls表示当前类本身,使用类名来调用,调用时会自动传入类
非绑定方法: 用staticmethod装饰器装饰的方法
特点:不与类或对象绑定，类和对象都可以调用，但是没有自动传值那么一说

class Student:
school = "Tsinghua"

def say\_hello(self):# 绑定到对象的方法  
    print(self)  
    print("hello i am a student my name is %s" % self.name)

def \_\_init\_\_ (self,name): #绑定到对象的方法  
    self.name = name  
@classmethod     # 绑定到类的方法  
def school\_info(cls):  
    print(cls)  
    print("the student from %s" % cls.school)

stu1 = Student("Jack")
print(stu1)
#输出 <__main__.Student object at 0x1063112e8>

#1.调用对象绑定方法
stu1.say_hello()
#输出 <__main__.Student object at 0x1063112e8>
#输出 hello i am a student my name is Jack

#查看对象绑定方法
print(stu1.say_hello)
#输出 >
#含义 这个绑定方法是Student类中的say_hello函数,绑定到地址为0x10552b2e8的Student对象

#绑定方法本质上也是函数 只要能找到它就能调用它所以你可以这样来调用它
Student.say_hello(stu1)
#输出 <__main__.Student object at 0x103818390>
#输出 hello i am a student my name is Jack

print(Student)
#输出
#2.调用类绑定方法
Student.school_info()
#输出
#输出 the student from Tsinghua

#查看类绑定方法
print(Student.school_info)
#输出 >
#含义 这个绑定方法是Student类中的school_info函数,绑定到Student这个类

9:类的继承 抽象
继承定义:一个类中属性和方法可以被另一个类引用时 就是继承
抽象:就是A类 B类 有部分相同的属性和方法也不同的属性方法 那么将共同相同的属性和方法拿出来创建一个新的C类 两个类在去继承C类就好了
class A:
pass
class B(A)
pass

B类继承A类 那B类的对象就可以使用A类对象的属性和方法 A类就是父类 B类就是子类

class Teacher:
def __init__(self,name,gender,age):
self.name = name
self.gender = gender
self.age = age
def say_hi(self):
print("hi my name is %s age is %s gender is %s" % (self.name,self.age,self.gender))

class Student(Teacher): #指定Teacher类继承Student类
pass

#创建两个对象
t1 = Teacher("Jack","man",20)
t1.say_hi()
s1 = Student("Maria","woman",20)
s1.say_hi()

10:派生和覆盖
派生:子类不同于父类的属性和方法
覆盖:子类中的属性和父类的名称一致 优先使用子类的属性和方法

11:子类中重用父类的方法
1:直接用类名调用 无继承也可是调用
2:super()函数
class A:
def __init__(self,name,,age,gender)
self.name = name
……
class B(A):
def __init__(self,name,,age,gender,sleep) # 子类多一个属性sleep
super().__init__(name,,age,gender) # 继承父类的三个属性
self.sleeo = sleep # 添加的属性

12:接口 抽象类
接口:就是一套规范 按照这个规范来就可以被使用
抽象类:如果这个类中的方法是不具体(没有实现功能的代码)的抽象的,那么这个类也是抽象的;
导入 import abc 模块来使用的 用@abc.abstractmethod 装饰器
#_*_coding:utf-8_*_
#一切皆文件
import abc #利用abc模块实现抽象类

class All_file(metaclass=abc.ABCMeta):
all_type='file'
@abc.abstractmethod #定义抽象方法，无需实现功能
def read(self):
'子类必须定义读功能'
pass

@abc.abstractmethod #定义抽象方法，无需实现功能  
def write(self):  
    '子类必须定义写功能'  
    pass

class Txt(All_file):

pass

t1=Txt() #报错,子类没有定义抽象方法

class Txt(All_file): #子类继承抽象类，但是必须定义read和write方法
def read(self):
print('文本数据的读取方法')

def write(self):  
    print('文本数据的读取方法')

class Sata(All_file): #子类继承抽象类，但是必须定义read和write方法
def read(self):
print('硬盘数据的读取方法')

def write(self):  
    print('硬盘数据的读取方法')

class Process(All_file): #子类继承抽象类，但是必须定义read和write方法
def read(self):
print('进程数据的读取方法')

def write(self):  
    print('进程数据的读取方法')

wenbenwenjian=Txt()

yingpanwenjian=Sata()

jinchengwenjian=Process()

#这样大家的使用方法时完全一致的,也就是一切皆文件的思想
wenbenwenjian.read()
yingpanwenjian.write()
jinchengwenjian.read()

print(wenbenwenjian.all_type)
print(yingpanwenjian.all_type)
print(jinchengwenjian.all_type)

13;组合
组合定义:在一个类中以另外一个类的对象作为数据属性 则是类的组合
类可以继承使用也可以组合使用

class Equip: #武器装备类
def fire(self):
print('release Fire skill')

class Riven: #英雄Riven的类,一个英雄需要有装备,因而需要组合Equip类
camp='Noxus'
def __init__(self,nickname):
self.nickname=nickname
self.equip=Equip() #用Equip类产生一个装备,赋值给实例的equip属性
r1=Riven('锐雯雯')
r1.equip.fire() #可以使用组合的类产生的对象所持有的方法

14:鸭子类型
定义:长得像鸭子(技能) 走路像鸭子 叫声像鸭子(属性) 那就就是鸭子
class PC():

def conntent\_device(self, usb\_device):  
    usb\_device.open()  
    usb\_device.work()  
    usb\_device.close()

class Mouse:
# 实现接口规定的所有功能
def open(self):
print("mouse opened")

def work(self):  
    print("mouse working...")

def close(self):  
    print("mouse closed")

mouse = Mouse()
pc = PC()

pc.conntent_device(mouse)

class KeyBoard:
def open(self):
print("KeyBoard opened")

def work(self):  
    print("KeyBoard working...")

def close(self):  
    print("KeyBoard closed")

key1 = KeyBoard()

如果key1的特征和行为都像USB设备 那就把它当做USB设备来使用

对于使用者而言可以不用关心这个对象是什么类,是如如何是实现,

pc.conntent_device(key1)

15:属性的查找方法的顺序
对象---子类>--->父类--->父类的父类…..object. object是所有的类的基类
子类有多个父类时,运用mro列表展示的顺序来查找
print(A.mro()) 就是A类的查找顺序