day09-测试编程之python的面向对象

一、面向对象和面向过程

        照例来介绍一下这两个词的意思

        1.1.面向对象

                1).概念：通俗一点解释，就是把事物拆成一个一个对象来解决问题

                2).特点：在完成某个需求前，首先确定职责

                3).缺点：顺序地让不同的对象调用不同的方法

                4).代表语言：JAVA、Python

        1.2.面向过程（更多用于写操作系统、数据库服务器）

                1).概念：通俗一点解释，就是把事物拆成一个一个函数来解决问题，函数之间相互调用

                2).特点:注重步骤与过程，不注重职责分工

                3).缺点：开发复杂项目，没有固定套路，开发以及维护难度很大！

                4).代表语言：C、C++、C#

二、类和对象

        在了解面向对象之前，先来解释一下类和对象

        2.1.类

                1).概念：类是对一群具有相同特征或者行为的事物的统称，是抽象的，不能直接使用（比如：飞机图纸，是一个模板）

                2).属性和方法

                        1.属性：事物的特征称为属性(事物的描述信息)

                        2.方法：事物的行为称为方法(事物的行为动作)

        2.2.对象

                1).概念：对象是由类创建出来的一个具体的存在事物，可以直接使用

                2).说明：由于对象是由类创建出来的，因此类具有的属性和方法，对象同样具有

        2.3.类和对象的关系

                1).先有类，再有对象

                2).类是对象的模板，通过类可以创建对象

                3).类只有一个，而对象可以有多个

                4).类中有什么样的属性和方法,则对象中也会有什么样的属性和方法

                5).对象之间的属性值和方法的实现可能有所不同

                6).类是抽象的，不能直接使用，对象是具体存在，可以直接使用

        2.4.设计类（重要）

                1).三个元素

                        1.类名

                                (1).从具体的事物中提取出来的具有共同特征和行为的名词       

                                (2).符合大驼峰命名法 (每个单词的首字母要大写，单词与单词之间没有下划线)

                        2.属性

                                (1).具体事物具有的特征--->属性(名词)

                                (2).具体事物的描述信息

                        3.方法

                                (1).具体事物具有的行为--->方法(动词)

                                (2).具体事物的行为动作

                2).注意：需求中没有涉及的属性或者方法在设计类时，不需要考虑

三、面向对象基础语法

        3.1.dir内置函数（了解即可）

                1).是python中的内置函数

                2).作用：可以用来查看变量或对象中所有的属性和方法

                3).魔法方法

        3.2.定义简单的类(只包含方法)---封装性

                1).语法格式

                2).说明：类名必须符合大驼峰命名法

                3).方法和函数的区别

                        3.1).相同点：都是封装代码的整体，都是实现某个功能的小工具

                        3.2).不同点

                                (1).定义的位置不同

                                        1.函数定义在类的外部

                                        2.方法定义在类的内部

                                (2).参数不同

                                        1.函数没有self参数

                                        2.方法有self参数

                                (3).调用的方式不同

                                        1.函数名(参数)

                                        2.对象名.方法名(参数)

        3.3.类创建对象

                1).格式

                2).对象变量名保存的是对象内存地址的引用

                3).访问方法：对象名.方法名

        3.4.方法调用顺序

                1).定义类模板时，python解释器会进入类模板内部扫描一遍，定义方法，不会进入方法内部执行代码，类模板只会初始化一次

                2).当使用类模板创建对象，通过对象名.方法名（）调用方法时，才会进入方法内部执行代码

                3).方法中的代码执行完，回到调用的地方，继续向下执行

                4).对象名就是一个变量名，保存当前对象内存空间的引用地址

        3.5.方法中的self参数

                1).self参数保存当前对象地址的引l用（当前调用方法的对象是哪个，self参数就保存哪个对象的引l用）

                2).在类外部通过对象调用方法时，不需要手动传入self参数，Python解释器自动传参

                3).在类内部访问属性：self.属性名

                4).在类内部访问方法：self.方法名()

                5).在类外部访问属性：对象名.属性名

                6).在类外部访问属性：对象名.方法名()

        3.6.给对象添加属性有两种方式

                1).在类外部给对象添加属性

                        1.1).方式：对象.属性名=属性值

                        1.2).访问方式：

                                1.在类内部，可以使用self参数访问属性self.属性名

                                2.在类外部，通过对象访问属性对象名.属性名

                        1.3).说明：不推荐使用，如果程序在运行时，没有找到属性，会报错

                2).在类内部给对象添加属性，在初始化方法内部添加属性

                3).注意：给对象添加属性，属性添加到对象的内存空间中

        3.7.初始化方法_init__

                1).初始化方法_init_方法是python内置方法（魔法方法：在某些情况下会自动调用）

                2).使用类名（）创建实例对象时，初始化方法_init_(self,参数列表）会自动调用

                3).格式

                4).作用：用来初始化属性数据的

                5).始化的同时设置属性值

                        5.1).格式

                        5.2).步骤

                                1.在初始化方法__init_(self，参数1...)中添加参数

                                2.在初始化方法内部把参数保存为属性self.属性名=参数1

                                3.在使用类模板创建对象时传递参数类名（参数1的值）

        3.8.内置方法__del__（了解）

                1).删除方法(释放资源的方法)，是在对象被销毁前自动调用的

                2).对象的生命周期是从创建对象开始到调用_del__方法结束

                3).在对象的生命周期中可以访问属性和方法，如果对象销毁后，不能访问属性和方法

                4).如果需要手动删除一个对象时，需要使用del关键字

        3.9.内置方法__str__（了解使用）

                1).打印实例对象时的描述信息，print(实例对象名)

                2)._str_方法必须返回一个字符串

                3).没有定义，默认输出对象的引|用地址

        3.10.身份运算符

                1).身份运算符用于比较两个对象的内存地址是否一致一是否是对同一个对象的引用

                        1.1).is

                        1.2).is not

                2).注意

                        1.1).在Python中针对None比较时，建议使用is判断，示例：isNone

                        1.2).is与==的区别

                                1.is用于判断两个变量引用地址是否相同

                                2.==用于判断引用变量的值是否相等

        3.11.私有方法和私有属性

                1).概念：有些情况下，类中一些属性和方法不需要类外实例对象直接访问到，可以把类中的属性和方法定义为私有

                2).格式：前置双下划线的属性和方法就是私有属性和私有方法，例如：_age私有属性，__screat(self）私有方法

                3).说明

                        3.1).私有属性和私有方法在类外部不能直接访问，但是可以在类内部访问到

                        3.2).Python中并没有真正意义上的私有属性和私有方法，而是通过名字重整的方式将私有属性和私有方法改了名字

                        3.3).私有属性和私有方法名字重整后：

                                1.私有属性名==>>_类名_私有属性名

                                2.私有方法名==>>_类名_私有方法名

                        3.4).可以通过重整后的私有属性名和私有方法名，间接去访问，例如：对象名.类名_私有属性名

                4).注意：Python中的警告：Python中不阻止你去干坏事，一切靠自觉，不推荐去间接访问私有属性或私有方法

四、面向对象高级部分

        4.1.继承

                1).概念：子类拥有父类的属性和方法(私有属性和私有方法除外)

                2).继承的优点

                        2.1).去除重复代码

                        2.2).简化代码结构

                3).语法：class 子类名(父类名)

                4).注意

                        4.1).子类继承父类后，就可以调用父类的属性和方法

                        4.2).子类中可以自定义自己的属性和方法

                        4.3).继承中，父类不能使用子类的属性和方法

                        4.4).继承不是复制，而是通过子类的对象去父类模板查找属性或方法，如果找到了就访问，找不到就报错

                5).多层继承

                        5.1).样式：孙子类继承了父亲类，父亲类继承了爷爷类，

                        5.2).特点：孙子可以直接使用爷爷的方法/属性，爷爷类/父类不能访问孙子类中的属性和方法

        4.2.方法的重写

                1).当父类方法不能满足子类的需求时，子类可以对父类方法进行重写

                2).子类中如果有与父类相同的方法名，说明子类重写了父类的方法

                3).子类重写父类的方法，调用的方法自己重写的方法，不是父类的方法

                4).方法的重写分类

                        4.1).覆盖子类重写父类方法时，实现的功能与父类完全不同

                        4.2).扩展父类的方法不能完全满足子类的需求，子类需要在父类方法的基础上进行功能扩展

                5).在重写的方法中调用父类的方法

                        5.1).super().重写的方法()

                        5.2).父类名.重写的方法(self)---->不推荐使用（类名改变，代码也要改变，麻烦)

        4.3.父类的私有属性和私有方法:

                1).子类不能直接访问父类的私有属性

                2).子类不能直接调用父类的私有方法

                3).通过对外提供访问私有属性方法，间接访问

        4.4.多继承

                1).一个子类继承多个父类

                2).格式：子类(父类名1，父类名2...)

                3).多继承时，子类拥有父类的所有方法和属性(（不包括私有属性和私有方法)

                4).继承中父类有相同的方法名

                        4.1).调用同名父类方法由_mro__(方法解析顺序)决定

                        4.2).规则：哪个对象调用方法就去自己的类中去查找这个方法，没有将去调用父类的

        4.5.Object类

                1).oobject类是所有类的父类

                2).python2.x解释器是经典类默认不继承object

                3).python3.x解释器是新式类默认继承object

                4).推荐大家定义类时，加上继承object

        4.6.多态

                1).不同的对象调用相同的方法，产生不同的状态结果，就是多态

                2).满足多态的三个条件

                        2.1).要有继承

                        2.2).要有方法的重写

                        2.3).要有父类或子类的对象作为方法的参数

        4.7.对象

                1).实例对象

                        1.1).类创建出来的对象就是实例对象(实际存在的对象)

                        1.2).实例对象中保存着实例属性，注意：每个实例对象中保存自己的实例属性，彼此独立互不干扰

                        1.3).实例对象可以调用实例方法，但是实例对象的实例方法都是保存在类模板中的（实例方法是实例对象公有的)

                2).类对象

                        2.1).类名就是类对象

                        2.2).Python解释器遇到class关键字，class关键字后面的变量名就是类对象名，类对象名保存类模板空间地址引用

                        2.3).类对象一般只有一个，实例对象可以有多个，通过类对象创建实例对象

                        2.4).Python中一切皆对象，函数，数字，方法，类都是对象

        4.8.属性

                1).实例属性

                        1.1).实例属性是属于实例对象的，保存在对象的内存空间中

                        1.2).每个实例对象都有自己的实例属性，各个实例对象中实例属性值各有不同

                        1.3).在类内部访问实例属性，通过self参数，self.属性名

                        1.4).在类外部访问实例属性，通过实例对象，实例对象.属性名

                2).类属性

                        1.1).也是一种属性，属于类对象的属性(存在类模板中)在创建类对象时只被初始化一次

                        1.2).定义在类的内部，方法外部，作用：用来记录类对象的属性特征

                        1.3).访问类属性的方式类名.类属性名(推荐）实例对象名.类属性名(不推荐)

                        1.4).注意：通过实例对象并没有修改类属性的值，而是定义了一个与类属性同名的实例属性

                        1.5).使用类属性可以在不破坏类的封装特性前提下保存类模板某些特性

        4.9.方法

                1).实例方法 (最常用)

                        1.1).实例方法是属于实例对象的

                        1.2).格式

                        1.3).实例方法一般用来处理实例属性的

                        1.4).保存在类模板中(为多个实例对象所共有)

                        1.5)调用方式

                                1.类内部：self.方法名（参数列表）

                                2.类外部：实例对象名.方法名（参数列表）

                2).类方法 (会用)

                        2.1).类方法是一种特殊的方法，用来处理类属性

                        2.2).格式

                        2.3).注意@classmethod是一种语法糖(语法现象)，装饰器(修饰器)，告诉python解释器，当前的方法是特殊的方法(类方法)

                        2.4).参数cls表示调用当前方法的类对象的引用

                        2.5).调用类方法

                                1.类名.类方法名()----推荐

                                2.实例对象名.类方法名()不推荐使用(因为实例对象一般访问的是实例方法)

                3).静态方法 (基本不用)

                        3.1).静态方法既不需要self参数，也不需要cls参数

                        3.2).静态方法中不需要用到实例对象的实例属性和实例方法，也不需要用到类对象的类属性和类方法

                        3.3).静态方法不会破坏类的封装性

                        3.4).格式

                        3.5).装饰器@staticmethod装饰的是静态方法名，告诉python解释器下面的方法是特殊的方法，不需要报错

                        3.6).调用静态方法

                                1.类名.静态方法名()

                                2.实例对象名.静态方法名()

                        3.7).使用场景：比如打印菜单等简单的操作

五、今日学习思维导图