python-面向对象

面向对象

在java，c#语言中只能使用面向对象式编程，python中当某一些函数具有相同参数时，可以使用面向对象式编程，将参数一次性封装到对象，以后去对象中取就可以

class f1:
    def __init__(self,a1,b1,c1):
        self.a1 = a1
        self.a2 = b1
        self.a3 = c1

    def select(self,sql):
        print(self.a1,self.a2,self.a3,sql)
    def add(self,sql):
        print(sql)
#实例化的时候自动执行类的__init__构造方法
obj = f1('1','2','3')
obj.host = 'abc.com'
obj.username = 'alex'
obj.pwd = '123'
#当某些函数拥有相同参数时，使用面向对象
obj.select('select * from A')
obj.add('create table from A')
>>>1 2 3 select * from A
>>>create table from A

class c1:
    def __init__(self,name,obj):
        self.name = name
        self.obj = obj

class c2:
    def __init__(self,name,age):
        self.name = name
        self.age = age
    def show(self):
        print(self.name)

c2_obj = c2('bb',18)
#将c2_obj当作参数传入obj，则c1_obj.obj=c2_obj  c2_obj.show = c1_obj.obj.show()
c1_obj = c1('aa',c2_obj)
c1_obj.obj.show()
>>>bb

继承

class F1:#父类，基类
    def show(self):
        print('show')
    def foo(self):
        print(self.name)

class F2(F1):#子类，派生类
    def __init__(self,name):
        self.name = name
    def bar(self):
        print('bar')
    def show(self):
        print('F2.show')
#继承相当于将F1的方法放到F2中，
obj = F2('alex')
obj.foo()
#两个类中有相同方法时，自身的方法优先级高
obj.show()
>>>alex
>>>F2.show

class f1():
    def c1(self):
        print('c1')
class f2(f1):
    def c2(self):
        print('c2')
class f3(f2):
    def c3(self):
        print('c3')

class f5():
    def c2(self):
        print('c5')
class f4(f3,f5):
    def c4(self):
        print('c4')
#当子类有两个类时，优先从左边分支寻找，左边分支找到头之后找右边
obj =f4()
obj.c2()
>>>c2

 多态（Polymorphism）按字面的意思就是“多种状态”。在面向对象语言中，接口的多种不同的实现方式即为多态。引用Charlie Calverts对多态的描述——多态性是允许你将父对象设置成为一个或更多的他的子对象相等的技术，赋值之后，父对象就可以根据当前赋值给它的子对象的特性以不同的方式运作（摘自“Delphi4 编程技术内幕”）。简单的说，就是一句话：允许将子类类型的指针赋值给父类类型的指针。多态性在Object Pascal和C++中都是通过虚函数实现的。

在python中，多态表现为参数的多类型

#python中参数可以为整数型，字符串型，列表型
def func(arg):
    print(arg)

func(1)
func("alex")
func([11,22,33])

#C#/Java,参数需声明类型
def func(int arg):
    print(arg)

func(123)
func("alex")#报错

#java的多态需要用派生类实现
class A：
    pass

class B(A):
    pass

class C(A):
    pass

#arg 参数：必须是A类型或A的子类类型
def func(A arg):
    print(arg)

obj =B()
obj =C()
obj = A()
func(obj)