面向对象编程，主要通过定义类、并使用类方法，实现特定的程序功能。C#、Java是面向对象编程。

　　但面向对象编程不是哪里都适用，功能简单的编程更适合函数式编程。 Ruby、Python是面向对象编程+函数式编程。

　　一、面向对象编程的执行流程：

　　（一）创建类，并构造类字段和方法

　　（二）创建类对象，也叫创建类实例

　　（三）类对象调用类方法

　　二、面向对象编程最主要的三个特点：封装、继承和多态。

　　（一）封装：

　　封装：在内存中，把某个东西封装在对象里，执行类方法时调用。

　　python为每一个类方法自动添加参数self，self指代的是类对象自身，通过self可以调用封装在对象中的普通字段并修改。

　　应用场景一：当同类方法中，含有相同参数；应用场景二：把类当模板，可以创建多个内容不同但形式相同的对象。

　　1、构造（初始化）：

　　类创建对象时，直接执行类中的构造方法：__inti__（self，obj），并通过obj参数设置类的普通字段。

　　2、析构：

　　python解释器在类对象销毁时，自动调用析构方法：__del__（）。

# ---------------------------封装--------------------
# 创建类实例，为类封装内容

# # 方式一：不使用构造方法封装内容，非主流方式
# 创建类
class oldboy():
    def f1(self):
        print(self.name)
    def f2(self):
        print(self.name,self)
# 创建类实例
obj1 = oldboy()
obj1.name = 'lucy'
print(obj1)
obj1.f1()
obj1.f2()

# 方式二：使用构造方法__init__()封装内容，主流方式
# 创建类
class oldboy():
    def __init__(self,name):
        self.name = name
    def f1(self):
        print(self.name)
    def f2(self):
        print(self.name,self)
# 创建类实例
obj2 = oldboy('dongxuew')
print(obj2)
obj2.f1()
obj2.f2()

# ------------------实例----------------------------
class Person():
    def __init__(self,name,age,weight):
        self.name = name
        self.age = age
        self.weight = weight

    def eat(self):
        self.weight += 3

    def run(self):
        self.weight -= 2

    def __del__(self):
        pass

p1 = Person('lucy',5,48)
print(p1.weight)
p1.run()
print(p1.weight)
p1.eat()
print(p1.weight)
View Code

　　（二）继承：

　　继承：子类除了可以使用自身构造的方法外，还可以继承使用父类的方法。当子类和父类有相同方法时(重写），优先使用子类的方法。

　　子类又叫派生类，父类对应的又可以叫做基类。一个子类可以继承于多个基类，调用方法时的优先级是：子类——》父类（从左向右）。　

#-----------------------------------继承------------------------

# ----------------1、单继承：一个子类继承一个父类--------------

# 定义基类（父类）
class Animal():
    # 定义类时，若未指定基类，类名的（）可有可无。
    def __init__(self,name):
        self.Name = name
    def eat(self):
        print(self.Name + ' eat')
    def drink(self):
        print(self.Name + ' drink')
    def __del__(self):
        pass

# 定义派生类（子类）
class Dog(Animal):
    def __init__(self,name):
        self.Name = name
    def eat(self):
        print(self.Name + ' bone')
    def sound(self):
        print(self.Name + ' wa..wang..')
    def __del__(self):
        pass

# 派生类实例
d1 = Dog('bill')
d1.sound()  # 子类有、父类无，执行子类方法
d1.eat()    # 子类有、父类有，执行子类方法
d1.drink()  # 子类无，父类有，执行父类方法

# ---------------2、一个子类可以继承多个父类（python独有）----------------
# 父类优先级：从左向右
class father():
    def __init__(self,name):
        self.Name = name
    def eyes(self):
        print('father is double')
    def nose(self):
        print('father is high')
    def smoke(self):
        print('father likes smoking')  # father独有
    def __del__(self):
        pass


class mather():
    def __init__(self,name):
        self.Name = name
    def eyes(self):
        print('mather is simple')
    def nose(self):
        print('mather is low')
    def dress(self):
        print('mather likes dress')  # mather独有
    def __del__(self):
        pass

class son(father,mather):
    def __init__(self,name):
        self.Name = name
    def eyes(self):
        print(self.Name + ' is double&simple')
    def games(self):
        print(self.Name + ' likes games')  # son独有
    def __del__(self):
        pass

boy = son('tom')
boy.dress()
boy.smoke()
boy.games()
boy.nose()
boy.eyes()
View Code

　　查找、调用方法时，应注意多级继承的优先级：在含有共同基类的时候，最后找共同基类。

#--------------------多级继承时的优先级-----------------
class Letter():
    def f1(self):
        print('letter')

class A(Letter):
    def f(self):
        print('A')

class B(Letter):
    def f1(self):
        print('B')

class C(A):
    def f(self):
        print('C')

class D(B):
    def f1(self):
        print('B')

class E(C):
    def f(self):
        print('E')

class F(D):
    def f1(self):
        print('F')

class G(E,F):
    def f(self):
        print('G')

obj = G()
obj.f1()  
# 优先级：G-->E-->C-->A-->-->F-->D-->B-->Letter
View Code

　　（三）多态：

　　python 是弱类型语言，不需要预先指定类型，原生支持多态，不支持重载。

　　　　多态：字段和方法可以有多种形态，即：指向不同类。

　　　　重载：方法名相同，但是参数个数不同。

　　C#、Java等强类型语言，必须先指明类型，不能直接多态。通过一个父类下多个子类的形式，实现多态。

　　C#、Java中支持重载，即：函数名一样，但是参数个数不同。python不支持重载。

　　C#、Java中支持重写，即：在派生类中重新写了基类中的方法。