齐达内个人资料

齐达内个人资料（精选6篇）

齐达内个人资料 篇1

齐达内

姓名：齐达内（zinedine zidane）

出生日： 1972年6月23日

身高：1.85米

体重：80公斤

出生地：马赛

现效力球队：皇家马德里（西班牙）

位置： 中场

1994年8月17日: 对捷克（2-2平）作为法国足坛的超级巨星，齐达内是勒梅尔世界杯计划的关键。这位现世界年度足球先生是世界上最好的中场组织者之一，而他这个赛季在意甲巨人尤文图斯的表现也是有目共睹的;

: 他协助波尔多闯进欧洲联盟杯决赛，并从此受到了欧洲足坛的关注;

19: 欧洲杯上表现不俗，率队冲进半决赛，但不幸在点球大战中不敌捷克;

/97和/98赛季: 齐达内是尤文图斯连续夺得联赛冠军的主要功臣;

世界杯: 他在对抗劲旅巴西的决赛中2次头球破门，带队3-0完胜对手.

达内生产实习总结 篇2

一直以来我们专业的生产实习就是在校内，而今年我们终于有机会在校外实习了。去IT培训学校实习两周，对于我这种酷爱计算机的人是多么好的体验机会。作为数学类专业的学生，如果一味的学习理论，不能去实践理论，那是多么悲哀呀。当得知有这样的机会时，很多同学都积极参加了。就这样，大家带着新鲜好奇、实践理论的心情离开学校来到了达内实习了。

实习的第一天，有老师就带领我们熟悉了将要使用的操作系统——LINUX操作系统，这个系统以前我根本没有接触过，当时就想只有好好学了。老师介绍了在终端的许多操作，并且将连接主机的方式以及一些在终端上的简单操作等等告诉我们，大概因为是新知识，所以很多同学都不断练习以达到熟练。实习的第一天我们花了很多时间在熟练基础上，说实话真的有些累，但是，了事谈到说，作为IT工作的人比我们更辛苦，我忽然觉得自己在达内的实习很充实。我总想，我们要成功就一定要别人更努力。

实习的第二天，我们见到了接下来给我们上课的老师，他是项目经理，据说他带的班和学生是基地里最多的。经理常说，要学好计算机，好的代码你要敲上300遍。他的同学在百度上班，那个我们最熟悉的百度首页他同学就敲过几百遍，才有现在的完美首页。听了经理的介绍，忽然觉得自己在学校敲的代码次数太少了，在接下来的日子了，我会每天都对前一天的项目代码多敲几遍。

一个行业你要喜欢它，也会喜欢它的文化，经理上课的第一天就讲了IT行业的发展史。IT行业分别经历了PC机时代、软件时代、互联网时代和移动终端时代，到今天已经是大数据时代了。当然，最为IT人知晓的代码“Hello World”，这一语句可是很多IT家的墓志铭。在我们的很多教材里，第一个程序代码就是输出“Hello World”。

在之后的一些天里，我们开始学习六个项目，它们分别是：满天星、水底世界、弹跳板、雷电游戏、斗地主。暴力五子棋。

学习开始，我们跟着老师一步一步往下走，跟着在键盘上忙碌的敲代码、调整程序。邓经理讲课很细心，思维新颖逻辑严谨罗列着他所要讲的内容，娴熟的敲打他已积累如山的代码，还时不时的讲讲笑话和他的一些事情，当没听懂需再讲一遍时，他还是笑迎喜面的再讲一遍，同学们都很喜欢邓老师，我也是如此。每次做项目前，项目经理就会先做项目驱动，把我们所以做出的项目展示，并且讲解它的一些来由。比如项目“满天星”，美丽的星空是一位编程的男生送给心爱的女友的，他为她摘天上的“漫天星”。在满天星下，项目经理还要求下大家自己动手设计出自己不一样的星空下的“小村庄”。要知道IT对于我最大的吸引力就在于此，我可以有自己独特的想法去完成一项任务。我用各种不同画出草坪、房屋、花朵。。。每一座房屋都是自己拼出来的（因为所学知识有限）。作品大家做好后就可以上传到老师那里展示了，看到自己的成果大家评价高，那是多么令人兴奋的事。

每天都是这样，老师认真的讲着，我认真的听着，一个星期以来，老师介绍了几个项目，每个项目的驱动都特别有意义。接下来对于老师所讲的项目更是感兴趣，对于与邓老师在一起的时间我更是倍感珍惜，在计算机领域中，是心灵的一种进化，也是心灵的一种提升。

达内实习的时候，我们不仅仅学的是项目本身，我们很多有趣的知识。比如经典游戏的内涵，以及扑克牌数目的各种含义等等。当然，想要做成功一个项目必须先了解它的需求分析。为了能让大家能明白项目开发的过程，经理会把项目所涉及的计算机语言知识先讲解，然后再带领大家一步一步完成项目。当大家按着经理的指导敲出一个又一个不一样的实物和动感时，那种喜悦，那种成功的感觉是只一味读书所没有的。最令大家有成功感的，不仅仅如此。为了能让大家熟悉每天的新知识，经理会给我们布置作业，那就是在简单程序的基础上运用自己的想法敲出完整的项目或者结合自己的想法敲出不一样的项目。

实习快要结束的时候，我们接到新的任务，那就是在LINUX操作系统上完成个人的实

训总结ppt，我很喜欢达内，在这里，环境优良，为我们每人准备了一台电脑，天气热，为我们安了空调，怕我们上火，哈哈，老师在上课期间怕影响我们上课静静的为我们倒水，严厉之中透漏着温柔，呵斥之中透漏着关怀。

在这里，我不是一个人而是家庭中的一员，和同学一起上下课，下了课一起打打闹闹的去吃饭，在业余时间还和老师聊聊天，或许这对于别人来说，这是人生中当学生时代最平常不过的事了，可对于我真的很珍贵，我很开心，我现在发现我也不是一个真的很喜欢独处的人，不能彻底的改变，但事实却在改变。

实习时间慢慢的在减少，而程序却相反——越来越难，越来越繁。因为一个小环节与大家拉开了距离，在一个庞大的项目中是不允许任何一处掉链子的。看到同学们早已“轻车熟路”操作自如了，而我却不知所措，立刻就有了压力。一天下来感受最深的就是那种巨大的差距。学校所学与实际应用中的脱节

在达内为期两周的实习时间已悄然离去，刚来时的那种新鲜好奇早飞到了九霄云外，更多的是离开时的那种不舍和对自己及所学的反思。

通过实际项目的开发我有以下几点收获：

1.多向老师、同学虚心请教，也别说自己学的不怎么样，不然会大大减少自己的自信，从而与大家的差距越来越大。

2.编程以前一定要对整个项目有仔细的了解，最好能写好需求分析，这样在实际操作时就会更加调理，而且不会遗漏东西。

3.做任何项目都离不开团队合作。所以我们一定要注意团队合作意识，多和小组内的人交流。

4.在编程中一定要规范，绝对不可以随性

达内学习总结 篇3

1.四个月时间不长，所以要认真听课，是对自己负责任同时也是尊重老师，严格要求自己。

2.认真跟随老师敲代码，代码就是靠孰能生巧，写的代码多了自然就能融会贯通，所谓以小见大，慢慢就会窥视整个架构。

3.俗话说勤能补拙，勤奋总是有好处的。比别人多学一点点，4个月下来就可以在以后的面试中工作中占很大优势，底气自然就足点。

4.不要死学习，适当的和同学们交流，很大程度上可以查漏补缺。因为工作中总是要和别人交流分工合作的，以别人的长处来弥补自己的短处，这样才能让工作更加的完美，理解团队的重要性。

5.学习是一个长期的事情，不要想着一口气吃个大胖子，这样是不行的。遇到问题不要气馁，想办法去解决，自己实在不行就请教下同学或者老师，今日事今日毕，力争当日解决问题，以免夜长梦多。

达内实习报告 孔龙 - 副本 篇4

实习题目： JAVA实习实习单位：实习时间：学 学 专 班 学 指 实 达内培训

2015年7月13日— 2015年7月31日 院

名

称 ： 计算机学院 生

姓

名 ： 孔龙

业 ： 智能科学与技术

级 ： 0451202

号 ： 2012211766 导

教

师 ： 史宣燕、郭钢习

成绩 ：

一、对实习地点、实习单位的情况介绍

经过学校安排和我们自己的选择，在这酷热的七月我们并没有回家享受生活，而是在这段时间来参加达内科技的培训。达内专注职业教育13年，借助美国投资基金，采用“先学习，就业后付款”模式，帮助20万名学员成功就业。16大热门课程，30多个城市建立了130多家培训中心,一地学习,全国就业.要培训,就选上市公司!达内科技公司是Canada Tarena Technologies Inc.在中国的全资子公司，主要业务是提供IT培训、项目咨询、软件定制、技术研发、人才定向培养和人才出租服务，为企业提供全面的培训、咨询和技术研发解决方案，是首家为中国企业用户提供全系列高端IT技术培训（技能+经验）、项目咨询和人才服务一条龙服务的北美高科技公司。达内科技以中关村科技园区为依托，在中国软件业发达城市——北京、上海、广州、深圳、大连、南京、武汉、杭州、西安、苏州、成都、太原等20大城市，建立了近40家培训中心，占地2万平米，年培训1万多名软件人才。已累计为IBM、微软、摩托罗拉、华为、中软、用友、Yahoo、阿里巴巴、TOM、新浪、搜狐、百度、联想、神州数码、大唐电信、亚信等知名IT企业培养输送了7万多名中高级软件人才，目前达内全国拥有600多名员工，年产值近2亿元，是中国领先的中高端软件人才培训机构。达内科技目前提供的职业培训包括：外企软件开发工程师、软件测试工程师、Oracle数据库管理员、Unix系统管理员、网络系统工程师。

二、对实习内容作详细说明

软件开发是根据用户要求建造出软件系统或者系统中的软件部分的过程。软件开发是一项包括需求捕捉，需求分析，设计，实现和测试的系统工程。软件一般是用某种程序设计语言来实现的。通常采用软件开发工具可以进行开发。软件分为系统软件和应用软件。实训第一天早上，我们准时到达培训的实验室参加培训，达内的老师们很热情，然后让我们进行了分组，短暂分组后，我们开始做自我介绍，这个活动充分调动了同学们的积极性和团结能力，也让我们彼此认识了很多其他专业的同学，为后面的合作学习打下了一定的基础。最后老师介绍了达内的情况，以及我们以后的学习和日常生活的情况，在愉悦而开心的气氛下，我们轻松的度过一上午了。然后我们进行了实训的第一课，接触JAVA，虽然在学校中也了解过JAVA，但那仅仅连皮毛都称之不上，通过史老师的讲解，我们了解到JAVA使用是很广泛的，它有好多的版本，J2SE、J2ME、J2EE等等，广泛应用于桌面客户端，Android,IOS，以及浏览器，服务器等。随后史老师将如何进入JAVA的界面教给我们，分为三步：首先启动终端，然后敲入命令，接着进入界面新建工程，进行编译。

在接下来的几天里，史老师讲了JAVA的组成，与实用工具，如开发工具包——JDK。它包含了JAVA的运行环境——JRK，JAVA虚拟机——JVM，IAVA的标准类库——JAVA SE API。JAVA的开发需JDK。在Linux环境JAVA配置中，检查配置可以用JAVA －version。接着，史老师还讲解了了JAVA与C++语言的区别，最主要的就是在编译方面，JAVA编译一次，可以到处运行，而C++语言不可以。我们进行了第一个小游戏的编码，名字是“2048”。通过史老师的介绍JAVA概述，我们开始懂得了如何去操作，以及做些小东西了。之后，学习了在JAVA程序中镶嵌语句，与学过的C++语言类似，也让我们在学习新的知识的同时，也对以往的知识有了一个回顾。

在这次实训中另一位老师郭老师还给我们讲了JAVA中的web工程，首先要用安装好软件，其次要配置环境，这是一个重点，我听的很仔细，对于主要内容也能够掌握，主要有三个配置变量，接着老师又对三个配置变量做了详细的介绍，其中，PATH路径是一个难点，但是在老师详尽的讲解下，我也能够听懂，并且还能进行简单的操作。

本次实训的难点就是我们要自己完成一个网页的设计，虽然很简单，但是对于初学的我们，还是很困难，在老师的带领下，我们小组的成员也完成了任务，期间得到了老师的心细指导，感谢老师的帮助，这也归功于组员的配合。接下来是本次实训学习成果的验收，验收的便是我们花了两天时间所做的项目。我们分组上台进行答辩，其中一个队员进行所做程序的演示，其余几个人就说一下自己在这方面所做的内容和对一些知识的理解。

三、实际项目：

在培训过程中，我们接触到了2个小项目：一个小项目是2048小游戏，一个是雇员管理系统web服务。

2048游戏项目：2048是一款最近较为流行的数字游戏，很多同学在课堂上研究如何得到更高的积分，以至影响了学习效果，不如自己写下这款游戏吧，这样估计也就没有玩的兴趣了。游戏的规则是：给定一个4*4的方格，开始的时候只有若干个2，每次可以选择上下左右其中一个方向去滑动，每滑动一次，所有的数字方块都会往滑动的方向靠拢外，系统也会在空白的地方乱数出现一个数字方块，相同数字的方块在靠拢、相撞时会相加，可以连续移动但不能连续相加。玩家的目标就是尽快凑出“2048”这个数字方块。

作为一个程序员，写一个2048游戏当然难不倒你，通过分析你发现主要问题是如何根据当前状态和滑动方向，确定出下一个方格状态即滑动后的结果(不考虑新加入的随机方格)。每个状态绘制出来便成了一个简单的2048游戏。在这个过程中，学习了java的基础知识，学习到了一些java库类，如awt，swing,object,string等等类。并了解到了一些异常处理和I/O流操作。

四、在实习过程中遇到的问题及解决方法：

在这次实习的过程中，我发现了自己有很多的不足之处，对以前所学的知识的使用不是很熟练、学的不够扎实。自己所掌握的知识面不够广泛，所以以后要扩宽自己知识面，还要提高逻辑能力。我们还明白了不要以为很简单就不去做，其实在真正上手时才会发现我们懂得很少。所以为了不让手生，就要坚持去敲代码，要知道：坚持就是胜利！再就是本次实训的难点，软件设计和操作流程，让我们有点显得混乱，思路不是太清楚，所以以后我们要多做这样的时，让我们能更加流畅的工作。我们自己完成一个网页的设计，虽然很简单，但是对于初学的我们，还是很困难，在老师的带领下，我们小组的成员也完成了任务，期间得到了老师的心细指导，感谢老师的帮助，这也归功于组员的配合。

经过在企业实地参观和在招聘会上的观察，我发现，有很多适合我的公司或者岗位，也有我所需要的。但我认为自己的能力还是不够强，所以在今后的一年内，我需要努力学习，不断提高自己的实力，到毕业时可以找到一份理想的工作。

五、实习心得：

在达内IT培训集团的实习结束了，看着自己亲手写出来的几千条代码，内心非常激动，整个实习过程充满浓厚的学习氛围。在这里，我对Java的认识与理解上升了一个档次，当初对Java只是一知半解，而在这里学习了一段时间后，发现自己对Java还是很感兴趣的。课堂上老师认真地讲解各个方面的知识，每一个知识点都会讲解地非常清楚，让我们理解透彻，并且会加以程序联系，让我们充分地吸收一天所学的知识。实习从开始的紧张畏惧到后来的喜欢习惯，短短的十天时间，匆匆就过了，但是留下的记忆是深刻的、收获是丰盛的、汗水是晶莹的。达内教给我的不仅仅是最前端的技术，更重要的是教会了我如何去应用自己所掌握的知识。回想这段日子，其实对于我们每一个人来讲，都充满了苦涩。但是我们没有抱怨，没有不解，更没有对繁重课业的恐惧。只要坚持不懈地努力，我们一定能学到本事。

在本科前三年的学习中，理论知识占了很大比重，有些缺乏动手实践的机会和项目经验；但在达内的学习过程中，老师将讲解与实践相互交叉，知识与项目广泛结合，在每个部分学习结束时，都会有相应的练习。我觉得在学习过程中，笔记是最不可缺少的，在后面的学习中，遇到老问题可以方便地查找，长时间没有碰到过的内容也可以抽时间快速地复习，以备不时之需。实习是每一个大学生必须拥有的一段经历，它既使我们在实践中了解社会，让我们学到了很多在课堂上根本就学不到的知识，也打开了视野，长了见识，为我们以后进一步走向社会打下坚实的基础。实习使我开拓了视野，领略到不同企业的风格和模式，实习是我们把学到的理论知识应用在实践中的一次尝试。实习时把自己所学的理论知识用于实践，让理论知识更好的与实践相结合，在这结合的时候就是我们学以致用的时候，并且是我们扩展自己充实自己的时候。

应聘达内科技公司咨询顾问感言 篇5

首先很荣幸今天能够去到达内公司应聘，老实说在我原先的生活状态中对软件应用这块接触的比较多，对软件开发接触甚少，加上本身也不是学习这个出身，再去公司之前对软件开发只当是茶余饭后的一种八卦闲聊，对达内公司更是一无所知。

通过今天这次面试使我对达内公司有了个大概的了解，达内公司是一家外资企业，在国内主营高端IT精英的培训工作，是一家上市公司，在业界也有着非常好的口碑。公司流程方面主要分为三大模式，其一是市场专员主要负责招聘工作并且完成公司布置的其他任务，这是最基础的岗位，确也为其

二、其三奠定基础。其二是内勤人员，服务于公司各个岗位与部门，其三为咨询顾问，对这个岗位要求比其一和其二都要严格很多，因为这个岗位直接关系到公司整体的业绩。对于我个人而言这个行业是陌生的，但对这个行业有激情，在这个飞速发展的社会，IT行业绝对是个新潮而又澎湃的行业，在未来IT业注定要主导中国市场，所有东西都会趋向于智能化，而社会上每个人都会是这个行业的间接或直接的受益者，这是我激情于这个行业的元素之一。对于关经理在面试中提到对于市场出现恶性竞争方面，我会怎么处理，在面试过程中我据实回答没有碰到过这种情况，面试结束后我仔细想想，对于这种情况在同个行业竞争中确实是经常发生的，我们应该对这个有心里准备，在面对恶性竞争时，首先我认为我们应该对自己公司有信心，其次我们是代表公司与人竞争，我们自身就代表公司，自身的素质是非常重要的。对于营销，我认为要销售产品首先就要学会销售自己，只有把自己推销出去了，你才可以更好的引领你的客户。

齐达内个人资料 篇6

获奖学员：陈启壮 所获奖项：三等奖 内容

俄罗斯方块一共三个类中间用等号隔开 软件的开发过程 明确业务需求

用自然语言，将业务功能描述清楚

...2 业务分析

找到有哪些业务对象,和图片的分析

tetris(俄罗斯方块)

｜－－ score 累计分数

｜－－ lines 销毁的行数

｜－－ Wall（墙 20行x10列）

｜－－ 20row(行)

｜－－10 col cell(列)

｜－－ tetromino（4格方块，有7种形态）

｜－－ 4 cell

｜－－nextOne 下一个准备下落的方块

｜－－ 4 cell 数据模型,一切业务对象转换为数字表示

场地按照行列划分为20x10格子

格子有属性row,col,color 4 类 设计

Tetris

|--int score

|--int lines

|--Cell[20][10] wall

|--Tetromino tetromino

|

|--Cell[4] cells

|--row

|--col

|--color 5 算法设计，就是如何利用数据的计算实现软件的功能

4格方块的初始形态： I S Z J L T O

就在初始数据的数值状态设计

四格方块的下落计算：就是将每个格子的row+1

就是将下落的业务功能，转换为数字计算实现

左右移动

下落流程控制：控制方块下落与墙之间的控制关系

１ 合理的文字流程描述

２ 分析文字描述中的功能（动作）为方法

３ 用流程控制语句连接方法实现功能 严格测试结果！ＴestCase 左右移动流程控制

分数计算

界面的绘制

键盘事件控制

旋转流程控制

加速下降流程控制

开始流程控制（Ｔimer）

暂停流程控制

继续流程控制

结束流程控制

首先是Cell类，最基本的类包含3个私有属性和get,set方法，重写Object类的toString输出方法，并规定格子所具有的3个移动功能 package com.tarena.tetris;//包：小写英文字母，域名倒写.项目名 /** * 最小的格子

*/ public class Cell{

private int row;

private int col;

private int color;

public Cell(int row, int col, int color){

super();

this.row = row;

this.col = col;

this.color = color;

}

public int getCol(){

return col;

}

public void setCol(int col){

this.col = col;

}

public int getColor(){

return color;

}

public void setColor(int color){

this.color = color;

}

public int getRow(){

return row;

}

public void setRow(int row){

this.row = row;

}

public void left(){

col--;

}

public void right(){

col++;

}

public void drop(){

row++;

}

public String toString(){

return row+“,”+col;

} } ＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝ package com.tarena.tetris;import java.util.Arrays;import java.util.Timer;import java.util.TimerTask;

import javax.swing.JPanel;//是能够显示的矩形面板区域 import javax.swing.JFrame;//窗口框

import javax.swing.border.LineBorder;//实现边框 import java.awt.Color;import java.awt.Font;import java.awt.Graphics;import java.awt.event.KeyAdapter;import java.awt.event.KeyListener;import java.awt.event.KeyEvent;/* * 俄罗斯方块类

* 俄罗斯方块 扩展了（extends）系统的显示面板，增加了墙和

* 正在下落的方块

* */ public class Tetris extends JPanel{

public static final int ROWS = 20;

public static final int COLS= 10;

/*代表方块下落着陆的墙*/

private Cell[][] wall = new Cell[ROWS][COLS];

/*是正在下落的方块*/

private Tetromino tetromino;

/*下一个进入的方块*/

private Tetromino nextOne;

private static int score;

private int lines;

Timer timer;

private boolean gameOver = false;

private boolean pause = false;//暂停

private static final int[] SCORE_LEVEL={0,1,4,10,100};

private static final Graphics Graphics = null;

/*销毁（destory)满行*/

//

0 1 2 3 4

/*在Tetris中添加方法,检查游戏是否结束*/

public void rotateRightAction(){

tetromino.rotateRight();

if(outOfBounds()||coincide()){

tetromino.rotateLeft();

}

}

public void rotateLeftAction(){

tetromino.rotateLeft();

if(outOfBounds()||coincide()){

tetromino.rotateRight();

}

}

/*在Tetris中添加方法,检查游戏是否结束*/

private boolean gameOver(){

gameOver = wall[0][4]!=null;

return gameOver;

}

/*在Tetris中添加方法*/

public void hardDropAction(){

while(canDrop()){

tetromino.softDrop();

}

tetrominoLandToWall();

destroy();

if(gameOver()){

gameOverAction();

}

nextTetromino();

}

public void destroy(){

int lines = 0;//统计本次销毁的行数

for(int row = 0;row

Cell[] line = wall[row];

if(fullCell(line)){

clearLine(row,wall);

lines++;//每消除一行就累计加1

}

}

score += SCORE_LEVEL[lines];

this.lines +=lines;

}

public static void clearLine(int row,Cell[][] wall){

for(int i=row;i>1;i--){

System.arraycopy(wall[i-1],0,wall[i],0,wall[i].length);

}

Arrays.fill(wall[0],null);

}

public static boolean fullCell(Cell []line){

for(int col = 0;col

if(line[col]==null){

return false;//找到空格子，这行没有满

}

}

return true;

}

public String toString(){//显示全部的墙

String str = “";

for(int row = 0;row

Cell[] line = wall[row];

for(int col = 0;col

Cell cell = line[col];

if(tetromino.contains(row,col)){

str +=row+”,“+col+” “;

}else{

str = str + cell + ” “;

}

}

str +=”n“;

}

return str;

}

/*4格方块下降流程

* 方块移动到区域最下方或是着地到其他方块上无法移动时，* 就会固定到该处，而新的方法快出现在区域上方开始下落。

* 如果能下降就继续下降，* 否则就着陆到墙上，并且生成（随机）下一个方块

* */

public void softDropAction(){

if(canDrop()){//如果能下降

tetromino.softDrop();//方块继续下降

}else{

tetrominoLandToWall();//着陆到墙上

destroy();//

if(gameOver()){

gameOverAction();

}

nextTetromino();//生产（随机）下一个方块

}

}

private void startGameAction(){

gameOver = false;

pause = false;

score = 0;

lines = 0;

emptyWall();

nextTetromino();

repaint();

timer = new Timer();

timer.schedule(new TimerTask(){

public void run(){

softDropAction();

repaint();

}

}, 500, 500);

}

private void emptyWall(){

for(int row=0;row

Arrays.fill(wall[row],null);

}

}

/*清理游戏结束现场，如：停止定时器等*/

private void gameOverAction(){

timer.cancel();//停止定时器

}

/*检查 方块 是否能够继续下落：到底最低部，或者墙上

* 的下方有方块,返回false不能下降，返回true可以下降

* */

public boolean canDrop(){

//检查到底部

Cell[] cells = tetromino.getCells();

for(Cell cell:cells){

if(cell.getRow()==ROWS-1){

return false;

}

}

//检查墙上下方是否有方块

for(Cell cell:cells){

int row = cell.getRow();

int col = cell.getCol();

Cell block = wall[row+1][col];

if(block!=null){

return false;

}

}

return true;

}

/*方块“着陆”到墙上，* 取出每个小cell

* 找到cell的行号row和列号col

* 将cell放置到wall[row][col]位置上

* */

public void tetrominoLandToWall(){

Cell[] cells = tetromino.getCells();

for(Cell cell:cells){

int row = cell.getRow();

int col = cell.getCol();

wall[row][col] = cell;

}

}

/*生产（随机）下一个方块

* 1 下一个变为当前的* 2 随机产生下一个

* */

public void nextTetromino(){

if(nextOne==null){//第一次nextOne是null时候先生产一个

nextOne = Tetromino.randomTetromino();

}

tetromino = nextOne;//下一个变为当前的

nextOne = Tetromino.randomTetromino();//随机产生下一个

if(tetromino==null){//处理第一次使用时候下一个是null

tetromino=Tetromino.randomTetromino();

}

}

/*以格子为单位左右移动方块

* 1）如果遇到左右边界就不能移动了

* 2）如果与墙上的格子相撞就不能移动了

* 变通为：

* 1）先将方块左移动，* 2）检查(移动结果是否出界)，或者(重合)

* 3）如果检查失败，就右移的回来

*

* */

public void moveLeftAction(){

tetromino.moveLeft();

if(outOfBounds()|| coincide()){

tetromino.moveRight();

}

}

private boolean outOfBounds(){

Cell[] cells = tetromino.getCells();

for(int i = 0;i < cells.length;i++){

Cell cell = cells[i];

int row = cell.getRow();

int col = cell.getCol();

if(row == ROWS||col<0||col>=COLS){

return true;

}

}

return false;

}

private boolean coincide(){

Cell[] cells = tetromino.getCells();

for(int i = 0;i < cells.length;i++){

Cell cell = cells[i];

int row = cell.getRow();

int col = cell.getCol();

if(row >0&&row0

&&wall[row][col]!=null){

return true;//重合 }

}

return false;

}

public void moveRightAction(){

tetromino.moveRight();

if(outOfBounds()|| coincide()){

tetromino.moveLeft();

}

}

public static final int CELL_SIZE = 25;

/*在Tetris.java中添加main方法 作为软件的启动方法*/

public static void main(String []args){

JFrame frame = new JFrame(”俄罗斯方块“);

int wigth =(COLS+8)*CELL_SIZE +100;

int height =ROWS*CELL_SIZE +100;

frame.setSize(wigth,height);

frame.setLocationRelativeTo(null);//居中

frame.setDefaultCloseOperation（JFrame.EXIT_ON_CLOSE);//设置关闭窗口就关闭软件

frame.setLayout(null);//取消默认布局，取消自动充满

Tetris panel = new Tetris();

panel.setLocation(45,25);

panel.setSize((COLS+8)*CELL_SIZE,ROWS*CELL_SIZE);

panel.setBorder(new LineBorder(Color.black));

frame.add(panel);//窗口中添加面板

frame.setVisible(true);//显示窗口时候调用paint()

panel.action();

}

/*动作方法，这里是让软件开始动作，*/

public void action(){

//wall[18][2] = new Cell(18,2,0xff0000);

startGameAction();

//重绘方法－>尽快调用paint()

//startGameAction();

//this 是当前Tetris面板

this.requestFocus();//为当前面板请求获得输入焦点

//this对象就获得了输入焦点，以后任何的

//键盘输入(包括左右方向键)目标就是这个面板对象了！

//addKeyLIstener添加键盘监听，监听那些按键输入了

this.addKeyListener(new KeyAdapter(){

public void keyPressed(KeyEvent e){

int key = e.getKeyCode();//key按键

if(gameOver){

if(key==KeyEvent.VK_S){

startGameAction();//启动游戏开始流程

}

return;

}

if(pause){

if(key==KeyEvent.VK_C){

continueAction();

}return;

}

//System.out.println(”Type:“+e.getKeyCode());

switch(key){

case KeyEvent.VK_RIGHT :moveRightAction();break;

case KeyEvent.VK_LEFT :moveLeftAction();break;

case KeyEvent.VK_DOWN :softDropAction();break;

case KeyEvent.VK_UP :rotateRightAction();break;

case KeyEvent.VK_SPACE :hardDropAction();break;

case KeyEvent.VK_P :pasueAction();break;

}

//按键－>方块移动方法－>改变方块数据－>repaint()

//->尽快调用paint（）－>利用新数据绘制

repaint();

}

private void continueAction(){

pause = false;

timer = new Timer();

timer.schedule(new TimerTask(){

public void run(){

softDropAction();

repaint();

}

}, 500, 500);

}

private void pasueAction(){

pause = true;

timer.cancel();

}

});

}

//JPanel 类利用paint（涂画）方法绘制界面

//子类重写paint方法可以修改绘图逻辑

public static final int BORDER_COLOR = 0x667799;

public static final int BG_COLOR = 0xC3D5EA;

public static final int FONT_COLOR = 0;

public void paint(Graphics g){

//g 代表绑定在当前面板上的画笔

//利用画笔在当前 面板上 绘制了一串字符!

paintBackground(g);//填充背景

paintWall(g);//绘制墙

paintTetromino(g);//绘制当前方块

paintNextOne(g);//绘制下一个方块

paintScore(g);//绘制分数

paintTetrisBorder(g);//绘制边线

}

private void paintScore(Graphics g){

int x = 12 * CELL_SIZE;

int y = 5 * CELL_SIZE;

Font font = new Font(getFont().getName(),Font.BOLD,25);

String str = ”分数： “+score;

g.setColor(new Color(FONT_COLOR));

g.setFont(font);

g.drawString(str, x, y);

y+=2*CELL_SIZE;

str = ”行数： “+lines;

g.drawString(str, x, y);

if(gameOver){

str = ”(T_T)！[s]再来！“;

y+=2*CELL_SIZE;

g.drawString(str, x, y);

}

if(pause){

str = ”[c]继续！“;

y+=2*CELL_SIZE;

g.drawString(str, x, y);

}else{

str = ”[p]暂停！";

y+=2*CELL_SIZE;

g.drawString(str, x, y);

}

}

private void paintNextOne(Graphics g){

if(nextOne==null)//如果没有4格方块就返回，不绘制

return;

for(Cell cell : nextOne.getCells()){

int row = cell.getRow()+1;

int col = cell.getCol()+9;

int x = col*CELL_SIZE;

int y = row*CELL_SIZE;

g.setColor(new Color(cell.getColor()));

g.fillRect(x, y, CELL_SIZE, CELL_SIZE);

g.setColor(new Color(BORDER_COLOR));

g.drawRect(x, y, CELL_SIZE, CELL_SIZE);

}

}

private void paintTetromino(Graphics g){

if(tetromino==null)//如果没有4格方块就返回，不绘制

return;

for(Cell cell : tetromino.getCells()){

int row = cell.getRow();

int col = cell.getCol();

int x = col*CELL_SIZE;

int y = row*CELL_SIZE;

g.setColor(new Color(cell.getColor()));

g.fillRect(x, y, CELL_SIZE, CELL_SIZE);

g.setColor(new Color(BORDER_COLOR));

g.drawRect(x, y, CELL_SIZE, CELL_SIZE);

}

}

private void paintWall(Graphics g){

for(int row = 0;row

for(int col = 0;col < COLS;col++){

Cell cell = wall[row][col];

int x = col*CELL_SIZE;

int y = row*CELL_SIZE;

if(cell == null){

//g.setColor(new Color(BORDER_COLOR));

// g.drawRect(x, y，//

CELL_SIZE, CELL_SIZE);

}else{

g.setColor(new Color(cell.getColor()));

g.fillRect(x, y，CELL_SIZE, CELL_SIZE);

g.setColor(new Color(BORDER_COLOR));

g.drawRect(col*CELL_SIZE, row*CELL_SIZE，CELL_SIZE, CELL_SIZE);

}

}

}

}

private void paintBackground(Graphics g){

g.setColor(new Color(BG_COLOR));

g.fillRect(0, 0, getWidth(), getHeight());

}

private void paintTetrisBorder(Graphics g){

g.setColor(new Color(BORDER_COLOR));

g.drawRect(0, 0, CELL_SIZE*COLS, CELL_SIZE*ROWS-1);

g.drawRect(CELL_SIZE*COLS,0，CELL_SIZE*8-1, CELL_SIZE*ROWS-1);

} } ＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝ package com.tarena.tetris;import java.util.Arrays;import java.util.Random;/* * 四格方块类，有7种子类：I Ｔ S Ｚ J Ｌ O * */ public abstract class Tetromino {

public static final int I_COLOR =0xff6600;

public static final int T_COLOR =0xffff00;

public static final int S_COLOR =0x66ccff;

public static final int Z_COLOR =0x00ff00;

public static final int J_COLOR =0x0000ff;

public static final int L_COLOR =0xcc00ff;

public static final int O_COLOR =0xff0000;

protected Cell[] cells = new Cell[4];

/*四格方块的下落，是四个格子一起下落*/

public void softDrop(){

for(int i = 0;i

cells[i].drop();

}

}

/*向左移动一步*/

public void moveLeft(){

for(int i = 0;i

Cell cell = cells[i];//引用赋值

cell.left();

}

}

public void moveRight(){

//增强for循环，是传统数组迭代的“简化版本”，//也称为foreach循环（foreach迭代）(java 5以后)

for(Cell cell:cells){//底层实现就是经典迭代

cell.right();

}

}

public Cell[] getCells(){

return cells;

}

protected Offset[] states;//旋转的状态

protected class Offset{

int row0,col0;

int row1,col1;

int row2,col2;

int row3,col3;

public Offset(int row0, int col0, int row1，int col1, int row2, int col2，int row3, int col3){

this.row0 = row0;

this.col0 = col0;

this.row1 = row1;

this.col1 = col1;

this.row2 = row2;

this.col2 = col2;

this.row3 = row3;

this.col3 = col3;

}

}

private int index = 10000-1;

/*向右转*/

public void rotateRight(){

index++;

Offset offset = states[index%states.length];

Cell axis = cells[0];//找到轴（axis）的位置

cells[0].setRow(offset.row0+axis.getRow());

cells[0].setCol(offset.col0+axis.getCol());

cells[1].setRow(offset.row1+axis.getRow());

cells[1].setCol(offset.col1+axis.getCol());

cells[2].setRow(offset.row2+axis.getRow());

cells[2].setCol(offset.col2+axis.getCol());

cells[3].setRow(offset.row3+axis.getRow());

cells[3].setCol(offset.col3+axis.getCol());

}

public void rotateLeft(){

index--;

Offset offset = states[index%states.length];

Cell axis = cells[0];//找到轴（axis）的位置

cells[0].setRow(offset.row0+axis.getRow());

cells[0].setCol(offset.col0+axis.getCol());

cells[1].setRow(offset.row1+axis.getRow());

cells[1].setCol(offset.col1+axis.getCol());

cells[2].setRow(offset.row2+axis.getRow());

cells[2].setCol(offset.col2+axis.getCol());

cells[3].setRow(offset.row3+axis.getRow());

cells[3].setCol(offset.col3+axis.getCol());

}

/*随机生成一个具体方法*/

public static Tetromino randomTetromino(){

Random random = new Random();

int type = random.nextInt(7);//0~6

switch(type){

case 0:return new I();

case 1:return new T();

case 2:return new S();

case 3:return new J();

case 4:return new Z();

case 5:return new L();

case 6:return new O();

}

return null;

}

public String toString(){

return Arrays.toString(cells);

}

public boolean contains(int row, int col){

for(int i =0;i

Cell cell = cells[i];

if(cell.getRow()==row && cell.getCol()==col){

return true;

}

}

return false;

}

} class I extends Tetromino{

public I(){

cells[0] = new Cell(0,4,I_COLOR);

cells[1] = new Cell(0,3,I_COLOR);

cells[2] = new Cell(0,5,I_COLOR);

cells[3] = new Cell(0,6,I_COLOR);

states = new Offset[]{

new Offset(0,0,-1,0,1,0,2,0)，new Offset(0,0,0,-1,0,1,0,2)，};

} } class T extends Tetromino{

public T(){

cells[0] = new Cell(0,4,T_COLOR);

cells[1] = new Cell(0,3,T_COLOR);

cells[2] = new Cell(0,5,T_COLOR);

cells[3] = new Cell(1,4,T_COLOR);

states = new Offset[]{

new Offset(0,0,1,0,-1,0,0,1)，new Offset(0,0,0,-1,0,1,1,0)，new Offset(0,0,1,0,-1,0,0,-1)，new Offset(0,0,0,1,0,-1,-1,0)，};

} } class S extends Tetromino{

public S(){

cells[0] = new Cell(0,4,S_COLOR);

cells[1] = new Cell(0,5,S_COLOR);

cells[2] = new Cell(1,3,S_COLOR);

cells[3] = new Cell(1,4,S_COLOR);

states = new Offset[]{

new Offset(0,0,-1,0,1,1,0,1)，new Offset(0,0,0,1,1,-1,1,0)，};

} } class Z extends Tetromino{

public Z(){

cells[0] = new Cell(0,4,Z_COLOR);

cells[1] = new Cell(0,3,Z_COLOR);

cells[2] = new Cell(1,4,Z_COLOR);

cells[3] = new Cell(1,5,Z_COLOR);

states = new Offset[]{

new Offset(0,0,-1,1,0,1,1,0)，new Offset(0,0,-1,-1,-1,0,0,1)，};

} } class J extends Tetromino{

public J(){

cells[0] = new Cell(0,4,J_COLOR);

cells[1] = new Cell(0,3,J_COLOR);

cells[2] = new Cell(0,5,J_COLOR);

cells[3] = new Cell(1,5,J_COLOR);

states = new Offset[]{

new Offset(0,0,-1,0,1,0,1,-1)，new Offset(0,0,0,1,0,-1,-1,-1)，new Offset(0,0,1,0,-1,0,-1,1)，new Offset(0,0,0,-1,0,1,1,1)，};

} } class L extends Tetromino{

public L(){

cells[0] = new Cell(0,4,L_COLOR);

cells[1] = new Cell(0,3,L_COLOR);

cells[2] = new Cell(0,5,L_COLOR);

cells[3] = new Cell(1,3,L_COLOR);

states = new Offset[]{

new Offset(0,0,-1,0,1,0,-1,-1)，new Offset(0,0,0,1,0,-1,-1,1)，new Offset(0,0,1,0,-1,0,1,1)，new Offset(0,0,0,-1,0,1,1,-1)，};

} } class O extends Tetromino{

public O(){

cells[0] = new Cell(0,4,O_COLOR);

cells[1] = new Cell(0,5,O_COLOR);

cells[2] = new Cell(1,4,O_COLOR);

cells[3] = new Cell(1,5,O_COLOR);

states = new Offset[]{

new Offset(0,0,0,1,1,0,1,1)，new Offset(0,0,0,1,1,0,1,1)，};