面向对象编程——1.初步了解

1147-柳同学

发表文章数:589

首页 » Python » 正文

一、引言

学习python已有5个月了,小论文初步完成。虽然在学习之初,就听视频里的老师强调面向对象编程的重要性。但在实际用编程解决问题的过程中,面向过程可以明晰解决问题的思路,潜意识下就自然的使用面向过程解决问题了。不过,面向过程在模拟现实世界的人、物、事方面有缺陷,为了get到面向对象的精髓,实现用机器语言来模拟现实世界的静态属性与动态方法。因此,重新进行了梳理。
将从以下方面进行展开:

  • 面向对象的特点
  • 类的定义与调用
  • 类的属性和方法的定义
  • 类的继承

二、面向对象的特点

面向对象符合人类对客观世界的抽象与理解

  • 生活中一切皆对象,python中一切皆对象。
  • 一切对象皆有自己的内在属性 – 属性
  • 一切对象皆有自己的行为 – 方法

我们可以把一类对象的公共特征抽象出来,创建通用的类,类是对象的载体。
面向对象编程将数据与操作方法(属性与方法)封装到对象中,组织代码与数据的方式更接近于人的思维,提高了编程效率。面向过程思维主要关注程序的逻辑流程,适合编写小规模的程序。面向对象编程关注对象之间的关系,是从设计者的角度来关注问题,适合编写大规模程序。但两者不是相互对立的,而是相辅相成的。面向对象离不开面向过程。因此,在碰到问题时,面向对象可以帮助我们从整体上、宏观上分析,在实现每一部分时,我们仍然可以通过面向过程去处理。
面向对象的思考方式:遇到复杂问题时,先从问题中找名词,然后确定这些名词哪些可以作为类,再确定类之间的关系,再根据问题需求确定每一个类的属性与方法。

三、类的定义与调用

1.类的定义

三要素:类名、属性、方法

  • 类的命名——需要有实际意义;驼峰命名法(雷鸣单词首字母大写)
  • 类的属性——相当于内部变量,def init(self,参数) # 初始化类属性
  • 类的方法——相当于类内部定义的函数
"""类前空两行"""


# 定义一个简单的类
class Car():
    """模拟汽车"""
    def __init__(self,brand,model,year):# __init__(self,[])构造函数  # self指当前的实例对象
        """初始化汽车属性"""
        self.brand = brand   # 品牌
        self.model = model   # 型号
        self.year = year     # 出厂年份
        self.mileage = 0     # 里程碑数
    
    def get_main_information(self):  # self不能省
        """获取汽车主要信息"""
        print("品牌:{},型号:{},出厂年份:{}"
              .format(self.brand,self.model,self.year))
    def get_all_mileage(self):
        """获取总里程数"""
        return "行车总里程:{}公里".format(self.mileage)
    
    
"""类后空两行"""

2.类的调用

  • 创建实例
  • 访问属性
  • 调用方法
# 实例的创建-实例化过程中,传入相应的参数
# 通过  类名(参数列表)  来调用构造函数__init__(),调用后将创建好的对象返回给相应的变量
my_new_car = Car("Audi","A6",2018)

# 访问属性
print(my_new_car.brand)
print(my_new_car.model)
print(my_new_car.year)

# 调用方法-实例名.方法名(必要的参数)
my_new_car.get_main_information()
s = my_new_car.get_all_mileage()
print(s)
  • 修改属性
# 修改属性-先访问后修改
# 创建实例
my_old_car = Car("BYD","宋",2016)
# 先访问后修改
print(my_old_car.mileage)
my_old_car.mileage = 12000
print(my_old_car.mileage)

# 0、12000
# 通过方法修改属性
class Car():
    """模拟汽车"""
    def __init__(self,brand,model,year):
        """初始化汽车属性"""
        self.brand = brand   # 品牌
        self.model = model   # 型号
        self.year = year     # 出厂年份
        self.mileage = 0     # 里程碑数
    
    def get_main_information(self):  # self不能省
        """获取汽车主要信息"""
        print("品牌:{},型号:{},出厂年份:{}"
               .format(self.brand,self.model,self.year))
    def get_all_mileage(self):
        """获取总里程数"""
        return "行车总里程:{}公里".format(self.mileage)
    
    def set_mileage(self,distance):  # self由解释器自动传参
        """设置总里程数"""
        self.mileage = distance
        
my_old_car = Car("BYD","宋",2016)
print(my_old_car.get_all_mileage())
my_old_car.set_mileage(8000)
print(my_old_car.mileage)
print(my_old_car.get_all_mileage())
# 行车总里程:0公里
# 8000
# 行车总里程:8000公里
  • 拓展
# 拓展——禁止设置负里程,并将每次里程数累加
class Car():
    """模拟汽车"""
    def __init__(self,brand,model,year):
        """初始化汽车属性"""
        self.brand = brand   # 品牌
        self.model = model   # 型号
        self.year = year     # 出厂年份
        self.mileage = 0     # 里程碑数
    
    def get_main_information(self):  # self不能省
        """获取汽车主要信息"""
        print("品牌:{},型号:{},出厂年份:{}"
              .format(self.brand,self.model,self.year))
    def get_all_mileage(self):
        """获取总里程数"""
        print("行车总里程:{}公里".format(self.mileage))
    
    def set_mileage(self,distance):
        """设置总里程数"""
        if distance >= 0:
            self.mileage = distance
        else:
            print("里程数不能为负!")
    def increment_mileage(self,distance):
        "总里程数累计"
        if distance >= 0:
            self.mileage += distance
        else:
            print("新增里程数不能为负!")

# 禁止设置负里程
my_old_car = Car("BYD","宋",2016)
my_old_car.get_all_mileage()
my_old_car.set_mileage(-8000)
my_old_car.get_all_mileage()
# 行车总里程:0公里
# 里程数不能为负!
# 行车总里程:0公里

# 将每次里程数累加
my_old_car.get_all_mileage()
my_old_car.set_mileage(8000)
my_old_car.get_all_mileage()
my_old_car.increment_mileage(500)
my_old_car.get_all_mileage()
# 行车总里程:0公里
# 行车总里程:8000公里
# 行车总里程:8500公里

my_new_car = Car("Audi","A6",2018)
my_cars = [my_new_car,my_old_car]

小结
– 包含的信息量可以极大化,可以创建无穷多的实例
– 高度的拟人(物)化,符合人类对客观世界的抽象与理解

3.类的继承

面向对象编程——1.初步了解

  • 简单继承
# 父类
class Car():
    """模拟汽车"""
    def __init__(self,brand,model,year):
        """初始化汽车属性"""
        self.brand = brand   # 品牌
        self.model = model   # 型号
        self.year = year     # 出厂年份
        self.mileage = 0     # 里程碑数
    
    def get_main_information(self):  # self不能省
        """获取汽车主要信息"""
        print("品牌:{},型号:{},出厂年份:{}"
               .format(self.brand,self.model,self.year))
    def get_mileage(self):
        """获取总里程数"""
        print("行车总里程:{}公里".format(self.mileage))
    
    def set_mileage(self,distance):
        """设置总里程数"""
        if distance >= 0:
            self.mileage = distance
        else:
            print("里程数不能为负!")
    def increment_mileage(self,distance):
        "总里程数累计"
        if distance >= 0:
            self.mileage += distance
        else:
            print("新增里程数不能为负!")


# 子类——新建一个电动汽车类
class ElectricCar(Car):
    """模拟电动汽车"""
    def __init__(self,brand,model,year):
        """初始化电动车属性"""
        super().__init__(brand,model,year)   # 声明继承父类的属性
        
    # 自动继承父类的所有方法

# 实例化
my_electric_car = ElectricCar("NextWeek","FF91",2046)
my_electric_car.get_main_information()

# 品牌:NextWeek,型号:FF91,出厂年份:2046
  • 给子类添加属性与方法
# 给子类添加属性与方法
class ElectricCar(Car):
    """模拟电动汽车"""
    def __init__(self,brand,model,year,bettery_size):
        """初始化电动车属性"""
        super().__init__(brand,model,year)    # 声明继承父类的属性
        self.bettery_size = bettery_size      # 电池容量
        self.electric_quantity = bettery_size # 电池剩余容量
        self.electric_distance_ratio = 5      # 电量换算距离公式-5公里/kw.h
        self.remainder_range = self.electric_quantity * 
                               self.electric_distance_ratio  # 剩余可行驶距离
        
    def get_electric_quantity(self):
        """查看当前容量"""
        print("当前电池剩余电量:{}kw.h".format(self.electric_quantity))
    
    def set_electric_quantity(self,electric_quantity):
        """设置电池剩余电量,重新计算电量可支撑行驶里程"""
        if electric_quantity > 0 and electric_quantity < self.bettery_size:
            self.electric_quantity = electric_quantity
            self.remainder_range = self.electric_quantity * 
                                              self.electric_distance_ratio
        else:
            print("电量未设置在合理范围内!")
    
    def get_remainder_range(self):
        """查看剩余可行驶里程"""
        print("当前电量还可以继续行驶{}公里".format(self.remainder_range))

# 实例化
my_electric_car = ElectricCar("NextWeek","FF91",2046,70)
my_electric_car.get_electric_quantity()
my_electric_car.get_remainder_range()
my_electric_car.set_electric_quantity(50)
my_electric_car.get_electric_quantity()
my_electric_car.get_remainder_range()

当前电池剩余电量:70kw.h
当前电量还可以继续行驶350公里
当前电池剩余电量:50kw.h
当前电量还可以继续行驶250公里
  • 重写父类的方法——多态
    在子类里将父类的方法进行重写,当对子类创建实例调用这个方法时,它会调用子类中的这个方法,父类中的方法不会执行。可以理解为当调用这个方法时,它首先到子类的方法中找,如果找得到,那就调用子类里的这个方法;如果找不到,它会到该子类继承的父类里找(子类会自动继承父类的所有方法)
    多态——即同样的方法,在不同的子类里面有了不同的表达方式。通俗点就是千人千面(强调不同)
# 重写父类的方法——多态
class ElectricCar(Car):
    """模拟电动汽车"""
    def __init__(self,brand,model,year,bettery_size):
        """初始化电动车属性"""
        super().__init__(brand,model,year)    # 声明继承父类的属性
        self.bettery_size = bettery_size      # 电池容量
        self.electric_quantity = bettery_size # 电池剩余容量
        self.electric_distance_ratio = 5      # 电量换算距离公式-5公里/kw.h
        self.remainder_range = self.electric_quantity * 
                              self.electric_distance_ratio  # 剩余可行驶距离
    
    def get_main_information(self):           # 重写父类方法
        """获取电动汽车的主要信息"""
        print("品牌:{}  型号:{}   出厂年份:{}    续航里程数:{}  公里"
              .
              format(self.brand,self.model,self.year,
              self.bettery_size*self.electric_distance_ratio))
    
    def get_electric_quantity(self):
        """查看当前容量"""
        print("当前电池剩余电量:{}kw.h".format(self.electric_quantity))
    
    def set_electric_quantity(self,electric_quantity):
        """设置电池剩余电量,重新计算电量可支撑行驶里程"""
        if electric_quantity > 0 and electric_quantity < self.bettery_size:
            self.electric_quantity = electric_quantity
            self.remainder_range = self.electric_quantity *
                                             self.electric_distance_ratio
        else:
            print("电量未设置在合理范围内!")
    
    def get_remainder_range(self):
        """查看剩余可行驶里程"""
        print("当前电量还可以继续行驶{}公里".format(self.remainder_range))

# 实例化
my_electric_car = ElectricCar("NextWeek","FF91",2046,70)
my_electric_car.get_main_information()

# 品牌:NextWeek  型号:FF91   出厂年份:2046    续航里程数:350  公里
  • 用在类中的实例
    电动汽车中的电池也是一个类,故我们可以把电池抽象成一个对象,然后在电车汽车类中调用电池的实例。
class Bettery():
    """模拟电动汽车的电池"""

    def __init__(self, bettery_size=70):
        self.bettery_size = bettery_size  # 电池容量
        self.electric_quantity = bettery_size  # 电池剩余容量
        self.electric_distance_ratio = 5  # 电量距离换算系数
        self.remainder_range = self.electric_quantity *
        					 self.electric_distance_ratio  # 剩余可行驶距离

    def get_electric_quantity(self):
        """查看当前容量"""
        print("当前电池剩余电量:{}kw.h".format(self.electric_quantity))

    def set_electric_quantity(self, electric_quantity):
        """设置电池剩余电量,重新计算电量可支撑行驶里程"""
        if electric_quantity > 0 and electric_quantity < self.bettery_size:
            self.electric_quantity = electric_quantity
            self.remainder_range = self.electric_quantity * 
            								self.electric_distance_ratio
        else:
            print("电量未设置在合理范围内!")

    def get_remainder_range(self):
        """查看剩余可行驶里程"""
        print("当前电量还可以继续行驶{}公里".format(self.remainder_range))


class Car():
    """模拟汽车"""

    def __init__(self, brand, model, year):
        """初始化汽车属性"""
        self.brand = brand  # 品牌
        self.model = model  # 型号
        self.year = year  # 出厂年份
        self.mileage = 0  # 里程碑数

    def get_main_information(self):  # self不能省
        """获取汽车主要信息"""
        print("品牌:{},型号:{},出厂年份:{}".format(self.brand, 
        										self.model, self.year))

    def get_all_mileage(self):
        """获取总里程数"""
        return "行车总里程:{}公里".format(self.mileage)


class ElectricCar(Car):
    """模拟电动汽车"""

    def __init__(self, brand, model, year, bettery_size):
        """初始化电动汽车属性"""
        super().__init__(brand, model, year)
        self.bettery = Bettery(bettery_size)  # 电池

    def get_main_information(self):  # 重写父类方法
        """获取电动车的主要信息"""
        print("品牌:{}  型号:{}  出厂年份:{}  续航里程数:{}公里"
              .format(self.brand, self.model, self.year,
                      self.bettery.bettery_size *
                       self.bettery.electric_distance_ratio))


my_electric_car = ElectricCar("NextWeek","FF91",2046,70)
# 获取车辆主要信息
my_electric_car.get_main_information()
# 获取当前电池量
my_electric_car.bettery.get_electric_quantity()
# 重设电量
my_electric_car.bettery.set_electric_quantity(50)
# 获取当前电量
my_electric_car.bettery.get_electric_quantity()
# 获取当前剩余可行驶里程数
my_electric_car.bettery.get_remainder_range()

# 品牌:NextWeek  型号:FF91  出厂年份:2046  续航里程数:350公里
# 当前电池剩余电量:70kw.h
# 当前电池剩余电量:50kw.h
# 当前电量还可以继续行驶250公里

未经允许不得转载:作者:1147-柳同学, 转载或复制请以 超链接形式 并注明出处 拜师资源博客
原文地址:《面向对象编程——1.初步了解》 发布于2020-12-21

分享到:
赞(0) 打赏

评论 抢沙发

评论前必须登录!

  注册



长按图片转发给朋友

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

微信扫一扫打赏

Vieu3.3主题
专业打造轻量级个人企业风格博客主题!专注于前端开发,全站响应式布局自适应模板。

登录

忘记密码 ?

您也可以使用第三方帐号快捷登录

Q Q 登 录
微 博 登 录