Python 之面向對象

一、面向對象

1、定義類

class Car(object):
    #公共屬性
    name = None
    #私有屬性
    __wheel = 0

    #構造方法，執行個體化類執行
    def __init__(self, *args) -> None:
        print(args)
        self.name, self.__wheel = args

    def test(self):
        print('test...', self.name, self.__wheel)
    
    #當列印對象時，輸出傳回的内容
    def __str__(self) -> str:
        return '列印對象...'
    
    #對象被删除調用
    def __del__(self):
        print('對象被删除了...')
        
car = Car('奔馳', 4)
car.test()
print(car)

del      

補充：類屬性 _name：相當于protected，__name：相當于private

 2、繼承

1、單繼承

class A(object):
    def printA(self):
        print('printA...')
    
class B(A):
    def printB(self):
        print('printB...')
    

a = B()
a.printA()
a.printB()      

2、多繼承

# 定義一個父類
class A:
    def printA(self):
        print('----A----')

# 定義一個父類
class B:
    def printB(self):
        print('----B----')

# 定義一個子類，繼承自A、B
class C(A,B):
    def printC(self):
        print('----C----')

obj_C = C()
obj_C.printA()
obj_C.printB()      

3、重寫父類方法與調用父類方法

class Cat(object):
    def sayHello(self):
        print("halou-----1")


class Bosi(Cat):

    def sayHello(self):
        print("halou-----2")

bosi = Bosi()

bosi.sayHello()      

class Cat(object):
    def __init__(self,name):
        self.name = name
        self.color = 'yellow'


class Bosi(Cat):

    def __init__(self,name):
        # 調用父類的__init__方法1(python2)
        #Cat.__init__(self,name)
        # 調用父類的__init__方法2
        #super(Bosi,self).__init__(name)
        # 調用父類的__init__方法3
        super().__init__(name)

    def getName(self):
        return self.name

bosi = Bosi('Yang')

print(bosi.name)
print(bosi.color)      

3、多态

class F1(object):
    def show(self):
        print('F1.show')

class S1(F1):
    def show(self):
        print('S1.show...')

class S2(F1):
    def show(self):
        print('S2.show...')

# 由于在Java或C#中定義函數參數時，必須指定參數的類型
# 為了讓Func函數既可以執行S1對象的show方法，又可以執行S2對象的show方法，是以，定義了一個S1和S2類的父類
# 而實際傳入的參數是：S1對象和S2對象

def Func(obj):
    """Func函數需要接收一個F1類型或者F1子類的類型"""
    print(obj.show())

s1_obj = S1()
Func(s1_obj) # 在Func函數中傳入S1類的對象 s1_obj，執行 S1 的show方法，結果：S1.show

s2_obj = S2()
Func(s2_obj) # 在Func函數中傳入Ss類的對象 ss_obj，執行 Ss 的show方法，結果：S2.show      

4、類方法

是類對象所擁有的方法，需要用修飾器​

​@classmethod​

​​來辨別其為類方法，對于類方法，第一個參數必須是類對象，一般以​

​cls​

​作為第一個參數（當然可以用其他名稱的變量作為其第一個參數，但是大部分人都習慣以'cls'作為第一個參數的名字，就最好用'cls'了），能夠通過執行個體對象和類對象去通路。

class People(object):
    country = 'china'

    #類方法，用classmethod來進行修飾
    @classmethod
    def getCountry(cls):
        return cls.country

    @classmethod
    def setCountry(cls,country):
        cls.country = country

p = People()
p.setCountry('english')

print(p.country)      

5、靜态方法

需要通過修飾器@staticmethod來進行修飾，靜态方法不需要多定義參數。

class People(object):
    country = 'china'

    @staticmethod
    #靜态方法
    def getCountry():
        return People.country

print(People.getCountry())