Python面向对象三大特征之封装

拼搏现实的明天。 2022-03-26 03:14 329阅读 0赞

文：jacky（朱元禄）

--------------------

> 要搞懂面向对象，是比较容易的，我们只要掌握面向对象的三大特征，就可以了，真的很简单

**面向对象编程** \- - Object Oriented Programming 简写OOP

> 面向对象三大特征：
> 
> 1.  封装
> 2.  继承
> 3.  多态

> 本文，我们先说**封装**，**封装**就是根据职责将**属性**和**方法**封装到一个抽象的**类**中；

# 01 面向对象基本概念 #

*  我们之前学习的编程方式就是**面向过程**的
 *  **面向过程**和**面向对象**，是两种不同的**编程方式**
 *  对比 **面向过程** 的特点，可以更好地了解什么是 **面向对象**

## 1.1 过程和函数（基础铺垫） ##

*  **过程**是早期的一个编程概念
 *  **过程**类似于函数，只能执行，但是没有返回值
 *  **函数**不仅能执行，还可以返回结果（return）

## 1.2 面向过程 和 面向对象 基本概念 ##

**1）面向过程——怎么做？**

1.  把完成某一个需求的所有步骤从头到尾逐步实现
2.  根据开发需求，将某些功能独立的代码封装成一个又一个函数
3.  最后完成的代码，就是顺序地调用不同的函数

面向过程编程**的特点**

1.  注重 **步骤与过程**，不注重职责分工
2.  如果需求复杂，代码会变得很复杂
3.  开发复杂项目，没有固定的套路，开发难度很大！

**2）面向对象——谁来做？**

*  相比较函数，面向对象是更大的封装，根据职责在一个对象中封装多个方法

1.  在完成某一个需求前，首先确定**职责**——**要做的事情（方法）**
2.  根据职责确定不同的**对象**，在**对象**内部封装不同的**方法**（多个）
3.  最后完成的代码，就是顺序地让 **不同的对象** 调用 **不同的方法**

**特点**

1.  注重 **对象和职责**，不同的对象承担不同的责任
2.  更加适合应对复杂的需求变化，**是专门应对复杂项目开发，提供的固定套路**
3.  **需要在面向过程基础上，再学习一些面向对象的语法**

--------------------

# 02 类和对象 #

## 2.1 类和对象的概念 ##

**类** 和 **对象** 是面向 **对象编程** 的**两个核心概念**

**1）类**

*  类 是对一群具有 **相同特征** 或者 **行为** 的事物的一个统称，是抽象的，**不能直接使用**
    
     *  **特征** 被称为 **属性**
     *  **行为** 被称为 **方法**
 *  **类** 就相当于制造游轮时的**图纸**，是一个 **模板**，是 **负责创建对象的**

![@数据分析-jacky][-jacky]

> 那这张图纸能在大海上航行吗 ? 所以，在面向对象开发中，类j是抽象的，不能直接使用，类的职责很单一，就是负责创建对象的；

**2）对象**

*  对象 是 **由类创建出来的一个具体存在**，可以直接使用
 *  由 哪一个类 创建出来的 对象，就拥有在 哪一个类 中定义的：
    
     *  属性
     *  方法
 *  **对象** 就相当于用 **图纸** **制造** 的游轮

> 在程序开发中，应该 **先有类**，**再有对象**  
> ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2phY2t5X3podXl1YW5sdQ_size_16_color_FFFFFF_t_70]

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2phY2t5X3podXl1YW5sdQ_size_16_color_FFFFFF_t_70 1]

## 2.2 类和对象的关系 ##

*  **类是模板**，**对象**是根据**类**这个模板创建出来的，应该**先有类，再有对象**
 *  **类**只有一个，而**对象**可以有很多个（有了一张图纸，就会有很多很多的邮轮）
    
     *  **不同的对象**之间**属性**可能会各有不相同（我们看上面的两张图，虽然都是能在海里航行的邮轮，但是邮轮的颜色可以各不相同）
 *  **类**中定义了什么**属性和方法**，**对象**中就有什么属性和方法，**不可能多，也不可能少**

--------------------

# 03 类的设计 #

在使用面向对象开发前，应该首先分析需求，确定一下，程序中需要包含哪些类

在程序开发中，要设计一个类，通常需要满足一下三个要素：

1.  **类名** 这类事物的名字，**满足大驼峰命名法**
2.  **属性** 这类事物具有什么样的特征
3.  **方法** 这类事物具有什么样的行为

**大驼峰命名法**

`CapsWords`

1.  每一个单词的首字母大写
2.  单词与单词之间没有下划线

## 3.1 类名的确定 ##

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

## 3.2 属性和方法的确定 ##

*  对 **对象的特征描述**，通常可以定义成**属性**
 *  **对象具有的行为**（动词），通常可以定义成**方法**

## 例如 ##

**需求**

*  小张今年25岁，身高1.76，每天早上跑完步，会去吃东西
 *  小李今年30岁，身高1.72，不跑步，喜欢吃东西

<table> 
 <thead> 
  <tr> 
   <th>Person</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>name age height</td> 
  </tr> 
  <tr> 
   <td>run() eat()</td> 
  </tr> 
 </tbody> 
</table>

--------------------

# 04 定义简单的类（只包含方法） #

**面向对象是更大的封装，在一个类中封装多个方法，这样通过这个类创建处理的对象，就可以直接调用这些方法了！**

## 4.1 定义只包含方法的类 ##

*  在Python中要定义一个只包含方法的类，语法格式如下：

class 类名：
    	def 方法1(self,参数列表):
    		pass
    	def 方法2(self,参数列表):
    		pass

*  **方法**的定义格式和之前学习过的**函数**几乎一样
 *  区别在于第一参数必须是self，大家暂时先记住，稍后介绍self

> 注意：类名的命名规则要符合大驼峰命名法

## 4.2 创建对象 ##

*  当一个类定义完成之后，要使用这个类来创建对象，语法格式如下：

对象变量 = 类名()

--------------------

# 05 初始：第一面向对象程序 #

**需求**

*  **小猫** 爱 **吃** 鱼，**小猫** 要 **喝** 水

**分析**

1.  定义一个猫类 Cat
2.  定义两个方法 eat 和 drink
3.  按照需求-- 不需要定义属性

<table> 
 <thead> 
  <tr> 
   <th>Cat</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>eat(self) drink(self)</td> 
  </tr> 
 </tbody> 
</table>

class Cat:
    	
    	def eat(self):
    		print("小猫爱吃鱼")
    	
    	def drink(self):
    		print("小猫要喝水")
    
    # 创建猫对象
    tom = Cat()
    
    tom.eat()
    tom.drink()
    
    >>>

--------------------

# 06. 在类的外部给对象增加属性 #

*  在 Python 中，要给对象设置属性非常容易，**但是不推荐使用。**
    
     *  因为：对象属性的封装应该封装在类的内部
 *  只需在类的外部的代码中直接通过，设置一个属性即可

class Cat:
    	
    	def eat(self):
    		print("小猫爱吃鱼")
    	
    	def drink(self):
    		print("小猫要喝水")
    
    # 创建猫对象
    tom = Cat()
    
    # 使用 .属性名
    tom.name = "Tom"

*  name 明明在 Cat 类中并没有该属性,但是为什么可以给name赋值呢?可以把该对象看成是json串,由于Python是解释型语言,所以并不会在内存中创建该对象,只是以字符串形式来保存该对象,所以属性可以随时删减也就不奇怪了!

--------------------

# 07. 使用 self 在方法内部输出每一只猫的名字 #

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

*  在类封装的方法内部，self 就表示 当前调用方法的对象自己
 *  调用方法时，程序员不需要传递 self 参数
 *  在方法内部
    
     *  可以通过 self ，访问对象的属性
     *  也可以通过 self ，调用其他的对象方法

class Cat:
    	
    	def eat(self):
    		print("%s 爱吃鱼" % self.name)
    	
    	def drink(self):
    		print("小猫要喝水")
    
    # 创建猫对象
    tom = Cat()
    tom.name = "Tom"
    tom.eat()
    tom.drink()
    
    >>> Tom 爱吃鱼
    >>> 小猫要喝水

--------------------

# 08. 之前代码存在的问题 —— 在类的外部给对象增加属性 #

class Cat:
    	
    	def eat(self):
    		print("%s 爱吃鱼" % self.name)
    	
    	def drink(self):
    		print("小猫要喝水")
    
    # 创建猫对象
    tom = Cat()
    tom.eat()
    tom.drink()
    
    # 如果把 .name 放在后面
    tom.name = "Tom"
    
    >>> AttributeError:'Cat' object has no attribute 'name

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

--------------------

# 09. Python 对象的初始化方法 #

*  当使用 类名（） 创建对象时，Python解释器会自动执行以下操作：
    
    1.  为对象在内存中 分配空间 – 创建对象
    2.  为对象的属性 设置初始值 – 初始化方法（init）
 *  这个 初始化方法 就是 \_\_ init\_\_ ， \_\_ init\_\_ 是对象的内置方法
    
     *  \_\_ init\_\_ 方法是专门用来定义一个类具有哪些属性的方法！

class Cat:
    	def __init__(self):
    		print("这是一个初始化方法")
    
    # 使用 类名() 创建对象的时候，会自动调用初始化方法 __init__
    tom = Cat()
    >>> 这是一个初始化方法

--------------------

# 10. 在初始化方法内部定义属性 #

*  在 \_\_ init\_\_ 方法内部使用 self.属性名 = 属性的初始值 就可以定义属性
 *  定义属性之后，在使用 Cat 类创建对象，都会拥有该属性

class Cat:
    	def __init__(self):
    		print("这是一个初始化方法")
       
       # 定义用 Cat 类创建的猫对象有一个 name 的属性
       self.name = "Tom"
       
       def eat(self):
       		print("%s 爱吃鱼" % self.name)
       	
    # 使用 类名() 创建对象的时候，会自动调用初始化方法 __init__
    tom = Cat()
    tom.eat()
    >>> Tom 爱吃鱼

--------------------

# 11 改造初始化方法 —— 初始化的同时设置初始值 #

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

class Cat:
    	def __init__(self, new_name):
    		print("这是一个初始化方法")
       		
       		self.name = new_name
      
       def eat(self):
       		print("%s 爱吃鱼" % self.name)
       	
    # 使用 类名() 创建对象的时候，会自动调用初始化方法 __init__
    tom = Cat("Tom")
    print(tom.name)
    
    lazy_cat = Cat("大懒猫")
    lazy_cat.eat()
    >>> Tom 
    >>> 大懒猫爱吃鱼

[-jacky]: /images/20220326/e90912c32ca24504817560b3f6e2c93f.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2phY2t5X3podXl1YW5sdQ_size_16_color_FFFFFF_t_70]: /images/20220326/927a3a4bd2fc4f238bbc368149713376.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2phY2t5X3podXl1YW5sdQ_size_16_color_FFFFFF_t_70 1]: /images/20220326/f4d02a1d06d341c5b14d44cdb289bfe9.png