python-面向对象小结

面向对象 小结
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)
#输出 <bound method Student.say_hello of <__main__.Student object at 0x10552b2e8>>
#含义 这个绑定方法是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)
#输出 <class '__main__.Student'>
#2.调用类绑定方法
Student.school_info()
#输出 <class '__main__.Student'>
#输出 the student from Tsinghua

#查看类绑定方法
print(Student.school_info)
#输出 <bound method Student.school_info of <class '__main__.Student'>>
#含义 这个绑定方法是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类的查找顺序