Day08 - 面向对象和继承

1. 面向对象烤地瓜分析

'''
烤地瓜安全
'''


# 抽象一个地瓜类
# 实现 初始化方法，初始地瓜的状态 和总烧烤时间
# 添加 一个用来保存调料的容器属性
# 实现一个烧烤方法
	# 该 方法有一个烧烤时间，这个时间会被累计到总时间上
		# 判断总时间，来改变地瓜状态
		# 累加时间
		# 判断 时间来改变地瓜状态
		# 0~3表示还是生的，超过3表示半生不熟，超过5表示已经烤好了，超过8表示
# 添加一个加调料的方法
	# 将参数的调料保存起来就可以
    # 实现 __str__方法，定义地瓜对象的显示格式
# 测试

2. 向对象对烤地瓜实现

'''
烤地瓜安全
'''


# 抽象一个地瓜类
class SweetPotato(object):

    # 实现 初始化方法，初始地瓜的状态 和总烧烤时间
    def __init__(self):
        self.status = '生瓜蛋子'
        self.total_time = 0
        # 添加 一个用来保存调料的容器属性
        self.condiments = []

    # 实现一个烧烤方法
    # 该 方法有一个烧烤时间，这个时间会被累计到总时间上
    # 判断总时间，来改变地瓜状态
    def cook(self, t):
        # 累加时间
        self.total_time += t

        # 判断 时间来改变地瓜状态
        # 0~3表示还是生的，超过3表示半生不熟，超过5表示已经烤好了，超过8表示
        if self.total_time < 3:
            self.status = '还是个生瓜蛋子'
        elif self.total_time < 6:
            self.status = '半生不熟'
        elif self.total_time < 8:
            self.status = '刚刚好，烤的冒油'
        elif self.total_time < 10:
            self.status = '烤糊了'
        else:
            self.status = '烤成炭了，直接烧火吧'

    # 添加一个加调料的方法
    def addCondiments(self, tl):
        # 将参数的调料保存起来就可以
        self.condiments.append(tl)

    # 实现 __str__方法，定义地瓜对象的显示格式
    def __str__(self):
        s = self.status + f'被烤了 {self.total_time} 分钟'
        s += '地瓜使用了以下调料：\n'
        for i in self.condiments:
            s += (i + '\n')

        return s


# 测试
sp1 = SweetPotato()
print(sp1)

sp1.cook(2)
sp1.addCondiments('蜂蜜')
print(sp1)

sp1.cook(2)
sp1.addCondiments('老干妈')
print(sp1)

sp1.cook(2)
sp1.addCondiments('芥末油')
print(sp1)

sp1.cook(5)
print(sp1)

sp2 = SweetPotato()
print(sp2)

3. 类的复合（类中属性是对象）

在设计一个类时,类中包含其它类的对象,称为类的复合

人有一条狗
人想听狗叫

'''
类的复合
练习：
人想听狗叫
'''


# 经过分析，应该设计 两个类
# 一个人类，一个狗类

# 设计狗类
class Dog(object):
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def bark(self, n):
        for i in range(n):
            print('Won...')


# 设计一个人类
class Person(object):
    def __init__(self, name, age):
        self.name = name
        self.age = age

    # 为人添加一个拥有宠物方法
    def add_pet(self, pet):
        self.pet = pet

    # 人想听狗叫
    def listen_dog_bark(self, n):
        self.pet.bark(n)


# 测试
# 实例一个人类对象
tom = Person('Tom', 23)
# 为人的对象添加一条狗
tom.add_pet(Dog('glof', 1))

# 人调用 想听狗叫的方法
tom.listen_dog_bark(3)

jack = Person('jack', 22)
jack.listen_dog_bark(5)

4. 存放家具的案例

'''
类的复合练习
向房子中添加家具
'''


# 设计一个家具类
class Furniture(object):
    def __init__(self, name, area):
        self.name = name
        self.area = area

    def __str__(self):
        return f'{self.name} 占用了 {self.area} 平米'


# 设计一个房子类
class House(object):
    def __init__(self, address, area):
        self.address = address
        self.area = area
        self.free_area = self.area * 0.3
        # 定义一个用来保存家具的容器属性
        self.furnitures = []

    # 实现一个添加家具的方法
    def add_furniture(self, fur):
        # 先判断剩余 面积是否够添加 到房中
        if fur.area < self.free_area:
            self.furnitures.append(fur)
            self.free_area -= fur.area
            print(f'剩余空间还有 {self.free_area} 平米')
        else:
            print('空间不够，无法添加新家具')

    # 实现显示方法
    def __str__(self):
        s = f'我的大House 在{self.address} ,占地面积 {self.area} 平米\n'

        s += '家具如下：\n'
        # 遍历家具信息，拼接到房子信息后

        if len(self.furnitures) == 0:
            s += '还没有添加家具'
            return s
        else:
            for f in self.furnitures:
                s += (str(f) + '\n')

        return s


# 测试

home = House('长安街3号', 100)

# print(home)


# 　添加家具
bed1 = Furniture('双人床', 5)
home.add_furniture(bed1)
# print(home)

home.add_furniture(Furniture('单人床', 3))
home.add_furniture(Furniture('饭桌', 4))
home.add_furniture(Furniture('椅子1', 1))
home.add_furniture(Furniture('椅子2', 1))
home.add_furniture(Furniture('椅子3', 1))
home.add_furniture(Furniture('椅子4', 1))

home.add_furniture(Furniture('大衣柜', 10))
home.add_furniture(Furniture('书桌', 10))

print(home)

print(str(home) + 'hello')

print(str(bed1) + 'hahahaha\n')

5. 私有属性的定义和使用

在python抽象类时,默认定义的变量是公有的
公有的变量,可以通过对象在任何位置访问

# 类中公有属性一般不建议使用,破坏程序的封装性,在类的外部可以通过对象直接访问,
  对于数据来说,相对不安全

# 类中公有的方法的作用是为外部提供一种接口,通过这个接口可以来实现相应的交互操作

# 私有属性:
  因为公有属性的不安全,可以将属性设置成私有,私有属性只能在类的内部使用,而在类的外部是不可以使用的

'''
私有属性
'''

'''
java:
 public  公有
 private 私有
 protected 保护
 
python:
    定义属性时，没有任何修饰 的都 是公有的
    如果在属性或方法前，加两个下划线前缀，那么这个属性或方法，python 解释 器就认为是私有的
'''


class Account(object):
    def __init__(self, name, balance):
        # 定义了两个公有属性，这两个属性在类的外部也是可以访问的
        # self.name = name
        # self.balance = balance

        # 因为公有的属性破坏程序的封装性，导致数据不安全，所以将属性定义私有的
        # 当一个类中的属性或方法，全部是私有时，这个类是无意义 的
        self.__name = name
        self.__balance = balance

    # 私有属性定义好后，可以保证数据 的访问安全
    # 但是还有需求去属性进行访问，可以通过 公有接口方法进行间接 访问
    # 一般对私有属性会提供 一种 称为 存取器方法的 公有方法
    # set/ get方法
    # set_属性名  get_属性名

    # 因为帐户名一旦确认后无需修改，所以可以不提供 set 方法
    # def get_name(self):
    def get_username(self):
        return self.__name

    # 给余额提供 存取方法
    def set_balance(self, new_balance):
        if isinstance(new_balance, int):
            self.__balance = new_balance
        else:
            print('不能存玉皇大帝的钱')

    def get_balance(self):
        return self.__balance

    # 定义一个查看信息的方法
    def show_info(self):
        # # 在类的内部，访问对象的公有属性
        # print(self.name + ' 有 ',self.balance ,'元')

        # 在类的内部，访问对象的私有属性
        print(self.__name + ' 有 ', self.__balance, '元')


jack = Account('JackMa', 9999999)
# 在类的外部，访问对象的公有属性
# print(jack.name)
# print(jack.balance)
#
# jack.name = '郭'
# print(jack.name)
# print(jack.balance)

# 访问私有属性
# print(jack.__name)
# print(jack._Account__name)  # 只是让你了解私有的原理，但是不能这么使用

# 通过 接口方法来访问私有属性
print(jack.get_username())
print(jack.get_balance())

jack.set_balance(88888888)
print(jack.get_balance())
# jack.set_name('郭')
# print(jack._Account__username)

jack.set_balance('十个亿')
money = jack.get_balance()
print(money)
money -= 999999999
print(jack.get_balance())

# 私有方法
  将不想公开的实现数据和逻辑通过私有方法进行封装,可以隐藏关键代码.
  如果想使用私的方法功能时,可以在类的内部使用,或者在类的外部通过类中提供的公有方法来间接使用

'''
私有方法的使用
'''


class ThunderBird(object):

    # 实现一个初始方法，用来保存下载任务
    def __init__(self):
        self.__list = []

    # 实现一个公有的方法，用来添加任务
    def add_task(self, url):
        self.__list.append(url)
        # 在类的内部，直接 访问私有方法
        self.__download_data(url)

    # 核心代码 ，用来下载数据的算法
    def __download_data(self, url):
        print(f'通过地址 {url} 下载数据中。。。。')


# 测试
tb = ThunderBird()
# 通过一个公有方法，间接 访问的了对象的私有方法，下载数据
tb.add_task('http://www.dytt88.net/复联4.mp4')

# 私有方法在类的外部是不能拼接访问的。
# tb.__downoad_data('http://www.dytt88.net/复联4.mp4')

6. 私有属性的优点

set/get方法对私有属性操作时的好处:
1. 提供精确的访问控制权限
2. 隐藏实现细节,让代码更安全
3. 可以提供更加安全的数据有效性控制 

7. 继承概述

程序中的继承,遵循生活的继承方式
被继承的类: 父类, 超类, 基类
衍生出的类: 子类, 派生类

新式类中:所有的类,都直接或间接继承 object 类

object 类是所有类的父类

在继承时,子类拥有父类的所有的内容

继承的作用:
	复用代码

8. 继承的格式

class 子类名(父类名):
	pass

在出现继承后
当子类对象去调用方法时,会先在子类中去查找 方法,如果有,那么就执行,如果没有找到,去到父类中去查找 该方法,如果找到执行
找不到再到上一级类中去查找 直到找到object类,如果还没有那么就报错

'''
继承的实现
'''


# 定义一个父类
class Phone(object):

    def __init__(self):
        self.name = '电话'

    # 定义一个打电话的方法

    def call(self, number):
        print(f'正在给 {number} 打电话')


# 定义一个子类
class iPhone(Phone):

    # 添加一个拍照方法
    def carmera(self):
        print('正在拍照')


# 当发生继承后，子类会继承父类中的属性和方法，可以直接 使用

iphonex = iPhone()
iphonex.call('13800138000')
iphonex.carmera()
print(iphonex.name)

dgd = Phone()
dgd.call('13800138000')
print(dgd.name)
# dgd.carmera()

9. 子类使用继承父类的属性和方法

# 当发生继承后，子类会继承父类中的属性和方法，可以直接 使用

10. 子类不能继承父类的私有属性和私有方法

'''
子类不能直接使用父类的私有属性和方法
'''


class Father(object):
    def __init__(self):
        self.__money = 999
        self.name = 'tom'

    def __show(self):
        print('这个是父类中的一个私有方法')

    def display(self):
        print('这是一个父类中的公有方法')
        self.__show()


# 定义一个子类
class Son(Father):
    # 定义一个自己的方法
    def play(self):
        print('这是子类中玩的方法')
        # 在子类中不能直接使用父类中的私有方法
        # self.__show()
        # 通过继承得到的父类的公有方法，间接 执行父类的私有方法
        self.display()


# 测试

s = Son()
s.play()
s.display()
# s.__show()