面向对像(2day)

http://www.cnblogs.com/post/readauth?url=/linhaifeng/articles/6182264.html

上节课复习

class Garen:        #定义英雄盖伦的类,不同的玩家可以用它实例出自己英雄;
    camp=‘Demacia‘  #所有玩家的英雄(盖伦)的阵营都是Demacia;
    n=0
    # hobby=[]
    def __init__(self,nickname,aggressivity=58,life_value=455): #英雄的初始攻击力58...;
        self.nickname=nickname  #为自己的盖伦起个别名;
        self.aggressivity=aggressivity #英雄都有自己的攻击力;
        self.life_value=life_value #英雄都有自己的生命值;
        Garen.n+=1
        self.hobby=[]
    def attack(self,enemy):   #普通攻击技能,enemy是敌人;
        enemy.life_value-=self.aggressivity #根据自己的攻击力,攻击敌人就减掉敌人的生命值。

# g1 = Garen(‘草丛伦‘)
# g2 = Garen(‘草丛伦2‘)
# g3 = Garen(‘草丛伦3‘)
# print(g1.hobby,id(g1.hobby))
# print(g2.hobby,id(g2.hobby))
# print(g3.hobby,id(g3.hobby))
# #
# # # g1.camp=‘123123123123‘
# g1.hobby.append(‘g1 hobby‘)
# g2.hobby.append(‘g2 hobby‘)
# g3.hobby.append(‘g3 hobby‘)
# print(g1.hobby)

#类的两种用法:实例化和属性引用
#一:实例化
# g1 = Garen(‘草丛伦‘)
# print(g1.__dict__)

#二:属性引用,类的属性就两种:变量和函数
# print(Garen.camp)
# print(Garen.xxxx)
# print(Garen.attack123)
# print(Garen.__dict__)
# print(Garen.camp)
# print(Garen.attack) #‘attack‘
#
# Garen.camp=‘123123123123123‘
# Garen.x=123  #Garen.__dict__[‘x‘]=123
# print(Garen.__dict__)

# Garen.x=1
# print(Garen.__dict__)

# del Garen.camp
# print(Garen.__dict__)

#实例就一种用法:属性引用,且实例本身就只有
# g1 = Garen(‘草丛伦‘)
# print(g1.nickname)
# print(g1.aggressivity)
# print(g1.life_value)
#增,删,改,查实例属性,略

#类的名称空间与实例的名称空间

#类的变量是所有对象共享的
class Garen:        #定义英雄盖伦的类,不同的玩家可以用它实例出自己英雄;
    camp=‘Demacia‘  #所有玩家的英雄(盖伦)的阵营都是Demacia;
    n=0
    # hobby=[]
    def __init__(self,nickname,aggressivity=58,life_value=455): #英雄的初始攻击力58...;
        self.nickname=nickname  #为自己的盖伦起个别名;
        self.aggressivity=aggressivity #英雄都有自己的攻击力;
        self.life_value=life_value #英雄都有自己的生命值;
        Garen.n+=1
        self.hobby=[]
    def attack(self,enemy):   #普通攻击技能,enemy是敌人;
        enemy.life_value-=self.aggressivity #根据自己的攻击力,攻击敌人就减掉敌人的生命值。

# g1 = Garen(‘草丛伦‘)
# g2 = Garen(‘草丛伦2‘)
# g3 = Garen(‘草丛伦3‘)

# # print(g1.camp)
# # print(g2.camp)
# # Garen.camp=123
# # print(g3.camp)
# # print(g1.camp)
# # print(g2.camp)

# print(g1.hobby,id(g1.hobby))
# print(g2.hobby,id(g2.hobby))
# print(g3.hobby,id(g3.hobby))
# #
# # # g1.camp=‘123123123123‘
# g1.hobby.append(‘g1 hobby‘)
# g2.hobby.append(‘g2 hobby‘)
# g3.hobby.append(‘g3 hobby‘)
# print(g1.hobby)

# # g1.camp=‘123123123123‘
# # print(g1.camp)
# # print(g2.camp)
# # print(g3.camp)
#
# # print(g1.__dict__)
# print(g1.n)
# print(g3.n)
# print(Garen.n)

#类的函数是绑定到每个对象的,每个对象绑定方法都是不一样的,但都是同一种功能

class Garen:        #定义英雄盖伦的类,不同的玩家可以用它实例出自己英雄;
    camp=‘Demacia‘  #所有玩家的英雄(盖伦)的阵营都是Demacia;
    n=0
    # hobby=[]
    def __init__(self,nickname,aggressivity=58,life_value=455): #英雄的初始攻击力58...;
        self.nickname=nickname  #为自己的盖伦起个别名;
        self.aggressivity=aggressivity #英雄都有自己的攻击力;
        self.life_value=life_value #英雄都有自己的生命值;
        Garen.n+=1
        self.hobby=[]
    def attack(self,enemy):   #普通攻击技能,enemy是敌人;
        print(‘=====>‘,self)
        print(‘=====>‘,enemy)
        # enemy.life_value-=self.aggressivity #根据自己的攻击力,攻击敌人就减掉敌人的生命值。

g1 = Garen(‘草丛伦‘)
# print(g1.attack)
# print(Garen.attack)

# g1.attack(g1) #Garen.attack(g1,g1)
#

继承类

时间: 2024-11-10 10:35:54

面向对像(2day)的相关文章

简说面向过程与面向对象

昨天白天,因为在室外活动,无事可做,所以我思考了一天,在想怎么才能比较清晰的向人解释这两个概念.所以我对这两个概念的字面意思做了一下详细的解释.没想到,这可能真的会帮助我们非常简单的理解这两个概念. 面向:从字面上理解面向,就是我们的脸对着的地方,引申为我们能看到. 过程: 过程是事物从开始,到发展,到结束的整个经历 那么面向过程就是:我们能看到, 一个事物从 开始->发展->结束. 这对于我们写程序的人来说,可能会有感触,因为一开始我们写程序时.都是按照事件的发展.去安排计算机,一步一步的做

Spring AOP(面向切面示例)

什么是AOP?基本概念切面(aspect):横切关注点被模块化的特殊对象.通知(advice):切面必须要完成的工作.切面中的每个方向称之为通知.通知是在切面对象中的.目标(target):被通知的对象.代理(proxy):向目标对象应用通知后创建的对象. 连接点(joinpoint):目标对象的程序执行的某个特定位置.如某个方法调用前,调用后的位置.包括两个信息:1.目标程序的哪个方法?2.方法执行 前还是执行后?切点(pointcut):每个类会有多个连接点,AOP通过切点定位到特定的边接点

面向数据可靠性存储系统设计思想探讨

存储系统的设计门槛是比较高的,和计算系统存在的最大区别在于存储系统所承载的是数据,一旦系统出现故障,不仅业务的连续性得不到保障,更为重要的是用户数据将会造成丢失.计算节点发生故障,最多造成业务连续性中断,这是与存储系统相比在可靠性要求方面最大的区别. 十几年前刚刚接触存储系统的研发,当时没有觉得存储有多复杂,不就是把数据按照一定规则存放在磁盘中,并且实现一定的功能,例如数据保护RAID.数据复制Replication.数据快照Snapshot以及文件系统嘛.感觉存储系统中最复杂的是各种功能,设计

【第二周作业】面向过程(或者叫结构化)分析方法与面向对象分析方法到底区别在哪里?

书上的一些概念这里不再复述,仅谈谈自己通过阅读教材.上课听讲后自己的一些理解: 面向过程分析方法注重自顶向下,逐层分析,把整个软件系统的功能逐布分解,各个击破.可以用生活中的一个例子来加以理解——去食堂吃饭.到达食堂(比如琴湖食堂)后,要遵从排队——打饭——阿姨打菜——拿筷子——找位子坐好——开吃,整个过程强调顺序性,比如不拿筷子就坐下是不行的,除非拿手抓.面向过程就是将软件系统所需要实现的功能按照以上类似的思路逐步细分,一步一步要做什么都要分析清楚. 面向对象分析方法则注重分析整个系统的逻辑结

Spring面向切面编程

  1.面向切面编程(AOP)的概念:把项目中需要在多处用到的功能,比如日志.安全和事物等集中到一个类中处理,而不用在每个需要用到该功能的地方显式调用.   2.术语解释:        横切关注点:分布应用于多处的功能        切面:横切关注点可以被模块化为一个类,这个类被称为一个切面        通知(advice):切面要完成的工作.Spring的通知有5种类型:before.after.after-returning.after-throwing和around这五种类型.    

面向切面编程(转)

面向切面编程(AOP是Aspect Oriented Program的首字母缩写) ,我们知道,面向对象的特点是继承.多态和封装.而封装就要求将功能分散到不同的对象中去,这在软件设计中往往称为职责分配.实际上也就是说,让不同的类设计不同的方法.这样代码就分散到一个个的类中去了.这样做的好处是降低了代码的复杂程度,使类可重用.       但是人们也发现,在分散代码的同时,也增加了代码的重复性.什么意思呢?比如说,我们在两个类中,可能都需要在每个方法中做日志.按面向对象的设计方法,我们就必须在两个

面向过程与面向对象的区别-遁地龙卷风

下面例子根据C和Java编写 面向过程与面向对象之间的区别在于认知世界的方式,后者在前者的基础上提供了更高的抽象层次-类. 也就是抽象.封装.继承.多态. 举个例子 输出 小明20岁<=>A,小明打篮球<=>B. 面向过程相当于在类中调用main方法输出A.B public class Test { public static void main( String[] args ) { System.out.println( "小明去上学" ); System.o

Spring AOP 面向切面编程

AOP 在软件业,AOP为Aspect Oriented Programming的缩写,意为:面向切面编程,通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术.AOP是OOP的延续,是软件开发中的一个热点,也是Spring框架中的一个重要内容,是函数式编程的一种衍生范型.利用AOP可以对业务逻辑的各个部分进行隔离,从而使得业务逻辑各部分之间的耦合度降低,提高程序的可重用性,同时提高了开发的效率. 在Spring中提供了面向切面编程的丰富支持,允许通过分离应用的业务逻辑与系统级服务(例

面向服务的体系架构(SOA)—架构篇

面向服务的体系架构(SOA)-架构篇 1.面向服务的体系架构(SOA) 面向服务的架构(service-oriented architecture)是Gartner于2O世纪9O年代中期提出的面向服务架构的概念.2002年的l2月,Gartner提出"面向服务的架构(SOA)"是"现代应用开发领域最重要的课题"之后.国内外计算机专家.学者掀起了对SOA的积极研究与探索. 在分布式的环境中,将各种功能都以服务的形式提供给最终用户或者其他服务.如今,企业级应用的开发都采