面向对象 重点代码

Posted pxxandfdd

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了面向对象 重点代码相关的知识,希望对你有一定的参考价值。

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

 





































































































































































































































































以上是关于面向对象 重点代码的主要内容,如果未能解决你的问题,请参考以下文章

关于Java中面向对象章节IO 流中的重点基础知识。

面向对象的继承

Python——面向对象重点笔记!!

软考重点8 面向对象及数据库

面向对象案例0428

IT黑马-面向对象