1.面向对象编程

  • 面向对象编程（Object Oriented Programming，简称：OOP ）是一种解决软件复用的设计和编程方法，就是根据现实社会中的事物，抽象出事物的属性和功能，后然将抽象出来的属性和功能封装成对象的属性和方法，在软件中通过复用对象实例提高软件的开发效率 ，很多高级编程语言都遵循面向对象的编程方法。

    2.类和对象

    • 类：是一类事物的抽象，定义了一类事物的属性和行为
      • 类的构成：类名、属性、方法
      • 定义： ```python class 类名: def 方法名(self[,参数列表]): 方法体 ……

注意事项： 1.定义类时，使用class关键字声明这是一个类 2.类名的命名规则：通常按照约定的“大驼峰”命名法。例：class ElectricCar 电动车类 3.定义方法时，方法的第一个参数默认为self，表示对象自身 4.通过对象调用方法时，不需要在方法中传入self参数，python解释器会自动传入

  1. ```python
  2. class Cat:
  3.   def eat(self):
  4.     print("吃鱼。。。")
  5.   def drink(self):
  6.     print("喝水。。。")
  7.   def run(self):
  8.     print("跳舞。。。")
  • 对象：是通过类创建的一个具体事物，具有状态和行为，可以做具体事情。
    • 创建对象的过程：是在内存中开辟一块区域存储这个对象，这块内存区域有它的对应内存地址，通过内存地址就能找到这块区域存储的这个对象。
    • 对象的引用：就是把存储这个对象的内存地址告诉了变量，这个变量就指向了内存中的这个对象，通过这个变量就可以找到它所指的这个对象，所以这个变量叫这个对象的引用。 ```python

      根据Cat类创建对象

      xiaohe=Cat()

      调用对象的方法

      xiaohe.eat() xiaohe.drink() xiaohe.run()

对比一个类创建多对象是否相同

xiaobai=Cat()

id(对象)可以获取对象的内存地址

print(“xiaohe的id：{}”.format(id(xiaohe))) print(“xiaobai的id：{}”.format(id(xiaobai)))

  2.    -  类与对象的关系：类相当于创建对象的基础条件，根据类可以创建多个对象。 
  3. -   
  4. <a name="ND8Ci"></a>
  5. ### 3.`__init__`构造方法
  7.    -  构造方法作用：是在创建一个类的对象时，对对象进行初始化操作。 
  8.    -  python中类的构造方法名称是`__init__`。定义类时，没有显示定义`__init__`构造方法，创建对象时会自动调默认没有参数的`__init__`构造方法 
  9.       - 无参构造方法
  10. ```python
  11. class Cat:
  12.   #无参构造方法
  13.   def __init__(self):
  14.     print("初始化对象。。。")
  15.   def eat(self):
  16.     print("吃鱼。。。")
  17.   def drink(self):
  18.     print("喝水。。。")
  19.   def run(self):
  20.     print("跳舞。。。")
  22. # 创建对象
  23. xiaohe=Cat()
  24. #调用对象的方法
  25. xiaohe.eat()
  26. xiaohe.drink()
  27. xiaohe.run()
  1.   - 有参构造方法
  1. class Cat:
  2.   #有参构造方法
  3.   def __init__(self,sex,age):
  4.     print("开始初始化对象。。。")
  5.     self.sex=sex
  6.     self.age=age
  7.     print("结束初始化对象。。。")
  8.   def eat(self):
  9.     print("吃鱼。。。")
  10.   def drink(self):
  11.     print("喝水。。。")
  12.   def run(self):
  13.     print("跳舞。。。")
  15. # 创建对象
  16. xiaohe=Cat("男",1)
  17. print("xiaohe的性别：{},年龄：{}".format(xiaohe.sex,xiaohe.age))

4.访问权限

  • python中类的属性和方法的访问权限不需要任何关键字修饰，是通过属性或者方法名前加两个下划线区分：
    • 私有访问权限：属性或者方法名前加两个下划线，只能在类内部方法。例：__name变量，__eat()方法
    • 公共访问权限：不需要在属性或者方法名前加两个下划线，可以在外部访问。例：name变量，eat()方法 ```python class Cat:

      有参构造方法

      def init(self,sex): print(“开始初始化对象。。。”) self.sex=sex self.age=age #私有属性 print(“结束初始化对象。。。”) def eat(self): print(“吃鱼。。。”) def drink(self): print(“喝水。。。”) def run(self): print(“跳舞。。。”) def get_info(self):

      调用私有属性和方法

      print(“年龄：{}”.format(self.age)) print(“run方法：”,self.run())

创建对象

xiaohe=Cat(“男”,1) xiaohe.get_info()

  3. <a name="TpOAm"></a>
  4. ### 5.继承
  6. - 面向对象编程的好处之一是代码重用，通过继承机制可以很好的实现代码重用。 
  7.    -  单继承：就是子类只继承一个父类 
  8.       - 格式：
  9. ```python
  10. class 子类名(父类名):
  1.   - 特点：子类只会继承父类的非私有属性和非私有方法
  1. #定义动物类
  2. class Animal:
  3.   def eat(self):
  4.     print("吃。。。")
  5.   def drink(self):
  6.     print("喝。。。")
  7.   def run(self):
  8.     print("运动。。。")
  10. #定义子类
  11. class Cat(Animal):
  12.   #猫除了继承父类属性好行为，还会捉老鼠行为
  13.   def catch(self):
  14.     print("捉老鼠。。。")
  16. # 创建对象
  17. xiaohe=Cat()
  18. #调用对象的方法
  19. xiaohe.eat()
  20. xiaohe.drink()
  21. xiaohe.run()
  22. xiaohe.catch()
  • super函数
    • 子类调用父类方法的方式：
      • 父类名.方法名(self[,参数列表])：在调父类方法时，需要传入self参数，这个self是子类而不是父类的实例对象 ```python class Cat(Animal):

        猫除了继承父类属性好行为，还会捉老鼠行为

        def catch(self): print(“捉老鼠。。。”)

定义子类

class BlackCat(Cat):

猫除了继承父类属性好行为，还会捉老鼠行为

def catch(self): Cat.catch(self)

xiaohe=BlackCat() xiaohe.catch()

  2.          - `super.方法名`
  3. ```python
  4. class Cat(Animal):
  5.   #猫除了继承父类属性好行为，还会捉老鼠行为
  6.   def catch(self):
  7.     print("捉老鼠。。。")
  9. #定义子类
  10. class BlackCat(Cat):
  11.   #猫除了继承父类属性好行为，还会捉老鼠行为
  12.   def catch(self):
  13.      super.catch()
  15. xiaohe=BlackCat()
  16. xiaohe.catch()
  • 重写
    • 就是 在子类中定义与父类同名的方法。子类重写父类后调用时，只会调用子类中重写的方法 ```python

      定义动物类

      class Animal: def eat(self): print(“吃。。。”) def drink(self): print(“喝。。。”) def run(self): print(“运动。。。”)

class Cat(Animal):

猫除了继承父类属性好行为，还会捉老鼠行为

def run(self): print(“跳舞。。。”)

xiaohe=Cat() xiaohe.eat() xiaohe.drink() xiaohe.run()

  2.    -  多继承 
  3.       -  是一个子类可以继承多个父类 
  4.       -  格式：  
  5. ```python
  6. class 子类名(父类1,父类2,父类3,...):
  1. class God:
  2.   def change(self):
  3.     print("百宝箱变东西。。。")
  5. class Cat:
  6.   def eat(self):
  7.     print("吃铜锣烧。。。")
  9. class Doraemon(God,Cat):
  10.   def speak(self):
  11.     print("说人话")
  14. a = Doraemon()
  15. a.change()
  16. a.eat()
  17. a.speak()

注：为了提高代码的可读性，多继承中，多个父类内尽量不要定义相同名称的方法

  • 当才华还配不上野心，就静下来学习