Python 中的面向对象

想学习更多Python知识，请关注微信公众号 莫同学vv

 

面向对象三要素：封装、继承、多态

 

封装

把一个共享的公用功能代码封装到一个方法中，在使用该功能的时候直接调用该方法，而不是每次用到该功能的时候都重写一遍该功能方法的代码。

 

封装的好处

1、将变化隔离

2、便于使用

3、提高复用性

4、提高安全性

 

封装的原则

1、将不需要对外提供的内容都隐藏起来

2、 把属性都隐藏，提供公共方法对其访问

 

继承

1、可以继承父类中公有方法方法

2、不可以继承父类中的私有方法

3、可以继承父类中__init__()方法的公有属性

4、不可以继承父类中__init__()方法的私有属性

5、可以继承父类中公有方法中的私有属性

6、不可以调用父类中私有方法和私有属性

class A:
    def __init__(self):
        self.num1 = 10
        self.__num2 = 20
    def test1(self):
        print("===test1===")
    def __test2(self):
        print("===test2===")
    def test3(self):
        self.__test2()
        print(self.__num2)
class B(A):
    def test4(self):
        self.__test2()
        print(self.__num2)
b = B()
b.test1()    # 可以继承A的公有方法test1()方法
b.__test2()  # 不可以继承A中的私有方法__test2()
print(b.num1) # 可以继承A中__init__()方法的公有属性
print(b.__num2) # 不可以继承A中__init__()方法的私有属性
b.test3()         # 可以继承A中公有方法中的私有属性
b.test4()          # 不可以调用A中私有方法和私有属性 

多继承

Python 中可以实现多继承，即一个类可以继承多个类以提高效率。

class Base(object):   # object 是所有类的父类，可以省略 object
    def test_Base(self):
        print("===test_Base===")
class A(Base):
    def test_A(self):
        print("===test_A===")  
class B(Base):
    def test_B(self):
        print("===test_B===")      
class C(A,B):  # 多继承，在括号中用逗号隔开多个类
    pass
c = C()
c.test_Base()  # 可以调用基类的方法
c.test_A()     # 可以调用父类的方法
c.test_B()     # 可以调用父类的方法

多继承的注意点

类名.__mro__ 方法根据C3算法推断出调用优先顺序

如果C类中有test()方法，则直接调用C类中的test()方法，如果C类中没有test()方法，则根据类名.__mro__ 方法中的指定顺序调用父类中的test()方法

class Base(object):   # object 是所有类的父类，可以省略 object
    def test(self):
        print("===test_Base===")
class A(Base):
    def test(self):
        print("===test_A===")  
class B(Base):
    def test(self):
        print("===test_B===")      
class C(A,B):  # 多继承，在括号中用逗号隔开多个类
    # pass
    def test(self):
        print("===test_C===")
c = C()
c.test()  # 可以调用基类的方法

多态

定义的时候还不知道谁调用，在被调用的时候根据传入的参数判断是谁调用

class A(object):
    def test(self):
        print("===test_A===")
class B(A):
    def test(self):
        print("===test_B===")
def test1(tmp):   # 在类中用def定义的称为方法，在类外用def定义的是函数，括号内可以不加self   
    tmp.test()    # 多态：定义的时候还不知道谁调用，在被调用的时候根据传入的参数判断是谁调用
a = A()
b = B()
test1(a)    
test1(b)  

类属性、实例属性

类也是一个对象，叫类对象，类对象的属性叫类属性，由类创建的对象叫实例对象，实例对象的属性叫实例属性

实例属性：实例属性属于某个具体的实例对象，并且一个实例对象和另一个实例对象是不共享实例属性的

类属性：类属性所属于类对象，并且同一个类创建的实例对象共享同一类属性

# 同一个类创建的实例对象共同拥有类属性
class People(object):
    # 类属性
    num = 10
    def __init__(self,new_name):
        self.name = new_name
p1 = People("zhangsan")
p2 = People("lisi")
print(p1.num)
print(p2.num)  

调用类对象

# 同一个类创建的实例对象共同拥有类属性
class People(object):
    # 类属性
    num = 10
    def __init__(self,new_name):
        self.name = new_name
        # 调用类实例对象
        People.num += 1
p1 = People("zhangsan")
p2 = People("lisi")
print(p1.num)
print(p2.num)  

类方法

类方法在方法名后的括号中要有参数cls，在方法顶部用 @classmethod 来声明

1、可以通过类的名字调用类方法

2、可以通过这个类创建的实例对象去调用这个类方法

class People(object):
    # 类属性
    num = 10
    # 实例方法
    def __init__(self):
        # 实例属性
        self.name = "zhangsan"
    # 类方法
    @classmethod
    def add_num(cls):
        cls.num = 20
p1 = People()
print(p1.num)
# 可以通过这个类创建的实例对象去调用这个类方法
p1.add_num()
print(p1.num)
# 可以通过类的名字调用类方法
print(People.num)  

静态方法

类方法后的括号内需要有参数cls

实例方法后的括号内需要有参数self

静态方法后的括号内可以为空，在方法顶部用 @staticmethod 来声明

class People(object):
    # 静态方法
    @staticmethod
    def print_name():
        print("zhangsan")
# 通过类去调用静态方法
People.print_name()
# 通过实例对象去调用静态方法        
p1 = People()
p1.print_name()

想学习更多Python知识，请关注微信公众号 莫同学vv