python面向对象:封装、继承、多态

 

面向对象三个特性：

封装：属性和方法封装到一个抽象的类中。
继承：实现代码的重用。子类可针对自己特有的需求编写代码。
多态：不同的子类对象调用相同的父类方法，产生不同的执行结果。

 

一、python封装

在设计类时，将一些属性和方法隐藏在类的内部，将无法直接以"类对象.属性名"（或者"类对象.方法名（参数）"）的形式调用这些属性（或方法），而只能用未隐藏的方法间接的操作这些隐藏的属性和方法。对类的属性和方法名称前两位字符使用单下画线定义，在调用过程中只能通过_class__xxx方式访问（class代表类名，xxx代表属性或方法名称）。

1. 默认情况下，python类中的变量和方法都是公有的，它们的名称前都没有下划线（_）
2. 如果类中的变量和函数，其名称以双下划线“__”开头，则该变量或函数为私有的。
3. 以单下划线“_”开头的类属性和类方法约定俗成的被视为私有属性和私有方法，虽然它们也能通过类对象正常访问，但是建议不要这样。
4. 以双下划线开头和结尾的类方法（如__init__()）时python内部定义的，自己定义时，不要使用这种格式。

类的专有方法：
__init__  构造函数，在生成对象时调用
__del__   析构函数，释放对象时使用
__repr__ 打印，转换
__setitem__按照索引赋值
__getitem__按照索引获取值
__len__获得长度
__cmp__比较运算
__call__函数调用
 
__add__加运算
__sub__减运算
__mul__乘运算
__div__除运算
__mod__求余运算
__pow__称方

 

1.

class Animals:
    __name='小白'
    def __run(self):
        print('This is running')

a=Animals()
print(a.__name)
a.__run()

运行结果如下：

2.

class Animals:
    name='小白'
    def run(self):
        print('This is running')

a=Animals()
print(a.name)
a.run()

运行结果如下：

3.调用类的内置方法__dir__()查看当前对象的所有属性和方法.

class Animals:
    # 定义私有属性和私有方法
    __name='小白'
    def __run(self):
        print('This is running')

a=Animals()
print(a.__dir__())
print(a._Animals__name)
a._Animals__run()

运行结果如下：

4.

#类定义 
class people: 
  #定义基本属性 
  name = '' 
  age = 0
  #定义私有属性,私有属性在类外部无法直接进行访问 
  __weight = 0
  #定义构造方法 
  def __init__(self,n,a,w): 
    self.name = n 
    self.age = a 
    self.__weight = w 
  def speak(self): 
    print("%s is speaking: I am %d years old" %(self.name,self.age)) 
  
  
p = people('tom',20,30) 
p.speak() 

 

二、python类的继承

一个类继承另一个类时，会自动获得另一个类的所有属性和方法，被继承的类称之为父类，新类称为子类。子类拥有父类所有的属性和方法，并且可以定义自己的属性和方法。

# 定义一个父类
class Animals:
    colour='black'

    # 父类中的方法
    def run(self):
        return 'Running'

 # 定义一个子类， 继承Animals类
class Dog(Animals):
    dogName='little black dog'

    # 在子类中定义其自身的方法
    def speak(self):
        return 'Speaking'

class Cat(Animals):
    catName='little black cat'

    def sleep(self):
        return 'Sleeping'

# 子类 重构方法
class Pets(Dog,Cat):
    def run(self):
        return 'Running and Jumping'

    def myPets(self):
        print(f'I have tow pets,their colors is {self.colour}')
        print(f'I have a dog,its name is {self.dogName}')
        print(f'I have a cat,its name is {self.catName}')
        print(f'The dog can {self.speak()}')
        print(f'The cat can {self.sleep()}')
        print(f'They can {self.run()}')

if __name__=='__main__':
    p=Pets()
    # 调用本身的方法
    p.myPets()

 

三、python多态

类的多态是指类可以有多个名称相同、参数类型不同的函数方法。Python没有明显的多态特性，因为Python函数的参数不必声明数据类型。

在一个类里面，只要在函数方法里面使用可变参数和关键字参数即可实现类的多态，因为可变参数和关键字参数不会限制参数的数量和数据类型，从而使该方法具有多态特性.

类的多态除了设置实例方法的可变参数和关键字参数之外，还可以在不同的类之间实现，比如派生类重写基类的某个方法或者两个不相关的类定义了相同的方法.

尽管两个类都定义了相同名称的实例方法，但通过传入不同的实例化对象即可调用对应的方法，这也是体现了类的多态.

# 在school类中封装方法schoolclass
class School(object):
    # 初始化方法中定义一个name属性
    def __init__(self,name):
        self.name=name

    def schoolclass(self):
        print("班级:%s"%self.name)

# 定义XiaoMing继承自School类，并重写父类方法
class XiaoMing(School):
    def schoolclass(self):
        print("班级：%s"%self.name)

# 定义Person类，并且封装一个schoolclass_with_classone的方法
# 在方法内部，直接让classone对象调用schoolclass方法
class Person(object):
    def __init__(self,name):
        self.name=name

    def schoolclass_with_classone(self,classone):
        print("%s在%s"%(self.name,classone.name))
        classone.schoolclass()

# 创建一个grade对象
grade=School("一班")
# grade=XiaoMing("二班")

# 创建一个小明对象
xiaoming=Person("小明")
# 小明调用schoolclass_with_classone方法
xiaoming.schoolclass_with_classone(grade)

 

 

 

部分参考《精通Python自动化编程》