PYTHON1.面向对象_day01

课程：Python面向对象
进度：day1

主要内容：
1. 面向对象的概念
2. 面向对象的三大特性：封装、继承、多态
3. 面向对象的技术特性
4. 方法重载、运算符重载
5. 面向对象的设计

今天内容提要
1. OOP概念：以对象为中心，关注功能、关注结果
  1）类和对象（重点）
   2）如何定义类（重点）
   3）类的构成（重点）
   4）封装（重点）
   5）继承（重点）

今天内容
1. 面向对象基本概念
   1）面向过程：考虑实现过程、考虑每一步如何做
        代码组织单位：函数

  2）面向对象
     a)提出的原因
         - 成本和可行性
         - 代码复用，提高开发效率
         - 软件既要保持稳定性，又要满足不断变更
           对扩展开放，对修改封闭
         - 面向过程方式，在某些领域有局限性

   b) 什么是面向对象
         - Object Orainted Programming(简写OOP)
            关注对象，把事物看做一个一个对象，以对象为中心
            把事物归纳成一个一个的类
         - 提供了另一种分析、解决问题的方式

   c) 优点
        - 思想方法层面：更有利于归纳、分析、解决问题
                                   更接近于人的思维方式
        - 技术层面
           重用性：有利于代码复用，提高开发效率
           扩展性：能够方便对现有代码进行扩展和改写
           灵活性：程序设计具有更多的灵活性、弹性

       - 适用场景
           面向过程：系统级软件，嵌入式
           面向对象：企业级应用，图形库，游戏

        - 类和对象 （重点）
           类（class）：具有共同特征事物的统称。例如学生，汽车
           对象（object）: 类当中一个特殊的个体，特定、具体的

       - 类的构成 （重点）
          属性：描述对象“有什么”，数据特征
          行为：描述对象“能干什么”，行为特征

       - Python中类的定义  （重点）
         class  ClassName([父类列表]):
     "类的代码"
     # 属性（一般通过__init__构造方法创建）
     # 方法1
     # 方法2
     # ......
          说明：  class              定义类的关键字
                       ClassName   类名称（一般以大写字符开头）
                       父类列表       发生继承时候，表示从哪个类继承

# ellipse.py
# 面向过程、面向对象编程比较
# 计算椭圆周长、面积

# 面向过程方式
a = 2.0   # 短半径
b = 3.0   # 长半径
len = 2 * 3.14 * a + 4 * (b - a)
print("a=%f, b=%f, len=%f" % (a,b,len))

area = 3.14 * a * b
print("a=%f, b=%f, area=%f" % (a,b,area))

# 面向对象方式
class Ellipse:   # 定义椭圆类
    #类中的函数, 称之为方法
    def __init__(self, a, b):  # 构造方法
        self.a = a   # 属性：短半径
        self.b = b   # 属性：长半径
    # 2 * pi * 短半径 + 4（长半径 - 短半径）
    def calc_len(self): #计算周长
        return 2 * 3.14 * self.a + 
               4 * (self.b - self.a)

    def calc_area(self): #计算面积
        return 3.14 * self.a * self.b

e = Ellipse(2.0, 3.0)  # 实例化：创建椭圆对象
len = e.calc_len()     # 获得椭圆周长
area = e.calc_area()   # 获得椭圆面积
print("a=%f，b=%f, len=%f, area=%f" %
      (e.a, e.b, len, area))

  - 示例：定义一个汽车类(AutoMobile)
                     代码见auto_mobile.py

# auto_mobile.py
# 汽车类
import random
class AutoMobile:
    # 构造方法，主要作用是对属性进行初始化
    def __init__(self, name,
                 color, output_volumn):
        self.name = name    # 名称
        self.color = color  # 颜色
        self.output_volumn = output_volumn#排量
        self.__distance = 0.00  # 私有属性
        self.__fuel_cons = 8.0  # 每百公里耗油量

    def __calc_distance(self): # 计算行驶里程方法
        dist = random.randint(1,400)
        self.__distance += dist  # 改变行驶里程

    def get_distance(self):  # 获得行驶里程
        return self.__distance  # 返回行驶里程属性

    def startup(self): # 启动方法
        print("汽车启动")

    def run(self):  # 行驶方法
        self.__calc_distance()  # 调用行驶里程计算方法
        real_fuel_con = self.__fuel_cons / 100 
                        * self.__distance
        print("汽车行驶了%.2f公里，油耗%.2f升" %
            (self.__distance, real_fuel_con))

    def stop(self):  # 停止方法
        print("汽车停止")

    def info(self):  # 打印汽车信息
        print("名称:%s,颜色:%s,排量:%.2f" 
             %(self.name, self.color, 
             self.output_volumn))

if __name__ == "__main__":
    # 实例化：根据类创建对象（根据模型制作具体产品）
    am = AutoMobile("家用轿车", "红色", 2.0)
    am.startup()   # 启动汽车（调用汽车方法）
    am.run()       # 行驶
    am.stop()      # 停止
    am.info()      # 查看汽车对象信息
    # 通过调用get_distance()获取行驶里程
    print("行驶里程：%.2f" % am.get_distance())

# car.py
# 家用小汽车类，继承示例
from auto_mobile import *

# 定义Car类，继承自AutoMobile类
class Car(AutoMobile):
    pass

if __name__ == "__main__":
    mycar = Car("小汽车", "蓝色", 1.40)
    mycar.startup()  #启动
    mycar.run()      #行驶
    mycar.stop()     #停止
    mycar.info()     #打印信息

 

- OOP小结：
            - 使用class AutoMobile定义了一个类，类中包含了
              名称、颜色、排量等属性；启动(startup), 行驶(run),
              停止(stop)，打印信息(info)等方法

           - 方法在类的内部定义，也叫成员函数或方法，定义了
              类“能干什么”，或“具有哪些功能”。和普通函数
              有个重要差别，就是必须以self作为第一个参数。self
              自动绑定调用该方法的对象

           - 实例化：创建一个类的对象
              am = AutoMobile("家用轿车", "红色", 2.0)
             
              * 该语句执行成功后，会返回一个对象，通过赋值语句
              将该对象绑定到am变量上
              * 实例化对象时，要传入的参数根据__init__方法确定
           
            - __init__（）方法，称之为“构造方法”
              在对象被创建时自动调用
              作用是创建属性，并且进行初始化

           - 对象被创建后，可以通过"对象.方法名()"来调用方法
              通过"对象.属性"来访问对象的属性

2. 面向对象三大特征： 封装、继承、多态
   1）封装
       - 将属性、方法放到类的内部
       - 对象对外提供了一组方法（接口），来对类的数据进行
         访问
       - 对于一个类或对象，外部主要关注功能，而不是功能的实现

   面向对象编写程序三步曲（记住，理解，应用）
    第一步：设计编写类。根据业务逻辑，从具体事物中归纳、
                  抽象出共同的属性、方法，并编写代码
              class 类名:
                    #构造方法
                    #其它方法
     第二步：根据定义的类，实例化一个对象
              ak = AK47()
              awp = AWP()
     第三步：调用对象方法，使用类所提供的功能
             ak.reload()
             ak.fire()
             awp.reload()
             awp.fire()

  2）继承
     a）代码冗余：不同模块中相同或相似的代码
           导致的问题
               - 重复劳动
               - 编码、测试工作量增大
               - 修改、维护困难
     b）继承
          - 将事物共同的特征抽象出来，定义到父类中
             子类继承父类，自动获得父类的行为和属性
          - 继承描述事物的共同特征
          - 继承能够减少代码冗余，减少工作量，提升效率
            使得代码更容易维护

   c）几个相关概念
          - 父类（基类，超类）、子类（派生类）
          - 父类相对子类更抽象、范围更宽泛
            子类相对于父类更具体、范围更狭小
          - 单继承（只有一个父类，Java）
            多继承（超过一个父类, Python/C++）
      d）Python如何实现继承
           class 类名称(父类1[, 父类2...]):
     类的实现代码

     e) 通过继承改写AK47,AWP类，添加父类Gun
           见改写后的ak47.py, awp.py, gun.py, test.py

# ak47.py
# AK47类
from gun import *

class AK47(Gun): #继承自Gun类
    pass

# awp.py
# 狙击枪类
from gun import *

class AWP(Gun):  #AWP类，继承自Gun类
    def openTelescope(self): #打开瞄准镜
        print("瞄准镜已打开")

    def closeTelescope(self): #关闭瞄准镜
        print("瞄准镜已关闭")

# gun.py
# 枪械类
class Gun:
    def __init__(self, name, max_bullets,
                 bullet_left,dest_ratio,
                firing_bullets):
        self.name = name  #名称
        self.max_bullets = max_bullets#弹夹容量
        self.bullet_left = bullet_left#剩余子弹
        self.dest_ratio = dest_ratio #杀伤系数
        # 每次开火击发子弹数量
        self.firing_bullets = firing_bullets

    def reload(self): # 填弹
        self.bullet_left = self.max_bullets
        print("填弹完成，剩余子弹%d发" % 
              self.bullet_left)

    def fire(self):  # 开火
        if self.bullet_left <= 0:#没子弹
            print("请填弹")
            return

        if self.bullet_left >= self.firing_bullets:
            self.bullet_left -= self.firing_bullets
        else: #剩余子弹小于一次击发打出的子弹
            self.bullet_left = 0 #全部打出

        # 计算杀伤力
        damage = int(self.dest_ratio*100)

        # 打印，模拟开火
        print("%s开火，杀伤力%d,剩余子弹%d" % 
          (self.name, damage, self.bullet_left))

# test.py
# 测试程序
import ak47
import awp

ak = ak47.AK47("AK47", 30, 0, 0.4, 3) #实例化AK47对象
ak.reload()      #填弹
ak.fire()        #开火
ak.fire()
print("----------------")
awp = awp.AWP("AWP", 10, 0, 1.0, 1)  #实例化AWP对象
awp.reload()
awp.fire()

ak2 = ak47.AK47("AK47", 20, 0, 0.4, 3)

  f）继承小结
         - 通过归纳、抽象，将共同特征（属性，行为）放到父类中
           子类通过继承，获得父类的行为和属性
         - 能够消除代码冗余
         - 能够在不改变父类代码的情况下，子类添加特有的行为
           和属性（例如AWP类中的openTelescope和
          closeTelescope方法），从而实现功能扩展、变更

作业：
1）定义一个鸟类（Bird），具有吃（eat），飞行（fly）,
繁殖（reproduction）方法
2）定义老鹰类（Eagle），鸵鸟类（Ostrich）类，
继承自Bird类
3）编写测试代码，测试eat,fly,reproduction方法

# bird.py
# 鸟类
class Bird:
    def __init__(self, name):
        self.name = name

    def eat(self):  # 吃方法
        print("%s正在吃饭" % self.name)

    def fly(self):  # 飞行
        print("%s正在飞行" % self.name)

    def reproduction(self): # 繁殖
        print("%s是卵生" % self.name)

class Eagle(Bird):  # 老鹰类，继承自Bird
    def eat(self):   # 重写eat方法
        print("我是%s,我喜欢吃肉" % self.name)

    def fly(self):
        print("我是%s,飞的又高又快" % self.name)

class Ostrich(Bird):  # 鸵鸟类，继承自Bird
    def fly(self):  # 重写fly方法
        print("我是%s,太重了不能飞" % self.name)

    def eat(self):
        print("我是%s,我是杂事动物" % self.name)

if __name__ == "__main__":
    eagle = Eagle("老鹰")
    eagle.eat()
    eagle.fly()
    eagle.reproduction()
    print("")
    ostrich = Ostrich("鸵鸟")
    ostrich.eat()
    ostrich.fly()
    ostrich.reproduction()