达内IT培训学习心得（共5篇）

第一篇：达内IT培训学习心得

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

当我第一天来这里时，和其他同学一样怀着兴奋得心情踏进达内IT培训中心，或许是单纯的对这个新环境的好奇、也或许是曾经对这儿有一点了解想亲自见证一下，因为听大二的学长说只有来到达内才能学到与学校不同的东西，才能更接近实际项目工程。的确如他们所说，运行程序前必须作许多准备工作，如：在ClassView内的CSDIDemoDoc文档内创建变量或增加成员函数；在ResourceView内创建快捷键或增加菜单项„„当然做成功一个项目必须先写好需求分析。

就这样既兴奋又好奇的跟着老师一步一步往下走，跟着在键盘上忙碌的敲代码、调整程序。实习时间慢慢的在减少，而程序却相反——越来越难，越来越繁。因为一个小环节与大家拉开了距离，在一个庞大的项目中是不允许任何一处掉链子的。看到同学们早已“轻车熟路”操作自如了，而我却不知所措，立刻就有了压力。一天下来感受最深的就是那种巨大的差距。学校所学与实际应用中的脱节。

在我困惑与迷茫时，老师给我解释说：“咱用的编程软件是VC6.0，更加注重的是对学生实战能力的培养，在学校所学专业知识的基础上让我们学习最新的编程技术，通过做项目的方式来让我们明白实践中的编程到底是怎样的„„”正是冀老师的耐心讲解让我重新找回了自信，几天下来从简单的c++程序到第一个win32程序，从MFC到第一个Dialog„„虽然程序中还是有太多的疑惑但更多的是增长了见识看清了差距。

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

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

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

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

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

在达内的这半个月培训我感觉获益匪浅。虽然与课本知识不同，至少我看清了实际做项目与书本知识之间的差距，不至于在就业后手足无措。这次实习对我以后的学习甚至就业带来了巨大的帮助。

感谢学校，感谢达内的王老师，冀老师。

第二篇：达内培训总结

达内培训总结

今年的7月初我和大多数达内学员一样，兴奋的进入了达内进行培训，开始了C/C＋＋的培训学习，转眼间4个多月已经过了，也结束了我们培训课程。虽然自己学的是软件技术专业，但自己在来达内之前也没有接触过C跟C++，既然走在了这条路上，我想我会一直走在这条路上，给自己的这四个月来说下几点：

1、端正自己学习的态度

在课程学习中如何端正自己的态度也是很重要的。在达内学习的过程中，每门课的时间都是很紧的，每天很辛苦，我也想过自己到底自己要不要学C/C++,但是自己还是保持了下来，有一个良好的心态去接受新的东西，哪些是自己懂的，哪些是自己不会的，自己还是要有一个计划，跟不上老师的讲课进度，也要试着去赶上老师的进度，调整自己的学习方法。

2、编程当作兴趣

在学习之初感觉编程很枯燥，所以自己还是要培养出对编程的兴趣。一开始其实多编程的兴趣也不是很大，只是慢慢习惯了枯燥，不是很感兴趣只要装着很感兴趣，久而久之开始对编程有了兴趣，正所谓兴趣才是最后的老师。

3、多敲敲代码

程序员是代码敲出来。在达内，每天学的东西到很多而且新的理论知识也多，然而那只是理论，和实际的应用还有很大差距，而这些差距只有在实际的代码编写中我们才能体会出来。所以还是每天坚持多敲敲多练练。总之，每天要保证一定量的代码，这样我们才会有真正水平上的提高。另外，在实际动手的过程中，还要多留心编译器错误提示，也有助于我们对语言的学习和理解。

4、多坚持一下

学习C/C＋＋毕竟是非常枯燥的一件事情，虽然我们可以培养自己的兴趣，但是4个月的时间毕竟很让人疲劳、很累，随着时间的推移，我们刚开始时的兴奋劲也慢慢减退了，有什么感觉没什么希望，我们能做的就只有多坚持一下，忍得住寂寞，才守得住阵地，保得住成果。自己还是踏踏实实的坚持完成这4个月的学习，还一直在坚持。

其他的也没有什么要说的，一切多看自己的能力。

第三篇：达内培训管理制度

达内培训管理制度

“无以规矩，不成方圆”，严谨的学习纪律是优秀学习效果的保障。为树立勤奋、刻苦的优良学风，严肃学习纪律，督促、引导学员努力学习，制订本制度。

第一部分课堂与练习1、2、3、4、学员上课期间一律不得会客。学员上课期间须关闭手机或将手机处于震动状态，并且不得接打电话。未经教学管理老师允许并办理相关手续，任何学员不得于非所在班级听课。任何教室，在任何学习与练习时间，只得用于授课和学员学习，学员不得玩游戏、阅读与学习无

关书籍或进行任何与学习无关活动。

5、任何学员，在任何学习与练习时间，须保持安静，不得大声喧哗，干扰课程秩序、影响他人学习。第二部分考勤、纪律1、2、3、考勤工作由教学管理员负责，教学管理员检查并记录学生的出勤情况。所有学员须准时到达课堂，努力学习，不得迟到、早退、旷课。学员在规定课程时间未按时到达教室，视为迟到。学生在培训期限内迟到次数累计三次，处以警

告和批评；在培训期限内迟到次数累计超过五次者取消培训资格。

4、学员在培训期限内未经请假或请假未获得批准，擅自缺课，视为旷课。在培训期限内旷课次数累

计超过五次者，取消培训资格。

5、如学员身体不适，不能坚持正常学习，须持医院有效证明向教学管理员请假，并办理病假手续。

如学员在达内学习期间发生心理或身体上的重大疾病，应及早向达内提出书面报告，及早请假就医，以免耽误治疗。

6、学习期间不得请事假。如遇特殊情况，须向教学管理员提出申请，获得同意后方可休假。学员在达内学习期间，不得用言词或其它方式侮辱他人；不得寻衅滋事、打架斗殴。

第三部分成绩考核

1、考核是检验教学效果、保证教学质量的重要手段，其目的在于指导和督促学员系统复习和巩固所

学知识与技能，检验理解程度与灵活运用能力。

2、学员的考核由任课教师负责实施并根据课程进度定期进行。

3、考核有通常课堂测验、单门课程考试、项目实战考评三种类型。

4、学员实习结束的成绩由日常成绩综合确定。

第四部分教室1、2、3、4、5、6、1、2、学员须服从达内公司的安排，在公司指定和规定的教室学习。达内指定教室供学员自由练习，自由练习时间由教学管理部门和行政部协商后作出规定。学员在结束学习和练习后须自觉关机。学员须爱护、小心使用所有设施设备，不得损坏，否则，除给予违纪处理外，须照价赔偿。学员须保持室内清洁卫生，严禁吸烟，严禁随地吐痰，乱丢杂物。教室内严禁用餐。第五部分机房 达内所有机房由MIS部统一管理，所有学员须根据规定使用计算机。严禁于机房内利用计算机从事任何娱乐活动，如游戏、看电影等，否则，达内公司有权要求进行

娱乐活动的学员支付使用计算机及其它相关费用，并要求恢复计算机初始状态，包括但不限于格式化或ghost镜象恢复。

学员安装学习软件，须向MIS部提出申请，经审核同意后方可实施。不得下载、安装各种计算机程序，否则，造成系统崩溃、病毒传播等恶劣后果由违反人承担所造成的一切损失。

严禁私自挪动、更换计算机设备。如有发生，按实物价值5-10倍赔偿。

严禁私自更改管理员密码，否则，暂停计算机使用权1星期。

严禁于机房内使用磁化物品，如磁化水杯，否则，造成显示器磁化现象照价赔偿。

学员须保持室内清洁卫生，严禁吸烟，严禁随地吐痰，乱丢杂物。

严禁在机房和教室用餐、吃零食。

严禁在机房和教室留宿。

第六部分违纪处理

违反上述任何条款的行为1次，情节轻微者，将被给予警告处理，同时，须执行上述有关条款已列出的违纪处理措施。

违反上述任何条款的行为3次，情节严重者或者累计违反上述任何条款2次，将被给予严重警告处理，同时，须执行上述有关条款已列出违纪处理措施。

累计违反上述任何条款4次，将被取消实习资格。除该种情况外，如下情况也将被取消实习资格：出现任何不尊重老师、同学之不文明行为 所有违纪行为记入学员档案并向其所在学校反应。

对于寻衅滋事、打架斗殴者，除按照上述4条措施处理外，因打架斗殴致人人身伤害者，须向受害者赔偿各项损失。寻衅滋事、打架斗殴等恶劣行为对达内造成不良影响的，达内保留对相关人员采取法律措施和其他追究措施的权力。学员的任何违法违规行为，包括但不限于上述的寻衅滋事、打架斗殴等行为，所造成的学员本人或第三人的任何损失和伤害，达内皆不承担任何责任；给达内造成的任何损失，达内有权向该学员追偿。

第四篇：北京达内培训感受

来北京有两个月了，感受真的很多，我是在北京达内集团学java，经过这段时间的学习，我不仅学到了java的核心技术，更是看到了计算机行业的发展状况，看到了社会的发展速度和大城市的生活工作节奏，这是在学校不可能看到的也是不可能体会到的，现在很是后悔在学校没有把握好时间学习，下面说说我的感想吧。

首先，这里有非常浓厚的学习氛围。这里能够感受到社会上工作的压力，来这里学习的同学不全是大学刚毕业或者是还没有毕业的大学生，有很多是在工作几年之后又回来学习的，可能他们也感觉社会在快速发展，自己也应该多学点有用的知识，以便更好地立足社会。俗话说“活到老学到老”，这话一点不假，跟他们交流，我学到了很多。从他们身上我能感觉到压力，能感觉到自己的不足，让我感觉自己学习不再只是为了一场考试，而是今后工作和生活的实力与能力。大家深知社会竞争激烈，都在拼命地学习。但是这并不影响我们之间相互讨论和学习，因为我们的对手不只是眼前的这些同学，而是更多的你所不认识的人，这也让我看到了团队合作的重要性。所以说学习其实是很快乐的，虽然很累很累，但是大家都知道其意义所在。

我们每天的学习时间很长。早晨七点多起床，路远的同学要坐车去上课，从八点半到中午连续不断地上课，中午休息一个多小时，下午上课到五点，然后上自习到七点，才去吃饭，大多数人晚饭后会回来一直学习到晚上九点多，这就是我们的一天，天天如此。所以我感觉我们是飞速前进的，我们在坚持中前进！

我们的学习是职业性的培训。老师告诉我们，我们的学习不再是teaching，而是货真价实的training。是的，我们在不断地训练，练习将来工作中真正能用的技术。都说现在找工作难，那是那些没有真正技术的人给自己的借口和自我安慰。我们在这里学的很多很多，从技术上来说，我们学习java核心技术、linux操作系统、oracle数据库、jdbc数据库连接技术、xml技术、java web、java script等等；我们会使用集成框架spring等做出很多商业软件„„在学到这么多有用的知识之后，谁还会没有信心找到工作呢！当你在自己的简历上写上你拥有如此多的技术，曾经做过项目，已经有了相当多的工作经验，有哪个公司会不录用这样的人才！但是有一个前提：在培训过程中，必须要坚持，因为不是一般的累，时刻告诉自己：加油！

由于时刻在学习中，所以对于学习有着说不完的话。下面再谈一些生活上的感受吧。大家都知道，在北京住房是很大的问题，但是我却从没想过会有这么困难。刚来的那会儿非常不适应，在大学宿舍五百块钱能住一年，但是在这里五百块只能在地下室住一个月，面对这么大的压力，谁会不努力学习呢！我们曾经在电视上看见过早晨上班一族挤公交车和地铁的场面，但是真的经历过了才能知道，这是多么的痛苦！也能体会到压力。但是就是在竞争最激烈的地方才会焕发人的潜能，只要肯努力，就一定会有收获的！

这是我来北京参加培训的一点点感受。对于选择到北京达内来学习，我认为这是一个很正确的选择，不是说出来培训就会找到好的工作，而是只要抱着一种上进的学习的心态，一直努力，找工作就像顺藤摸瓜一样，你的学习道路就是瓜藤，而学习的小尽头也就是满意的工作了。其实一份满意的工作不只是为了拿薪水，而是实现自己的价值，自己用自己的知识在自己喜欢的岗位上做自己喜欢的工作，这难道不是一件很好的事情吗？

IT行业是当今社会的热门行业，说它热门是因为它的发展潜力是无穷的，所以我们能进入到这个行业是一种幸运。可是我们在大学里面甚至连半只脚都没有迈进IT的门槛，随着知识的增多，随着对专业技术由点到线，由线到面的了解，我对这个行业就有了很深入的认识。这也是给大家的一个建议，永远不要想着知道全面的概况之后才去学每个点，而要从最小的点开始拓展开去，这样才能取得进步，所以在学校基础知识的学习也非常重要！

最后送大家一句话：相信自己没有选错行业，相信自己有立足的能力，为自己制定明确的目标，然后努力地去学习、体会、感悟、进步！

第五篇：达内学习心得：俄罗斯方块项目总结

达内学员：我的俄罗斯方块项目总结

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

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

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

...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)，};

} }