面向对象 重点代码

Posted 2021-01-19 pxxandfdd

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()  # 类的派生类也不能访问.