Python面向对象的三大特征

Python对象的创建与应用

定义python中的类

class Student:  # 类名 每个单词的首字母大写
    addr = '河南'  # 类属性,直接写在类里的属性,该类所有对象共享

    # 初始化方法
    def __init__(self, name, age):
        # name, age 为实体属性
        self.name = name
        self.age = age

    # 实例方法
    def eat(self):
        print('我是实例方法...')

    # 静态方法
    @staticmethod
    def staticMethod():
        print('我是静态方法,使用@staticmethod修饰...')

    # 类方法
    @classmethod
    def classMethod(cls):
        print('我是类方法,使用@classmethod修饰...')

创建类的实例对象并使用

# 创建Student类的实例对象
stu = Student('张三', 20)
print(stu.name, stu.age)
print("---------实例方法的调用-----------")
stu.eat()  # 对象.方法名()
Student.eat(stu)  # 类名.方法名(对象)
print("---------类方法的调用-----------")
Student.classMethod()
print("---------静态方法的调用-----------")
Student.staticMethod()

动态绑定属性和方法

Python是动态语音,在创建对象后,可以动态的绑定属性和方法

def show():
    print("这是一个普通show函数")

stu1 = Student('李四', 20)
stu2 = Student('王五', 20)
# 动态绑定属性
stu1.sex = '女'
print(stu1.name, stu1.age, stu1.sex)
# 动态绑定方法
stu2.show = show
stu2.show()

面向对象的三大特征

• 封装：提高程序的安全性

  • 将数据（属性）和行为（方法）包装到类对象中。在方法内部对属性进行操作，在类对象的外部调用方法。这样，无需关心方法内部的具体实现细节，从而隔离了复杂度。

  • 在Python中没有专门的修饰符用于属性的私有，如果该属性不希望在类对象外部被访问，前边使用两个"_"

    class Student:
        def __init__(self, name, age):
            # name, age 为实体属性
            self.name = name
            self.__age = age
        def showInfo(self):
            print(f'姓名:{self.name}, 年龄:{self.__age}')
    
    stu1 = Student('zhangsan', 20)
    stu1.showInfo()
    # print(stu1.__age)   # 对象外部访问不到__age属性
    # 其实也可以强制访问 _类名__属性
    print(stu1._Student__age)
    

• 继承：提高代码的复用性

  • 语法格式:class 子类名(父类1, 父类2):

  • 默认继承Object类

    定义类时,可以重写Object对象的__str__方法,输出类的描述信息

    class Student:
        def __init__(self, name, age, no):
            self.name = name
            self.age = age
            self.no = no
    
        def __str__(self):	# 重写__str__方法,输出类的描述信息,类似Java类中的toString()作用
            return f'name={self.name}, age={self.age}, no={self.no}'
    
    
    stu = Student('张三', 20, '100010')
    print(stu)  # name=张三, age=20, no=100010
    

  • Python支持多继承

  • 定义子类时,必须在其构造函数中调用父类构造函数

    class Person:
        def __init__(self, name, age):
            # name, age 为实体属性
            self.name = name
            self.age = age
    
        def showinfo(self):
            print(f'姓名:{self.name}, 年龄:{self.age}')
    
    
    class Student(Person):  # Student类继承Person类
        def __init__(self, name, age, stu_no):
            super().__init__(name, age)  # 调用父类的构造函数
            self.stu_no = stu_no
    
        def showinfo(self):  # 重写父类中的方法
            super().showInfo()  # 调用父类中被重写的方法
            print(f'学号:{self.stu_no}')
    
    
    stu = Student('张三', 20, "10010")
    stu.showinfo()
    

• 多态：提高程序的可扩展性和可维护性

静态语言和动态语言关于多态的区别

• 静态语言(Java)实现多态的三个必要条件

1. 继承

2. 方法重写

3. 父类引用指向子类对象

• 动态语言(Python)的多态崇尚“鸭子类型”当看到一只鸟走起来像鸭子、游泳起来像鸭子，那么这只鸟就可以被称为鸭子。在鸭子类型中，不需要关心对象是什么类型，到底是不是鸭子，只关心对象的行为。

  class Animal:
      def eat(self):
          print("动物会吃")
  
  
  class Cat(Animal):
      def eat(self):
          print("猫吃鱼")
  
  
  class Dog(Animal):
      def eat(self):
          print("狗吃肉")
  
  
  class Person:
      def eat(self):
          print("人吃五谷")
  
  
  def fun(obj):
      obj.eat()
  
  fun(Animal())
  fun(Cat())
  fun(Dog())
  print("*" * 20)
  fun(Person())
  # 动物会吃
  # 猫吃鱼
  # 狗吃肉
  # ********************
  # 人吃五谷