# 面向对象编程
# 思想 ：角色的抽象,创建类，创建角色（实例化），操作这些实例
# 面向对象的关键字
# class 类名:
# 静态属性 = 'aaa'
# def __init__(self):pass
#
# 类名.静态属性 #—— 存储在类的命名空间里
# 对象 = 类名() # 实例化：创造了一个self对象，执行init方法，返回self对象给外部
# 对象.属性
# 对象.方法 # 类名.方法(对象)
# 对象可以使用静态变量？ True
# 类可以使用对象里的属性么？ False
# 组合
# 一个类的对象是另外一个类对象的属性
# 什么有什么的关系
# class A:
# def __init__(self):
# self.name = 'egon'
#
# class B:
# def __init__(self,year,month,day):
# self.year = year
# self.month = month
# self.day = day
#
# b = B(18,1,17)
# a = A()
# a.birth = b
# b.year
# a.birthclass A:
# def __init__(self):
# self.name = 'egon'
#
# class B:
# def __init__(self,year,month,day):
# self.year = year
# self.month = month
# self.day = day
#
# b = B(18,1,17)
# a = A()
# a.birth = b
# b.year
# a.birth
# class A(object):pass # 父类，基类，超类
# class B:pass # 父类，基类，超类
# class A_son(A,B):pass # 子类，派生类
# class AB_son(A):pass # 子类，派生类
# 一个类 可以被多个类继承
# 一个类 可以继承多个父类 —— python里
# print(A_son.__bases__)
# print(AB_son.__bases__)
# print(A.__bases__) # python3 -新式类# 没有继承父类默认继承object
class Animal:
def __init__(self,name,aggr,hp):
self.name = name
self.aggr = aggr
self.hp = hp
self.func()
def func(self):
print(123)
#
class Dog(Animal):
def func(self):
print(456)
def bite(self,person):
person.hp -= self.aggr
d = Dog()
# class Person(Animal):
# pass
#
# jin = Dog('金老板',200,500)
# print(jin.name)
# 狗类 吃 喝 看门(guard)
# 鸟类 吃 喝 下蛋(lay)
# class Animal:
# def __init__(self):
# print('执行Animal.__init__')
# self.func()
# def eat(self):
# print('%s eating'%self.name)
# def drink(self):
# print('%s drinking'%self.name)
# def func(self):
# print('Animal.func')
#
# class Dog(Animal):
# def guard(self):
# print('guarding')
# def func(self):
# print('Dog.func')
# dog = Dog()
# class Bird(Animal):
# def __init__(self,name):
# self.name = name
# def lay(self):
# print('laying')
# dog.drink()
# bird.drink()
# dog.guard()
# bird.lay()
# class Animal:
# def __init__(self,name,aggr,hp):
# self.name = name
# self.aggr = aggr
# self.hp = hp
#
# def eat(self):
# print('吃药回血')
# self.hp+=100
#
# class Dog(Animal):
# def __init__(self,name,aggr,hp,kind):
# Animal.__init__(self,name,aggr,hp) #
# self.kind = kind # 派生属性
# def eat(self):
# Animal.eat(self) # 如果既想实现新的功能也想使用父类原本的功能，还需要在子类中再调用父类
# self.teeth = 2
# def bite(self,person): # 派生方法
# person.hp -= self.aggr
#
# jin = Dog('金老板',100,500,'吉娃娃')
# jin.eat()
# print(jin.hp)
# class Person(Animal):
# def __init__(self,name,aggr,hp,sex):
# Animal.__init__(self,name,aggr,hp)
# self.sex = sex # 派生属性
# self.money = 0 # 派生属性
#
# def attack(self,dog):
# dog.hp -= self.aggr
#
# def get_weapon(self,weapon):
# if self.money >= weapon.price:
# self.money -= weapon.price
# self.weapon = weapon
# self.aggr += weapon.aggr
# else:
# print("余额不足，请先充值")
# # alex = Person('alex',1,2,None)
# # alex.eat()
# # print(alex.hp)
# #
# # jin.bite(alex)
# # print(alex.hp)
#
#
# 父类中没有的属性 在子类中出现 叫做派生属性
# 父类中没有的方法 在子类中出现 叫做派生方法
# 只要是子类的对象调用，子类中有的名字 一定用子类的，子类中没有才找父类的，如果父类也没有报错
# 如果父类 子类都有 用子类的
# 如果还想用父类的，单独调用父类的:
# 父类名.方法名 需要自己传self参数
# super().方法名 不需要自己传self
# 正常的代码中 单继承 === 减少了代码的重复
# 继承表达的是一种 子类是父类的关系
class Animal:
def __init__(self,name,aggr,hp):
self.name = name
self.aggr = aggr
self.hp = hp
def eat(self):
print('吃药回血')
self.hp+=100
class Dog(Animal):
def __init__(self,name,aggr,hp,kind):
super().__init__(name,aggr,hp) # 只在新式类中有，python3中所有类都是新式类
self.kind = kind # 派生属性
def eat(self):print('dog eating')
# jin = Dog('金老板',200,500,'teddy')
# print(jin.name)
# jin.eat()
# super(Dog,jin).eat()
#
# coding:utf-8
# class F:
# def func(self): print('F')
# class A(F):pass
# # def func(self): print('A')
# class B(A):
# pass
# # def func(self): print('B')
# class E(F):pass
# # def func(self): print('E')
# class C(E):
# pass
# # def func(self): print('C')
#
# class D(B,C):
# pass
# # def func(self):print('D')
#
# d = D()
# # d.func()
# print(D.mro())
# 新式类中的继承顺序 ： 广度优先
class A(object):
def func(self): print('A')
class B(A):
def func(self):
super().func()
print('B')
class C(A):
def func(self):
super().func()
print('C')
class D(B,C):
def func(self):
super().func()
print('D')
b = D()
b.func()
print(B.mro())
#2.7
# 新式类 继承object类的才是新式类 广度优先
# 经典类 如果你直接创建一个类在2.7中就是经典类 深度优先
# print(D.mro())
# D.mro()
# 单继承 ： 子类有的用子类 子类没有用父类
# 多继承中，我们子类的对象调用一个方法，默认是就近原则，找的顺序是什么？
# 经典类中 深度优先
# 新式类中 广度优先
# python2.7 新式类和经典类共存，新式类要继承object
# python3 只有新式类，默认继承object
# 经典类和新式类还有一个区别 mro方法只在新式类中存在
# super 只在python3中存在
# super的本质 ：不是单纯找父类 而是根据调用者的节点位置的广度优先顺序来的
# 继续写作业 ：
# 学生管理系统 登录，识别身份 进阶 ： 不同视图不同的菜单
