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())