面向对象的琐碎特性

Posted 2020-10-16

好久没更新了，这段时间忙成狗了，做的却是没多大意义的Work，不说了，为了解决人生苦短的问题，继续奔腾着。。

1. 类的私有属性

 1 class Person:
 2     def __init__(self, name, age):
 3         self.name = name
 4         self.__age = age  # 私有属性
 5 
 6     # 给私有属性赋值，需要专门写一方法
 7     def set_new_age(self, new_age):
 8         if new_age > 0 and new_age <= 120:
 9             self.__age = new_age
10 
11     # 返回私有属性的方法
12     def get_age(self):
13         return self.__age
14 
15 
16 laowang = Person("老王", 30)
17 laowang.set_new_age(32)
18 print(laowang.get_age())

运行结果

2. 类的单继承(注：父类私有方法及属性不可被继承)

 1 class Cat:
 2     def __init__(self, color=‘白色‘):
 3         self.color = color
 4 
 5     def run(self):
 6         print(‘---跑---‘)
 7 
 8 
 9 class PersianCat(Cat):
10     pass
11 
12 
13 cat = PersianCat(‘黑色‘)
14 cat.run()
15 print(cat.color)

运行结果

3. 类的多继承

class Bird:
    def fly(self):
        print("--天上飞的方法--")

    def breathe(self):
        print("--鸟类的呼吸--")


class Fish:
    def swin(self):
        print("--水里游的方法--")

    def breathe(self):
        print("--鱼类的呼吸--")


class Volador(Bird, Fish): # 定义水鸟类(breathe为同名方法，先继承那个类就调哪个方法)
    pass


vola = Volador()
vola.fly()
vola.swin()
vola.breathe()

运行结果

4. 父类的操作————重写

 1 class Hello:
 2     def say_hello(self):
 3         print("--Hello--")
 4 
 5 
 6 class Chinese(Hello):
 7     def say_hello(self):        # 继承父类后的方法重写
 8         print("--吃了木有？--")
 9 
10 
11 chinses = Chinese()
12 chinses.say_hello()

运行结果

 

5. 父类的操作————调用

class Animal:                           # 动物：父类
    def __init__(self, leg_num):
        self.leg_num = leg_num


class Birdman(Animal):
    def __init__(self, leg_num):
        self.plume = "白色"
        super().__init__(leg_num)       # 调用父类方法


bird = Birdman(2)
print("有一只%s条腿%s羽毛的鸟人在树上装逼..." % (bird.leg_num, bird.plume))

运行结果

 6. 初识多态(调用同一种方法而出现的两种形式)

class A:
    def test(self):
        print(‘--A--Test.‘)


class B(A):
    def test(self):
        print(‘--B--Test.‘)


def func(tmp):
    tmp.test()  # 根据这里可知，传入的实参为对象


a = A()
b = B()

func(a)  # 传入对象a，调用a中的test()方法
func(b)  # 传入对象b，调用b中的test()方法

运行结果

7. 进一步认识“多态”(传入不同的对象，调用不同的方法，跟上面一样)

class Animal():
    def shout(self):    # 叫的方法
        print("--Animal--shout--")


class Dog(Animal):
    def shout(self):
        print("--汪，汪汪，汪--")


class Cat(Animal):
    def shout(self):
        print("--喵--喵--")


def func(tmp):
    tmp.shout()


dog = Dog()
cat = Cat()

func(dog)
func(cat)

运行结果

8. 类属性、实例属性

class Cat:
    num = 0                 # 类属性

    def __init__(self):     # 实例属性
        self.age = 1


print(Cat.num)              # 类属性
print(‘\\n‘)

cat = Cat()                 # 实例属性
print(cat.num)
print(cat.age)

运行结果

9. 类的方法(不用实例化，拿来就用的赶脚)(注意，它不能访问实例属性，只可访问类属性)

class Test:
    # 类属性
    num = 0

    # 类方法
    @classmethod
    def set_num(cls, new_num):
        cls.num = new_num


Test.set_num(300)
print(Test.num)

运行结果

10. 静态方法

 

class Test:
    @staticmethod
    def print_test():
        print("--哥是静态方法--")


Test.print_test()   # 类调用静态方法(不用实例化，即写即用)

test = Test()       # 对象调用静态方法
test.print_test()

运行结果

果然，真尼玛琐碎。。。。。。