面向对象 小结

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类的查找顺序