python 面向对象

一、面向对象的简单介绍

1.面向对象 oop:object oriented programming  是由类和对象所组成

如：python是面向对象 而c语言是面向过程

  面向过程和面向对象，是两种不同的编程方式

过程和函数(都是对一段功能的代码进行封装)
过程：是早期的一个编程概念
    过程类似于函数，只能执行，但是没有返回值
函数：不仅能执行，还可以返回结果(return)

2.面向过程和面向对象的基本概念

面向过程：---侧重于怎么做？
1）.把完成某一个需求的 所有步骤 从头到尾 逐步实现
2）.根据开发要求，将某些功能独立的代码封装成一个又一个函数
3）.最后完成的代码，就是顺序的调用不同的函数
特点：
1）.注重步骤与过程，不注重职责分工
2）.如果需求复杂，代码会变得很复杂
3）.开发复杂项目，没有固定的套路，开发难度很大

面向对象：--谁来做?
相比较函数，面向对象是更大的封装，根据职责在一个对象中封装多个方法
1）.在完成某一个需求前，首先确定职责--要做的事(方法)
2）.根据职责确定不同的对象，在对象内部封装不同的方法(多个)
3）.最后完成代码，就是顺序的让不同的对象调用不同的方法
特点：
1）.注重对象和职责，不同的对象承担不同的职责
2）.更加适合对复杂的需求变化，是专门应对复杂项目的开发，提供的固定套路
3）.需要在面向过程的基础上，再学习一些面向对象的语法

3.面向对象的两个核心概念和目标
1）类和对象 是核心概念
2）目标
类和对象的概念
类和对象的关系
类的设计

4.类和对象的概念
类和对象是面向对象编程的两个核心概念
1）类：是对一群具有相同特征或行为的事物的一个统称，是抽象的，不能直接使用。就相当于制造飞机时的图纸，是一个模板，是负责创建对象的

• 类包含  特征:被称为属性 （这个类创建出来的对象有什么样的特征）

                    行为:被称为方法（这个类创建出来的对象有什么样的行为）

                   类名：满足这类事物的名字(大驼峰命名法)
                                  大驼峰命名法：
                        1.每个单词的首字母大写
                        2.单词与单词之间没有下划线

• 类名的确定：

    名词提炼法:分析整个业务流程，出现的名词，通常就是找到的类名

2）对象：是由类创建出来的一个具体的存在，可以直接使用。由哪一个类创建出来的对象，就拥有哪一个类种法定义的属性和方法

5.类和对象的关系
类是模板，对象是根据类这个模板创建出来的，应该先有类，再有对象
类只需要有一个 而对象可以有很多个（一张图纸可以造出很多架飞机）
不同对象之前属性可以不相同(比如飞机的颜色 等等。。)
类中定义了什么属性和方法，使用这个类创建出来的对象中就有什么属性和方法，不可能多也不可能少

在程序开发中，应该先有类，再有对象

6.在面向对象开发中，引用的概念是同样适用的
如：tom = Cat():在等号右侧我们使用cat类创建了一个猫对象，在等号左侧使用tom这个变量接收了这个猫对象
python解释器在执行到此句代码的时候，在内存中为这个猫对象分配了一个内存空间，然后再让tom这个变量记录了猫对象在内存中的地址
在python中使用类创建对象之后，tom变量中仍然记录的是对象在内存中的地址
也就是tom变量引用了新建的猫对象
使用print输出对象变量，默认情况下，是能够输出这个变量引用的对象是由哪一个类创建的象，以及在内存中的地址(十六进制表示)
提示：在计算机中，通常使用十六进制表示内存地址

7.面向对象的三大特征：封装、继承、多态

二、面向对象的使用

1.基本语法

定义一个只包含方法的类
class 类名：
    def 方法1(self,参数列表):
        pass
    def 方法2(self,参数列表):
        pass
方法的定义格式和函数几乎一样
区别在于第一个参数必须是self

创建对象
当一个类定义完成之后，要使用这个类来创建对象
对象变量 = 类名()

2.引用

判断两个对象是否为同一对象，可从对象的内存地址判定，

3.参数self 的介绍

哪一个对象调用的方法，self就是哪一个对象的引用

self:
在调用方法的时候，程序员不需要传递self参数(但是定义的时候，第一个参数必须是self)
在方法内部：可以通过self.访问对象的属性

注：在日常开发中，不推荐在类的外部给对象增加属性
如果在运行的时候，没有找到属性，程序就报错
对象应该包含有哪些属性，应该封装在类的内部

4.初始化方法：
类名() 就可以创建一个对象
当使用类名()创建对象的时候，python解释器会自动执行以下操作
    1.为对象在内存中分配空间 ---创建对象
    2.调用初始化方法

改造初始化方法--初始化的同时设置初始值：
在开发中，如果希望在创建对象的同时，就设置对象的属性，可以对__init__方法进行改造
1.把希望设置的属性值，定义成__init__方法的参数
2.在方法内部使用self.属性名 = 形参 接收外部传递的参数
3.在创建对象时，使用类名(属性1，属性2..)调用

5.内置方法和属性

1）__del__方法：对象被从内存中销毁前，会被自动调用

 # tom 是一个全局变量(s所以当我们的代码全部执行完之后，系统才会将tom 这个对象进行回收)

# del 关键字 可以删除一个对象 del关键字自己调用__del__方法

__del__方法：
在python中
    当使用类名()创建对象时，为对象分配完空间后，自动调用__init__方法
    当一个对象被从内存中销毁前(把这个对象从内存中删除掉)，会自动调用__del__方法
应用场景
__init__改造初始化方法，可以让创建对象更加灵活
__del__如果希望在对象被销毁前，再做一些事情，可以考虑一下__del__方法

生命周期(出生到死亡)
一个对象从调用类名()创建，生命周期开始
一个对象的__del__方法一但被调用，生命周期结束
在对象的生命周期内，可以访问对象属性，或者让对象调用方法

2）__str__方法：如果在开发中，希望使用print输出对象变量时，能够自定义打印的内容

_str__方法：
在python中，使用python输出对象变量，默认情况下，会输出这个变量引用的对象是由哪>一个类创建的对象，
以及在内存中的地址(十六进制表示)
如果在开发中，希望使用print输出对象变量时，能够打印自定义的内容，就可以利用__str__这个内置方法了

6.私有属性和私有方法
应用场景
    在实际开发中，对象的某些属性或方法可能只希望在对象的内部使用，而不希望在外部被访问到

私有属性 就是 对象 不希望公开的 属性

私有方法 就是 对象 不希望公开的 方法

二、封装

封装：根据职责将属性和方法封装到一个抽象的类中
1.封装是面向对象编程的一大特点
2.面向对象编程的第一步，将属性和方法封装到一个抽象的类中(为什么类是抽象的？)
3.外界使用类创建对象，然后让对象调用方法
4.对象方法的细节都被封装在类的内部

案例一

小明和小美爱跑步
1.小明体重75.0公斤
  小美体重45.0公斤
2.小明每次跑步会减肥0.5公斤
3.小明每次吃东西体重会增加1公斤

案例二

摆放家具
需求：
1.房子有户型，总面积和家具名称列表
    新房子没有任何的家具
2.家具有名字和占地面积，其中
    床：占4平米
    衣柜：占2平面
    餐桌：占1.5平米
3.将以上三件家具添加到房子中
4.打印房子时，要求输出:户型，总面积，剩余面积，家具名称列表

剩余面积：
1.在创建房子对象的时候，定义一个剩余面积的属性，初始值和总面积相等
2.在调用添加家具的方法时，让 剩余面积 -= 家具的面积

# 添加家具：
# 1.判断家具的面积是否超过剩余面积，如果超过了房子的大小，提示不能添加
# 2.将 家具的名称 追加到 家具名称列表中
# 3.用 房子的剩余面积 - 家具面积

小结：
    1.主程序只负责创建房子对象和家具对象
    2.让 房子 对象调用add_item 方法 将家具添加到房子中
    3.面积计算，剩余面积，家具列表 等处理都被封装到房子类的内部

案例3

演练重点：一个对象的属性可以是另外一个类创建的对象
示例:士兵射击
需求：
1.士兵瑞恩有一把AK47
2.士兵可以开火(士兵开火扣动的是扳机)
3.枪 能够 发射子弹(把子弹发射出去)
4.枪 能够 装填子弹 --增加子弹的数量

三、继承

继承：实现代码的重用，相同的代码不需要重复的写

子类拥有父类的所有属性和方法(子类只需要封装自己特有的方法)

1.单继承

子类拥有父类的所有属性和方法(子类只需要封装自己特有的方法)

语法：class 类名(父类):
                      def 子类特有的方法

1）继承的传递性(在上面的基础上操作）
    1.C 类从B类继承 ，B类又从A类继承
    2.那么C类就具有B类和A类的所有属性和方法

2）方法的重写

当保留了父类的方法后，在运行时，先调用子类中重写的方法后调用父类原始的方法

在保留父类的初始化方法的同时扩展子类所需的方法

2.多继承
    子类拥有一个父类叫作单继承
    子类可以拥有多个父类，并且具有所有父类的属性和方法

注：

3.继承的私有属性和私有方法

注：# 在子类的对象方法中，不能访问父类的私有属性
        # 在子类的对象方法中，不能调用父类的私有方法

      # 在外界不能直接访问对象的私有属性/调用私有方法

如何访问父类的私有属性和方法

1.在父类创建一个公有方法,用公有方法去访问私有属性,调用私有方法

2.在子类调用父类的公有方法,即可访问

 

4.新式类和旧式(经典)类：
object是Python为所有对象提供的基类，提供有一些内置的属性和方法，可以使用dir函数查看
新式类：以object为基类的类，推荐使用
经典类：不以object为基类的类，不推荐使用
在python3.X中定义的类时，如果没有指定父类，会默认使用object作为基类--python3.x中定义的类都是新式类
在python2.x中定义类时，如果没有指定父类，则不会以object作为基类

新式类和旧式类在多继承时---会影响到方法的搜索顺序

为保证编写的代码能够同时在python2.x和python3.x运行
今后在定义类时，如果没有父类，建议统一继承自object

Python    早期,它对于class的定义在很多方面都是严重有问题的。当他们承认这一点的时候已经太迟了,
所以逼不得已,他们需要支持这种有问题的class 。
为了解决已有的问题,他们需要引入一种“新类”,这样的话“旧类”还能继续使用,而你也有一个新的正确的类可以使用了。
这就用到了“类即是对象”的概念。他们决定用小写的“object”这个词作为一个类,让你在创建新类时从它继承下来。

四、多态

1. 概念

多态(以封装和继承为前提)

多态：不同的子类对象调用相同的方法，产生不同的执行结果
        1.多态可以增加代码的灵活度
        2.以继承和重写父类的方法为前提
        3.调用方法，不会影响到类的内部设计

如：

                       人类
                    work(self)

  程序员                                  设计师
work(self)                            work(self)

2.多态的使用

3.类属性

1）在python中一切皆对象，类也是一个特殊的对象 --类对象

类对象可以拥有自己的属性和方法，称为：

类属性： 类属性就是给类对象定义的属性

               使用赋值语句在class关键字下方可以定义类属性

               通常用来记录与这个类相关的特征，不会用于记录具体对象的特征

类方法：类方法就是针对类对象定义的方法
              在类方法内部就可以直接访问类属性或调用类方法

2）调用

通过 类名.name 的方式可以直接访问类的属性或者调用类的方法(name代表定义的类属性）

类属性   创建需求：
定义一个工具类
每件工具都有自己的name
知道使用这个类，创建了多少个工具对象

类方法的使用:@classmethod

4.类结构

  术语--实例
1.使用面向对象开发，第一步是设计类
2.使用 类名() 创建对象，创建对象的动作有两步
    1.在内存中为对象分配空间
    2.调用初始化方法__init___ 为对象初始化
3.对象创建后，内存中就有了一个对象的实实在在的存在--实例

因此：
1.创建出来的对象叫做类的实例
2.创建对象的动作叫做实例化
3.对象的属性叫做实例属性
4.对象调用的方法叫做实例方法

在程序执行时：
1.对象各自拥有自己的实例属性
2.调用对象的方法，可以通过self
    访问自己的属性
    调用自己的方法
结论:
1.每一个对象都有自己独立的内存空间，保存各自不同的属性
2.多个对象的方法，在内存中只有一份，在调用方法时，需要把对象的引用传递到方法内部

5.静态方法

在开发的时候，如果需要在类中封装一个方法，这个方法
    既不需要访问实例属性或者调用实例方法
    也不需要访问那类属性或者调用类方法
    这个时候可以把这个方法封装成一个静态方法

使用：@staticmethod

6.相关练习

1.设计一个Game类
2.属性
    定义一个类属性top_score记录游戏的历史最高分(与这个类有关，每次游戏与历史最高分没关系)
    定义一个实例属性player_name记录当前游戏玩家的玩家姓名
3.方法：
    show_help显示游戏帮助信息(静态方法：既不需要访问类属性，也不需要访问实例属性)
    show_top_score显示历史最高分(类方法)
    start_game开始当前玩家的游戏(实例方法)