面向对象
顾名思义就是把现实中的事务都抽象成为程序设计中的“对象”，其基本思想是万物皆对象
几个概念
- 类(Class): 用来描述具有相同的属性和方法的对象的集合。它定义了该集合中每个对象所共有的属性和方法。对象是类的实例。
- 方法重写：如果从父类继承的方法不能满足子类的需求，可以对其进行改写，这个过程叫方法的覆盖（override），也称为方法的重写。
- 继承：即一个派生类（derived class）继承基类（base class）的字段和方法。继承也允许把一个派生类的对象作为一个基类对象对待。例如，有这样一个设计：一个Dog类型的对象派生自Animal类，这是模拟"是一个（is-a）"关系（例图，Dog是一个Animal）。
- 多态：通俗来说，就是多种形态，具体点就是去完成某个行为，当不同的对象去完成时会产生出不同的状态。
Python类的定义
1、python中定义类使用class关键字，class后面紧接类名，类名通常是大写开头的单词(无类继承时类名后可以加括号也可以不加括号)
2、python中类的定义语法如下：
class ClassName:
语句1
...
语句n
3、注意：
a、类定义与函数定义(def语句)一样：只有在被执行才会起作用
b、类是属性和方法的组合，所以语句1可能是内部变量(数据、属性)的定义和赋值语句，也可能是内部方法(函数)的定义语句
（1）一个对象的特征称为"属性，一个对象的行为称为"方法"
（2）属性在代码层面上来看就是变量，方法实际就是函数，通过调用这些函数来完成某些工作
继承
定义一个 class 的时候，可以从某个现有的 class 继承，新的 class 称为子类（Subclass），而被继承的 class 称为基类、父类或超类（Base class、Super class）
python中继承的特点：
（1）在继承中，基类的构造方法（__init__()方法）不会自动调用，需要在子类的构造方法中专门调用。
（2）在调用基类的方法时需要加上基类的类名前缀，并带上 self 参数变量。区别于在类中调用普通函数时不需要带 self 参数。
（3）首先查找对应类型的方法，如果在子类中找不到对应方法才到基类中逐个查找。
注意：
- 子类获得了父类全部非私有的功能。
- 子类不能继承父类中的私有方法，也不能被调用父类的私有方法。
- 对于父类中扩展的非私有方法，子类可以拿来即用。
#类定义
class people:
#定义基本属性
name = ''
age = 0
#定义私有属性,私有属性在类外部无法直接进行访问
__weight = 0
#定义构造方法
def __init__(self,n,a,w):
self.name = n
self.age = a
self.__weight = w
def speak(self):
print("%s 说: 我 %d 岁。" %(self.name,self.age))
#单继承示例
class student(people):
grade = ''
def __init__(self,n,a,w,g):
#调用父类的构函
people.__init__(self,n,a,w)
self.grade = g
#覆写父类的方法
def speak(self):
print("%s 说: 我 %d 岁了，我在读 %d 年级"%(self.name,self.age,self.grade))
s = student('ken',10,60,3)
s.speak()多态
让具有不同功能的函数可以使用相同的函数名，这样就可以用一个函数名调用不同内容(功能)的函数。
多态特点：
1、只关心对象的实例方法是否同名，不关心对象所属的类型；
2、对象所属的类之间，继承关系可有可无；
3、多态的好处可以增加代码的外部调用灵活度，让代码更加通用，兼容性比较强；
4、多态是调用方法的技巧，不会影响到类的内部设计。
应用场景之对象所属的类之间有继承关系
class gradapa(object):
def __init__(self,money):
self.money = money
def p(self):
print("this is gradapa")
class father(gradapa):
def __init__(self,money,job):
super().__init__(money)
self.job = job
def p(self):
print("this is father,我重写了父类的方法")
class mother(gradapa):
def __init__(self, money, job):
super().__init__(money)
self.job = job
def p(self):
print("this is mother,我重写了父类的方法")
return 100
#定义一个函数，函数调用类中的p()方法
def fc(obj):
obj.p()
gradapa1 = gradapa(3000)
father1 = father(2000,"工人")
mother1 = mother(1000,"老师")
fc(gradapa1) #这里的多态性体现是向同一个函数，传递不同参数后，可以实现不同功能.
fc(father1)
print(fc(mother1))
===运行结果：===================================================================================
this is gradapa
this is father,我重写了父类的方法
this is mother,我重写了父类的方法
100
作业
作业1：使用python，选择小汽车和客车作为对象，使用类实现他们的属性和方法（汽车的重量属性，驾驶的方法），并打印属性
class Vehicle(object): # 定义一个交通工具类
weight = 5 # 定义一个类属性重量
def __init__(self, n, w): # 定义构造方法
self.name = n
self.speed = w
def run(self): # 调用类属性和实例属性并打印输出
print("%s重量为%d吨,行驶速度为：%dkm/h " % (self.name, Vehicle.weight, self.speed))
v1 = Vehicle('小汽车', 30) # 小汽车实例对象
v1.run()
v2 = Vehicle('客车', 80) # 客车实例对象
v2.run()
作业2：对上述问题改写：继承客车的属性和方法，改造为公交车，输入的名字为“东风路28路公交车”，并打印（属性和方法）
class Ke: # 定义客车类
weight = 5 # 定义重量属性
def __init__(self, a): # 定义构造方法
self.run = a
def drive(self): # 引用类属性重量及实例属性
print("客车车重为：%d 吨，车速为 %d km/h。" % (Ke.weight, self.run))
class Bus(Ke): # 公共汽车继承客车属性和方法
def __init__(self, a, n):
Ke.__init__(self, a) # 调用父类的构造函数
self.name = n
def drive(self): # 覆写父类的方法
print("客车车重为 %d 吨, 车速为 %d km/h, 该客车名称为：%s " % (Ke.weight, self.run, self.name))
s = Bus(10, "东风路28路公交车") # 实例化对象
s.drive()作业3：使用多态实现28路，906路，B32路公交车的驾驶方法并打印
class Bus(object): # 定义父类Bus
def bus(self, speed):
pass
class First(Bus): # 定义子对象1并继承父类
def bus(self, speed):
print("28路驾驶速度为：{} km/h".format(speed))
class Second(Bus): # 定义子对象2并继承父类
def bus(self, speed):
print("906路驾驶速度为:{} km/h".format(speed))
class Third(Bus): # 定义子对象3并继承父类
def bus(self, speed):
print("B32路驾驶速度为:{} km/h".format(speed))
class Person(object): # 定义函数，类作为参数
def run(self, bus, speed):
bus.bus(speed)
a = First() # 实例化对象
b = Second()
c = Third()
person = Person()
# 使用多态调用 run() 方法
person.run(a, 80) # 28路
person.run(b, 75) # 96路
person.run(c, 60) # B32路