面向对象的三大特性：封装、继承、多态

一、封装

  • 将数据和行为包装到类对象中，提高程序的安全性。
  • 主要思想就是将代码提取出一个方法，一个类，在程序设计时还需要不断地去完善。
  • 同时类的一些属性不希望直接暴露给外界，让外界直接操作。因为这些属性可能有其特定的意义，如果让外接随意操作，可能最终结果并不是我们想要的。此时我们就需要将这些属性给封装起来，不让外界直接访问。
  • 在python中没有专门修饰符用于属性的私有，如果该属性不希望在类对象外部被访问，则添加两个"_"。
 1 class Car:
 2     """封装"""
 3     def __init__(self, name=None, brand=None):
 4         self.brand = brand
 5         self.__name = name
 6 
 7     def my_start(self):
 8         print("启动！")
 9         print(self.__name)
10 
11 
12 car = Car("133", "343")
13 print(car.brand)

二、继承

如果很多类具有着相同的属性和方法，那么这些属性和方法可以被提取出来，单独形成一个父类。之前的类再继承这个父类，就可以继承父类的属性和方法。因此，继承可以提高代码的复用性。

1. python中类的一些特点

  • 如果一个类没有继承任何类，则默认继承object
  • Python支持多继承，也就是一个类可以有多个父类
  • 定义子类时，必须在其构造函数中调用父类的构造函数

2. 方法重写

　　如果子类对继承自父类的某个属性或方法不满意，也就是说某个属性无法满足子类的需求，可以在子类中对其进行重新编写。

　　子类重写后的方法可以通过super().xxx()调用父类中被重写的方法，此时子类在执行重写的方法的同时，也会执行父类的属性或方法，在我看来相当于在子类的属性或方法里，调用了父类的同一个属性或方法。

3. object类

  • object类是所有类的父类，因此所有类都有object类的属性和方法
  • 内置函数dir()可以查看指定对象所有属性
  • Object有一个__str__()方法，用于返回一个对于“对象的描述"，对应于内置函数str()经常用于print函数，帮我们查看对象的信息，所以我们经常会对__str__()进行重写
 1 class Person(object):   # person继承object类
 2     """继承"""
 3     def __init__(self, name, age):
 4         self.name = name
 5         self.age = age
 6 
 7     def info(self):
 8         print(self.name, self.age)
 9 
10 
11 class Student(Person):
12     def __init__(self, name, age, stu_no):
13         super().__init__(name, age)
14         self.stu_no = stu_no
15 
16     def info(self):            # 方法重写
17         super().info()
18         print(self.stu_no)
19 
20 
21 class Teacher(Person):
22     def __init__(self, name, age, teach_year):
23         super().__init__(name, age)
24         self.teach_year = teach_year
25 
26     def info(self):
27         super().info()
28         print(self.teach_year)
29 
30 
31 class Assistant(Teacher, Student):     # 多继承，同时继承多个父类
32     pass
33 
34 
35 stu = Student("张三", 20, "6667832")
36 teacher = Teacher("李四", 34, 16)
37 
38 stu.info()
39 teacher.info()
 1 class A:
 2     """
 3     __str__()重写，输出类的内存地址,这里将它重写
 4     """
 5     def __init__(self):
 6         self.name = "f"
 7 
 8     def __str__(self):
 9         return '我的名字是{}'.format(self.name)
10 
11 
12 a = A
13 print(a)    # 默认调用a.__str___()
三、多态
  • 提高代码的扩展性和可维护性。
  • 简单地来说，多态就是具有多种形态，它指的是：即便不知道一个变量所引用的对象到底是什么类型。仍然可以通过这个变量调用方法，在运行过程中根据变量所引用对象的类型，动态决定对象调用那个对象中的方法。
  • 有人说python中是没有多态的，因为python中没有数据类型，但是python中其实是有多态的这种特征。在python中，多态可以让不同功能的函数可以使用相同的函数名，这样就可以让一个函数名调用不同功能的函数。
  • 在面向对象中，多台一般可以这样理解：想不同的对象发送同一条信息，不同对象在接收时会产生不同的行为，也就是说每个对象可以通过自己的方式去响应共同的消息。直白一点讲就是，不同的类可以有同名函数。
 1 class Animal(object):
 2     def eat(self):
 3         print("dongwu")
 4 
 5 
 6 class Dog(Animal):
 7     def eat(self):
 8         print("gou")
 9 
10 
11 class Cat(Animal):
12     def eat(self):
13         print("mao")
14 
15 
16 def eat(obj):
17     obj.eat()
18 
19 
20 eat(Animal())
21 eat(Dog())
22 eat(Cat())