Python是一种面向对象的程序设计语言，截止目前的课程我们所有的程序都是使用的面向过程的思想解决问题的。这节课我们初步了解一下什么叫面向对象编程。学会使用类来解决问题。

一、什么叫面向对象编程

面向对象编程（Object Oriented Programming，简称OOP）是一种是以对象为中心，以类和继承为构造机制的软件开发系统方法。它对现实世界的理解和抽象，是计算机编程技术发展到一定程度的产物。它的特点主要有：抽象、封装、继承、多态。

我们举个例子来说一下面向对象思想的主要特征：

如果需要制造电视机，我知道电视机需要怎样制造。我可以把制造电视机的方法制作成类（抽象），工人们不需要知道具体的制造方法，只要会使用我制造的类就可以了（封装）。电视机还会有很多种类型，比如LCD屏电视机、LED屏电视机，但是它们都是电视机，很多制作方法都是一样的，只需要定义自己不同的地方（继承）。电视机要根据不同家庭、不同消费者的需求生产不同颜色、不同大小的，我们对一些细节做改变（多态）。

面向过程思想和面向对象思想的区别：

之前讲函数时，我们曾经举过把大象放进冰箱的例子。之前的思路就属于面向过程的思想。

1. 过程一：打开冰箱门
2. 过程二：把大象放进冰箱
3. 过程三：关上冰箱门

在面向对象的思想中，我们是这样思考的：

• 对象一：冰箱

1. 动作一：冰箱.开门()
2. 动作二：冰箱.关门()

• 对象二：大象

1. 动作一：大象.进入(冰箱)

有了面向对象的编程思想，玩过游戏的同学应该能想到游戏中的人物是怎么通过编程实现的了。首先定义人物的类，并设置了人物的属性；不同的职业继承人物的类，有自己独特的属性和技能（方法）；玩家创建一个角色就是实例化一个对象。

二、类的定义、创建和实例化

2.1 类的定义

类就像一个模板，按照类给的模板，可以创造出一个个的对象。类是抽象的，对象是具体的。比如说，一只狗是一个具体的对象，把狗的特征抽象出来，狗这个物种就对应类。

类是具有相同属性和方法的对象的集合，定了了集合中每个对象所共有的属性和方法。类有属性和方法，属性是静态的，方法是动态的。比如每只狗都有它的名字、出生日期、性别、毛发颜色，这就是属性；每只狗都会发出“汪”的叫声，会吃东西、睡觉等等，这就是方法。

2.2 类的创建

定义类需要用关键字class，我们看看如何创建一个类：

class Dog(object):
    name = 'dog'

以上程序定义了一个名为Dog的类，括号中的内容代表这个类继承于哪个类，如果没有其他继承的类，默认写object。Python中所有的类最终都会继承object类。以上的类中有一个属性name，并且属性的初始值为dog。

2.3 类的构造方法

每一个类中都有一个__init__()方法，这个方法叫类的构造方法。从类创建对象时，会自动调用构造方法来初始化对象的属性。__init__()方法的第一个参数永远是self，代表创建的实例本身，后面的参数代表各个属性。我们看具体的代码：

class Dog(object):
    def __init__(self, name, birthday, gender, color):
        # 将传入的参数赋值给属性对象
        self.name = name
        self.birthday = birthday
        self.gender = gender
        self.color = color

2.4 创建类的成员和访问的方法

无论是写入属性数据还是读取属性，都要使用“self.属性名”的格式访问。在类里面定义方法，除了第一个参数必须为self以外与定义普通函数的方法相同。

类定义好以后，我们可以创建实例。创建实例时，需要传入参数，初始化对象的属性数据。self参数位置不需要传入参数，调用类的方法时，同样不必传递self参数，其他参数位置对应传入数据。我们看具体的代码：

class Dog(object):
    def __init__(self, name, birthday, gender, color):
        # 将传入的参数赋值给属性对象
        self.name = name
        self.birthday = birthday
        self.gender = gender
        self.color = color

    def print_info(self):
        print(self.name, "出生日期：", self.birthday, "性别：", self.gender, "毛色：", self.color)


# 创建实例，赋值给变量dog1，得到一个对象dog1
dog1 = Dog('甜甜', '2020-1-1', '母', '白') # 实例化是调用构造方法
dog1.print_info() # 调用对象的方法
dog1.name = '蜜蜜' # 修改对象的属性值

2.5 __str__()方法

__str__()方法是object类中内置的方法，如果在类中定义了__str__()方法，直接使用print()函数打印对象时，就会打印出__str__()方法的返回值。我们看具体的用法：

class Dog(object):
    def __init__(self, name):
        self.name = name

    def __str__(self):
        return '狗的名字是：' + self.name


dog1 = Dog('甜甜')
print(dog1)
# 输出结果： 狗的名字是：甜甜

三、类的封装

通过前面的例子，我们可以看出外部代码可以直接更改对象的属性。这样其实是不合理的。这就需要对数据进行封装。数据的封装可以隐藏内部复杂的代码，但外部代码可以通过访问对象的方法来操作对象中属性数据。

如果要让对象内部的属性或者方法不能被外部访问或改变，可以将它改成私有。它的方法是在变量名称前加“__”（两个下划线）。在实际的程序中，我们通常将属性设置为私有，通过方法访问属性或改变属性的值。我们看具体的例子：

class Dog(object):
    def __init__(self, name):
        self.__name = name  # __name是私有变量

    def getname(self):
        return self.__name

    def setname(self, name):
        self.__name = name


dog1 = Dog('糖糖')  # 实例化对象
print(dog1.getname())  # 通过对象的方法访问私有变量
dog1.setname('甜甜')  # 通过对象的方法修改私有变量
print(dog1.getname())

如果直接调用私有变量会出现什么情况呢？我们看一下下面的代码：

class Dog(object):
    def __init__(self, name):
        self.__name = name # __name是私有变量


dog1 = Dog('糖糖') # 实例化对象
print(dog1.__name)

程序直接报错：

AtributeError: 'Dog' object has no attribute '__name' 

除了私有属性，对象中可能一些方法仅用于对象的内部使用，不需要被外部调用，也可以在方法方法名前面加“__”将该方法定义为私有方法。

四、类的继承

创建新的类可以从现有的类继承，被继承的类叫做基类（父类、超类），继承后得到的类叫做派生类（子类）。

我们还是以前面的狗的类为例，狗也有分类，比如哈士奇是狗、吉娃娃也是狗，哈士奇会拉雪橇、吉娃娃不会拉雪橇，我们在“狗”这个类中不可能定义“拉雪橇”这个动作。那我们在“哈士奇”这个类中定义“拉雪橇”的动作，“哈士奇”继承“狗”这个基类。

我们看一下具体的例子：

class Dog(object):
    def __init__(self, name, birthday, gender, color):
        self.name = name
        self.birthday = birthday
        self.gender = gender
        self.color = color
    
    def print_info(self):
        print(self.name, "出生日期：", self.birthday,
              "性别：", self.gender, "毛色：", self.color)

class Husky(Dog):
    def sled(self):
        print(self.name, "拉雪橇了！")


dog1 = Husky('明明', '2020-2-2', '公', '棕')
dog1.print_info()
dog1.sled()

从上面的代码我们可以发现，在派生类中，我们既拥有了从基类继承来的属性、方法，还可以在派生类中添加更多的属性和方法。

当派生类从基类继承来的方法不能满足需求时，需要重写基类同名的方法。在派生类中，新方法将覆盖原来基类的方法。这个过程叫做方法的重写。这就叫做多态。在重写的过程中，我们经常会用到super()，super()的含义是调用基类中的方法。我们看具体的例子：

class Dog(object):
    def __init__(self, name, birthday, gender, color):
        self.name = name
        self.birthday = birthday
        self.gender = gender
        self.color = color
    
    def print_info(self):
        print(self.name, "出生日期：", self.birthday,
              "性别：", self.gender, "毛色：", self.color)

class Husky(Dog):
    def __init__(self, name, birthday, gender, color, nation):
        super().__init__(name, birthday, gender, color) # 以上属性与基类相同，调用基类的构造方法
        self.nation = nation # 派生类特有的属性

    def print_info(self):
        super().print_info() # 调用基类的方法
        print('出生地：', self.nation) # 打印派生类特有的内容
    
    def sled(self):
        print(self.name, "拉雪橇了！")


dog1 = Husky('明明', '2020-2-2', '公', '棕', '俄罗斯')
dog1.print_info()
dog1.sled()

派生类除了继承一个基类，还可以继承多个基类，称为多重继承。多重继承在派生类后面的括号中书写多个基类的名称，基类的名称之间以逗号隔开。基类的顺序非常重要，如果各个基类中有同名的方法，且派生类中没有这个同名的方法，会按照从左到右的顺序在基类中查找。

多重继承我们可以举一个简单的例子：狼狗属于狗，但是具有部分狼的特征。“狼狗”这个类可以继承“狗”和“狼”两个类。

class Dog(object):
    pass

class Wolf(object):
    pass

class Wolf_dog(Dog, Wolf)
    pass

面向对象的编程在实际中应用非常广泛，但是在青少年编程考级、各类竞赛中使用较少，这里只是作为一个基础的概述，面向对象编程的内容远不止这些。如果有兴趣的同学可以自行研究查看相关资料学习。

五、课后思考题

1、选择题

下列属于面向对象的三个基本特性的是（）

A. 封装性、继承性、多样性

B. 继承性、多态性、封存性

C. 稳定性、继承性、多态性

D. 多态性、继承性、封装性

2、选择题

下列程序运行的结果是：（）

class parent(object):
    __name = '小明'
    
    def __init__(self, name):
        self.name = name
    
    def print_info(self):
        print(self.__name)

class child(parent):
    def __str__(self):
        return self.name


b = child('小虾')
print(b)
a = parent('小鱼')
a.print_info()

A. 小明 小虾

B. 小鱼 小虾

C. 小虾 小鱼

D. 小虾 小明

3、编程题

定义一个车辆类（Vehicle），有品牌（brand）、车重（weight）、高度（height）三个属性。定义一个小轿车类（Car），继承车辆类。小轿车类中增加荷载人数（nuclear）属性。在小轿车类中定义一个方法（print_info）打印出小轿车的所有属性。

实例化一辆小轿车，品牌：Ford，车重：1250，高度1600，核载人数5，并打印出这辆小轿车的属性。

六、上节课思考题答案

1、D

2、D

3、A