三十九、python面向对象一

A、python面向对象

1.面向对象基础：面向对象三个特性：封装，继承，多态
C# java  只能用面向对象编程
Ruby,python 函数+面向对象

函数式编程：def 函数
def f1(a):
    return "f1"
def f2(b):
    return "f2"

f1("www")
f2("aaa")

面向对象式编程，类，def 方法
class Func:
    def f1(self,a):
        return "f1"
    def f2(self,b):
        return "f2"

obj=Func()
obj.f1("www")
obj. f2("aaa")
'''

'''
2.self:形式参数，代指执行方法中的对象，python内部传递
类+括号：自动执行类中的__init__方法，初始化
在__init__方法中执行具体的封装方法
__init__有个特殊的名字：构造方法

3.封装：
使用场景一：当同一类型的方法具有相同的参数时，直接封装到对象中即可
使用场景一：把类当做模板，创建多个对象（对象内封装的数据可以不一样）

class Func:

    def __init__(self,bk):
        '''
        该方法叫做构造方法
        :param bk:
        '''
        #普通字段
        self.b=bk

    def f1(self,a):
        print("f1",self.b)

    def f2(self,c):
        print("f2", self.b)

    def f3(self,d):
        print("f2", self)

    def __del__(self):
        '''
        解释器销毁对象时自动调用
        特殊的名字：析构方法
        :return:
        '''
        pass

#创建对象实例，并将数据封装到对象中
obj1=Func('www.baidu.com')
#封装
#obj1.b="www.baidu.com"
#执行方法，执行过程中可以根据self去obj中去取已经封装在里面的数据
obj1.f1("www")

obj2=Func("www.jd.com")
#obj2.b="www.jd.com"
obj2.f2("www")

'''
4.继承：父类（基类）子类（派生类）
　　1.派生类可以继承基类中所有的功能
　　2.派生类和基类同时存在，优先派生类
　　3.python类中可以同时继承多个类（java等不可以）
　　4.多继承  优先：自己，先左边后右边
　　5.多继承见图

class Anical:
    def __init__(self,name):
        pass

    def Eat(self):
        print(self.name+"吃0")

    def Cry(self):
        print(self.name+"叫0")
    def f1(self):
        print("0")

class Uncle:

    def __init__(self,name):
        self.name=name

    def du(self):
        print("赌")
    def f1(self):
        print("0.0")

class Pig(Anical,Uncle):

    def __init__(self,name):
        self.name=name
    def Cry1(self):
        print(self.name+"叫1")
    # def f1(self):
    #     print("1")
class Dog(Anical):

    def __init__(self,name):
        self.name=name
    def Cry2(self):
        print(self.name+"叫2")

obj1=Pig('小白')
obj1.du()
obj1.Cry1()
obj1.Cry()
obj1.Eat()
print(obj1.name)

obj1.f1()
obj2=Anical('小黑')
obj2.f1()

多继承例子：深度优先
class A:
    def f(self):
        self.f1()

class B(A):
    def f1(self):
        print("B")

class C:
    def f1(self):
        print("C")

class D(C,B):
    def f2(self):
        print("D")

d=D()
d.f()
---------------------------------------
C

多继承：广度优先

class Person:

    def f(self):
        print("Person")
class A(Person):
    def f1(self):
        print("A")

class B(Person):
    def f1(self):
        print("B")

class C(A):
    def f2(self):
        print("C")

class D(B):
    def f(self):
        print("D")
class E(C,D):
    def f2(self):
        print("E")

d=E()
d.f()
-----------------------------------
D

5、多态：每个参数都可以传多种参数
多种形态
pyhton本身支持多态
扩展：
重载：函数名相同，参数不同（python不支持）
重写：派生类中重新实现基类的方法

6、super执行父类中的构造方法

class Animal:
    def __init__(self):
        print("A的构造方法")
        self.ty="动物"

class Cat(Animal):
    def __init__(self):
        print("Cat的构造方法")
        self.n="猫"
        super(Cat,self).__init__()     #执行父类的构造方法
        #Animal.__init__(self)           #执行父类的构造方法

c=Cat()
print(c.__dict__)
----------------------------------------------------------------

　　Cat的构造方法
　　A的构造方法
　　{'n': '猫', 'ty': '动物'}