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()  # 類的派生類也不能訪問.

面向對象 重點代碼