1，这是个 输出顺序的题目
版本一
class Parent:
# def func(self):
# print('in Parent func')
#
# def __init__(self):
# self.func()
#
# class Son(Parent):
# def func(self):
# print('in Son func')
#
# son1 = Son() #in Son func
版本二
class Parent:
def __func(self):
print('in Parent func')
def __init__(self):
self.__func()
class Son(Parent):
def __func(self):
print('in Son func')
son1 = Son() #in Parent func'
2，组合思想的题目
1，暴力摩托程序（完成下列需求）：
# 1.1
# 创建三个游戏人物，分别是：
# • 苍井井，女，18，攻击力ad为20，血量200
# • 东尼木木，男，20，攻击力ad为30，血量150
# • 波多多，女，19，攻击力ad为50，血量80
# 1.2
# 创建三个游戏武器，分别是：
# • 平底锅，ad为20
# • 斧子，ad为50
# • 双节棍，ad为65
#
# 1.3
# 创建三个游戏摩托车，分别是：
#
# • 小踏板，速度60迈
# • 雅马哈，速度80迈
# • 宝马，速度120迈。
#
# 完成下列需求（利用武器打人掉的血量为武器的ad + 人的ad）：
# （1）苍井井骑着小踏板开着60迈的车行驶在赛道上。
# （2）东尼木木骑着宝马开着120迈的车行驶在赛道上。
# （3）波多多骑着雅马哈开着80迈的车行驶在赛道上。
# （4）苍井井赤手空拳打了波多多20滴血，波多多还剩xx血。
# （5）东尼木木赤手空拳打了波多多30滴血，波多多还剩xx血。
# （6）波多多利用平底锅打了苍井井一平底锅，苍井井还剩xx血。
# （7）波多多利用斧子打了东尼木木一斧子，东尼木木还剩xx血。
# （8）苍井井骑着宝马打了骑着小踏板的东尼木木一双节棍，东尼木木哭了，还剩xx血。
# （9）波多多骑着小踏板打了骑着雅马哈的东尼木木一斧子，东尼木木哭了，还剩xx血。
class Game():
def __init__(self, name, sex, age, ad, hp):
self.name = name
self.sex = sex
self.age = age
self.ad = ad
self.hp = hp
def attack(self, p):
p.hp = p.hp - self.ad
print("%s赤手空拳打了%s%s滴血，波多多还剩%s血。" % (self.name, p.name,self.ad, p.hp)) \
# def add_moto(self,mo):
# self.mo = mo
#
# def add_weapon(self,wea):
# self.wea = wea
#
# def road_rush(self,p1):
# p1.hp = p1.hp - self.ad - self.wea.ad
# print('%s骑着%s打了骑着%s的%s一%s，%s哭了，还剩%s血' \
# %(self.name,self.mo.name,p1.mo.name,p1.name,self.wea.name,p1.name,p1.hp))
def add_mot(self, mo):
self.mo = mo
def add_weapon(self, wea):
self.wea = wea
def road_rush(self,p1):
p1.hp = p1.hp - self.ad - self.wea.ad
print("%s骑着%s打了骑着%s的%s一%s，%s哭了，还剩%s血" \
% (self.name, self.mo.name, p1.mo.name, p1.name, self.wea.name, p1.name, p1.hp)
)
class Weapon:
def __init__(self, name, ad):
self.name = name
self.ad = ad
def fight(self, p1, p2):
p2.hp = p2.hp - (p1.ad + self.ad)
print("%s利用%s打了%s一%s，%s还剩%s血。" % (p1.name, self.name, p2.name, self.name, p2.name, p2.hp))
class Moto:
def __init__(self, name, speed):
self.name = name
self.speed = speed
def drive(self, p1):
print("%s骑着%s开着%s迈的车行驶在赛道上。"%(p1.name,self.name,self.speed))
p1 = Game('苍井井','女',18,20,200)
p2 = Game('东尼木木','男',20,30,150)
p3 = Game('波多多','女',19,50,80)
w1 = Weapon('平底锅',20)
w2 = Weapon('斧子',50)
w3 = Weapon('双节棍',65)
m1 = Moto('小踏板',60)
m2 = Moto('雅马哈',80)
m3 = Moto('宝马',120)
#m1.drive(p1)不是 组合的思想
p1.add_mot(m1) # 组合: 给p1 对象封装了一个属性,属性值 m1这个对象
p1.mo.drive(p1)
print(p1.mo) #两个是一个地址
print(m1)
p1.attack(p3)
#波多多利用平底锅打了苍井井一平底锅，苍井井还剩xx血。
p3.add_weapon(w1) # 组合: 给p1 对象封装了一个属性,属性值 w1这个对象
p3.wea.fight(p3,p1)
#苍井井骑着宝马打了骑着小踏板的东尼木木一双节棍，东尼木木哭了，还剩xx血。p1.add_mot(m3)p1.add_weapon(w3)p2.add_mot(m1)p1.road_rush(p2)
3，面试题
class A:
# name='alxa'
name = []
p1 = A()
p2 = A()
p1.name.append(1)
# p1.age = 12
# p1.age，p2.age，A.age 分别又是什么？为什么？ p1 12, p2 和 A都报错 因为不存在age object
# print(p1.age)
# print(p2.age)
# print(A.age)
# p1.name，p2.name，A.name 分别是什么？ 都是 【1】 这是 个面试题因为空间内的列表可变
print(p1.name)
print(p2.name)
print(A.name)
4，接口类笔记代码 记得看
from abc import ABCMeta,abstractmethod
class Payment(metaclass=ABCMeta): # 抽象类(接口类):
@abstractmethod #这是一个装饰器 一个方法加一个 这都是模板 没多大意义
def pay(self): pass # 制定了一个规范
@abstractmethod
def func(self):pass
class Alipay(Payment):
def __init__(self,money):
self.money = money
def pay(self):
print('使用支付宝支付了%s' %self.money)
class Jdpay(Payment):
def __init__(self, money):
self.money = money
def pay(self):
print('使用京东支付了%s' % self.money)
class pay(Payment):
def __init__(self,money):
self.money = money
def pay(self):
print('使用微信支付了%s' % self.money)
def pay(obj):
obj.pay()
w1 = pay(200)
a1 = Alipay(200)
j1 = Jdpay(100)
pay(a1) # 归一化设计
pay(j1)
w1 = pay(300)
#w1.weixinpay() #这样不对 必须是统一模板
5，封装初试
class B:
__money = 100000
class A(B):
name = 'alex'
__age = 1000
def func(self):
print(self.__age)
print(A.__age) # 对于私有静态字段,类的内部可以访问.
print('func....')
def func1(self):
print(self.__money)
print(A.__money)
a1 = A()
print(a1.name)
print(A.name)
print(a1.__age) # 实例化对象不能访问私有静态字段
print(A.__age) # 类名不能访问私有静态字段
对于私有静态字段,类的外部不能访问.
a1.func()
对于私有静态字段,类的内部可以访问.
a1.func1()
对于私有静态字段来说,只能在本类中内部访问,类的外部,派生类(子类)均不可访问.
可以访问,但是工作中千万不要用.
print(A._A__age)
print(A.__dict__)
私有方法
class B:
__money = 100000
def __f1(self):
print('B')
class A(B):
name = 'alex'
def __func(self):
print('func....')
def func1(self):
# self.__func() # 类的内部可以访问
self.__f1()
a1 = A()
a1.__func() # 类外部不能访问
a1.func1() # 类的内部可以访问
a1.func1() # 类的派生类也不能访问.
