第一篇：达内学习心得：俄罗斯方块项目总结
达内学员：我的俄罗斯方块项目总结
获奖学员：陈启壮 所获奖项：三等奖 内容
俄罗斯方块一共三个类中间用等号隔开 软件的开发过程 明确业务需求
用自然语言，将业务功能描述清楚
...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&&row &&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)，}; } } 达内培训总结 今年的7月初我和大多数达内学员一样，兴奋的进入了达内进行培训，开始了C/C＋＋的培训学习，转眼间4个多月已经过了，也结束了我们培训课程。虽然自己学的是软件技术专业，但自己在来达内之前也没有接触过C跟C++，既然走在了这条路上，我想我会一直走在这条路上，给自己的这四个月来说下几点： 1、端正自己学习的态度 在课程学习中如何端正自己的态度也是很重要的。在达内学习的过程中，每门课的时间都是很紧的，每天很辛苦，我也想过自己到底自己要不要学C/C++,但是自己还是保持了下来，有一个良好的心态去接受新的东西，哪些是自己懂的，哪些是自己不会的，自己还是要有一个计划，跟不上老师的讲课进度，也要试着去赶上老师的进度，调整自己的学习方法。 2、编程当作兴趣 在学习之初感觉编程很枯燥，所以自己还是要培养出对编程的兴趣。一开始其实多编程的兴趣也不是很大，只是慢慢习惯了枯燥，不是很感兴趣只要装着很感兴趣，久而久之开始对编程有了兴趣，正所谓兴趣才是最后的老师。 3、多敲敲代码 程序员是代码敲出来。在达内，每天学的东西到很多而且新的理论知识也多，然而那只是理论，和实际的应用还有很大差距，而这些差距只有在实际的代码编写中我们才能体会出来。所以还是每天坚持多敲敲多练练。总之，每天要保证一定量的代码，这样我们才会有真正水平上的提高。另外，在实际动手的过程中，还要多留心编译器错误提示，也有助于我们对语言的学习和理解。 4、多坚持一下 学习C/C＋＋毕竟是非常枯燥的一件事情，虽然我们可以培养自己的兴趣，但是4个月的时间毕竟很让人疲劳、很累，随着时间的推移，我们刚开始时的兴奋劲也慢慢减退了，有什么感觉没什么希望，我们能做的就只有多坚持一下，忍得住寂寞，才守得住阵地，保得住成果。自己还是踏踏实实的坚持完成这4个月的学习，还一直在坚持。 其他的也没有什么要说的，一切多看自己的能力。 达内学习心得：精心总结的面向对象 参赛学员：方钱有 获奖奖项：二等奖 什么面向对象: 个人分析觉得：在程序设计里,面向对象是一种相对说法，相对于面向过程而言的； 面向“对象“：即重点在于“对象”；而面向过程：则重点在于“过程”，简单说：就是我我们看待事物在眼光上注重点不一样；比如说：我们评判一个女孩漂亮与否，有的人看重外表，有的人则看重“心灵”，只是侧重点不一样。 举个例子：把大象装进冰箱！ 面向过程面向对象（注重一系列动作即过程）（注重动作所操作的承受者［“对象”］） “打开”冰箱“冰箱”打开“装入”大象“大象”装入“关闭”冰箱“冰箱”关闭 类：通俗的说类就是“一类事物的简称”，并且这些事物至少具有一点“共同的”特征.比如说：动物就是一个类 对象：就是某一类中一个具体的（就是可以具体描述出来的）东西，比如：动物(类)里的“狗”就是一个对象。(个人觉得对象相对于类而言的,因为狗又可以分好多种，‘狗’相对于‘哈士奇’是一个类,‘哈士奇’是‘狗’类的一个具体对象) 在生活中就拿描述汽车来说，我们都知道汽车都有4个轮子； 都有跑的功能 可以如下描述: 类汽车 属性： 4个轮 功能： 跑 那么怎么在Java中描述汽车这类呢？ class car{ int wheel=4;//属性： 4个轮 void run(){//方法(功能)： 跑 System.out.println(“是汽车都会跑”); } } 那么可见“出租车”应当是“汽车”这类的一个具体化（实实在在的例子即“实例”）对象，那自然出租车也就具备了汽车这类所具备的“共有”属性功能！ 如何创建一个出租车对象呢？java中通过new关键字来创建一个类的实例即对象，也叫类的实例化，就是把类具体化成一个实例嘛！ 格式：类名对象名 =mew 类名() Cartexi =newCar(); 创建了“出租车”对象（实例）之后那么它也就有了如下“自己”的属性和功能。 int wheel=4;//属性： 4个轮 void run(){//功能： 跑 System.out.println(“我是出租车我也会跑”); } 我们如何来访问对象中的它自己的属性和方法呢？ 格式：对象.属性；对象.方法名();这一点也验证了面向对象编程的侧重点在于“对 象”上； texi.wheel;texi.run() ******************************************************************************* ******************************************************************************* ******************************************************************************* 1.封装： 从字面可以解读为将东西封起来再装好。要想拿到里面的东西就得有相应的方法打开，才能 拿到。 举例来说：一个房间的门如果没有上锁，那么大家都可以进去拿东西，但现在我们不想让谁 都进来拿东西，我们可以将房门上锁，只对外提供一把钥匙，只有有钥匙的人才能进来，这 就是“封装”现象！ 在java程序中，“封装”现象如何实现呢？ 可以这样实现：将类中的一些属性和方法用private关键字修饰，将他们“私有化（即不对 外直接公开）”,使外部其他类不能通过创建该类对象或通过类名直接访问这些属性和方法; 只对外提供公有的方法，外部其他类必须通过该类对外提供的公有方法来访问该类的相应成员；例如： class Person{ private String name;//将name属性私有化（封装）［相当于了上锁］使外部其他类不能直 接访问到 public SetName(String name){//对外提供公有方法（相当于房门钥匙）供外部其他类访问 到本类属性 this.name=name; } } 2.继承： 从字面来说继承就是子父类关系的简称，就是儿子（女儿也行，好吧）会继承老爸的一些属性和行为 在java中如何描述继承关系呢？ 注意：第一得知道在java中继承是类与类之间或者是接口与接口之间才有继承关系； 通过extends关键字来描述继承关系 例如：老爸这个类 class Dad{ String sex=man; void smoke(){ System.out.println(“老子会抽烟！”); } } 那么我们怎么来让儿子这个类继承老爸这个类呢？ class Son extends Dad{//通过extends关键字儿子这个类就继承老爸这个类了 String name;//定义自己的属性 String sex=man;//继承过来的属性，无须再定义，这里写出来是为了好理解 void smoke(){//继承过来的方法，无须再定义，这里写出来是为了好理解 System.out.println(“老子会抽烟！”); } void playBall(){//定义自己的方法 System.out.println(“儿子即会打球又会抽烟！”); } void somke(){//重写的方法 System.out.println(“我不抽20块以下的烟”); } void smoke(int n){//重载的方法 System.out.println(“我抽了+n+”年的烟了“); } } 那么具有继承关系的两个类有什么特点呢？ 1）子类会将父类的属性和方法继承过来，当然子类也可以自己定义的属性和方法 2）当子类自己定义的方法和父类继承过来的方法相同时会发生“重写“现象！ 3）父类用private关键字私有的方法是不能被继承的！ 4）子类可以使用super访问父类的属性和方法 5）子类通过重写父类方法，修改父类的功能 6）子类构造器一定调用父类的无参构造器 7）构造器不能继承 3.多态： 字面意思就是多种形态,也就是说一种事物同时局部多种形态.注意：要出现多态情况，那么类和类之间一定得是继承关系，或者类和接口是实现关系 我觉得：在java中多态是相对于一个对象而言的，就是父类型引用变量引用子类对象，并 且父类型引用变量可以接受不同子类的对象 例如：拿上面的举例 Dad uncle=new Son();父类引用变量uncle即具备Son类的成员又具备父类的成员；这也称 为“向上造型”； 多态时的特点 1）多态时访问成员变量，如uncle.name; 编译时看等号左边，父类有该成员变量则编译通过，否则编译出错！ 运行时也看等号左边，有则运行结果 2）多态时访问方法,如uncle.smoke() 编译时看等号左边，父类有该成员方法则编译通过，否则编译出错！ 运行时看等号右边，父类有该方法，子类没有该方法执行父类方法；父类有该方法，子类也 有该方法执行子类方法 3）多态时访问静态方法 编译运行都看等号左边 ******************************************************************************* ******************************************************************************* ******************************************************************************* ********************* 4.抽象(有争议)： 什么是抽象？ 抽象就是不具体。 一般我们把不能具体描述的东西约定俗成为“抽象”的东西。例如：我们说一个人长得很 “抽象”,n你想你能具体形容描述出来么？ 在JAVA中如何描述抽象这个概念呢？ 我觉得在java中抽象类是由抽象方法而衍生出来的，为什么呢？ 因为Java规定一个类中定义了抽象方法那这个类就跟着必须定义为抽象类，而不是因 为先定义抽象类再跟着规定抽象类中的方法必须是抽象的，可能最后理解的结果是一样的但 性质是不一样的（个人理解）简单说：就是有抽象方法的类一定是抽象类，但是抽象类中不 一定都是抽象方法，也可以有具体方法。 首先就是当我要在一个类定义一个方法时，暂时我不知道该方法具体功能是什么；等我想好 了我在用他实现一个功能时我再具体描述他功能，这样我们就可以将这个方法用abstract关 键字修饰定义为抽象方法 （还有一点也就是什么时候定义抽象类的？也可以说抽象类是向上抽取而来的，就是几个类 据有共同的属性和方法，不想每个类都定义一次，那么定义一个公有类（即抽象类）其他类 只要继承抽象类再重写方法就行！） 例如：我有一百块钱，现在我不知道怎么用，等我想好了在具体怎么用！ abstract class Money{//因为有了抽象方法所以必须定义为抽象类 public abstract void buySomthing();//现在不知道怎么用，那就把它的功能代码体去掉 } //现在我饿了，想买东西吃了，我就知道怎么用了 class Hungry extends Money{ void buySomething(){ System.out.println(”我饿了，现在我要买东西吃！“) } } 抽象类的特点 1）抽象类不能实例化 2）抽象类可以继承抽象类 3）继承抽象类必须得重写抽象方法 5.抽象类，接口，普通类 的不同点和相同点？ 1）不同点： 普通类接口抽象类 可以直接实例化对象不可以直接实例化对象不可以直接实例化对象 可以定义任何成员只能定义抽象成员方法和常量成员 方法必须定义为抽象其他和普通类相同 可以被继承类可以实现接口，且可以实现多个接口可以被继承 接口可以继承多个接口抽象类有构造方 法，接口中不能有 抽象类有普通成员变 量，接口中没有 抽象类可以有非抽象方 法，接口中不能有 抽象类可以用public、protected修饰，接口中只能public（默认public） 抽象类包含静态方法，接 口中没有 接口中的变量只能是 public static final，抽象类中可以是任意类型修饰 2)相同点：都可以用于描述(封装)事物的,内部类分为哪几种？分别如何创建对象？ 分为 局部内部类，匿名内部类...3种 1）外部类名.内部类名 对象名＝new 外部类名（）.new 内部类名（） 2）外部类名.内部类名 对象名＝外部类名.new 内部类名（） 3）....不记得了第3种 匿名内部类 二、集合集合的定义？ 集合：用来保存一组数据的数据结构 集合的父接口，实现接口，实现类，实现类的常用方法是什么？(建议以树状图画出来，便 于加深印象)。 Collectionlistset ArraylistLinkedListHashSet TreeSet 1.List集合List集合的特征是元素可重复且有序 ；我们可以把他看成是一个动态数组，一般通过下标 访问 ArrayList和LinkedList最常用的两个子类实现 1)list可以使用for循环遍历 for（int i=;i list.get(i); } 2)list的浅层复制 调用ArraryList.clone()方法 注意：不能使用list.clone(),clone()方法是Object类的方法,list是接口是不能继承Object类的2.Set集合： 不重复且无序集 遍历set只能迭代器，用迭代器遍历集合遵循的操作原则:先问后取。问一次取一次。Iterator while(it.hashnext()){ E e=it.next(); } 3)map表 Map存储数据使用key-value(键-值)对的形式存储数据的。 对于Map而言，要求key值是唯一的。value值可以重复 获取数据时，使用key可以获取其对应的value 遍历map有3种方法 1）遍历key Set for(String key:keySet){ System.out.println(”key：“ + key); //可以根据每一个key获取其对应的value值 int value = map.get(key); 2)遍历value Collection Iterator while(it.hasNext()){ int value = it.next();//不能采用 map.next() System.out.println(”value:“ + value); 注意：通过迭代器在遍历集合的过程中，不能通过集合(即不能采用 map.next())去改变集合元素数量 3)遍历键值对 Set for(Entry //获取一组键值对的键和值 String key = entry.getKey(); int value = entry.getValue(); System.out.println(key + ”=" + value); Collection接口方法的定义 这里我主要列举 Iterator iterator()方法的使用 Collection提供的方法 Iterator iterator()方法来获取迭代器 Iterator是一个接口，定义了遍历集合应有的方法。 使用迭代器遍历集合遵循的操作原则:先问后取。问一次取一次。问：boolean hashNext() 取：Object next() 迭代器可以将取出的数据删除掉 删：remove()将当前获取的元素删除掉。 注意：1)删除的是next()取出的元素。且只能删除一次！ 2)调用1次next()后只能调用一次remove()! 达内学习心得：精心总结的面向对象 参赛学员：方钱有 获奖奖项：二等奖 什么面向对象: 个人分析觉得：在程序设计里,面向对象是一种相对说法，相对于面向过程而言的； 面向“对象“：即重点在于“对象”；而面向过程：则重点在于“过程”，简单说：就是我我们看待事物在眼光上注重点不一样；比如说：我们评判一个女孩漂亮与否，有的人看重外表，有的人则看重“心灵”，只是侧重点不一样。举个例子：把大象装进冰箱！ 面向过程 面向对象 （注重一系列动作即过程） （注重动作所操作的承受者［“对象”］） “打开”冰箱 “冰箱”打开 “装入”大象 “大象”装入 “关闭”冰箱 “冰箱”关闭 类：通俗的说类就是“一类事物的简称”，并且这些事物至少具有一点“共同的”特征.比如说：动物就是一个类 对象：就是某一类中一个具体的（就是可以具体描述出来的）东西，比如：动物(类)里的“狗”就是一个对象。(个人觉得对象相对于类而言的,因为狗又可以分好多种，‘狗’相对于‘哈士奇’是一个类,‘哈士奇’是‘狗’类的一个具体对象) 在生活中就拿描述汽车来说，我们都知道汽车都有4个轮子； 都有跑的功能 可以如下描述: 类 汽车 属性： 4个轮 功能： 跑 那么怎么在Java中描述汽车这类呢？ class car{ int wheel=4;//属性： 4个轮 void run(){//方法(功能)： 跑 System.out.println(“是汽车都会跑”); } } 那么可见“出租车”应当是“汽车”这类的一个具体化（实实在在的例子即“实例”）对象，那自然出租车也就具备了汽车这类所具备的“共有”属性功能！ 如何创建一个出租车对象呢？java中通过new关键字来创建一个类的实例即对象，也叫类的实例化，就是把类具体化成一个实例嘛！格式：类名 对象名 = mew 类名 () Car texi = new Car();创建了“出租车”对象（实例）之后那么它也就有了如下“自己”的属性和功能。 int wheel=4;//属性： 4个轮 void run(){//功能： 跑 System.out.println(“我是出租车我也会跑”); } 我们如何来访问对象中的它自己的属性和方法呢？ 格式：对象.属性； 对象.方法名(); 这一点也验证了面向对象编程的侧重点在于“对象”上； texi.wheel; texi.run()********************************************************************************************************************************************************************************************************************************************* 1.封装： 从字面可以解读为将东西封起来再装好。要想拿到里面的东西就得有相应的方法打开，才能拿到。 举例来说：一个房间的门如果没有上锁，那么大家都可以进去拿东西，但现在我们不想让谁都进来拿东西，我们可以将房门上锁，只对外提供一把钥匙，只有有钥匙的人才能进来，这就是“封装”现象！ 在java程序中，“封装”现象如何实现呢？ 可以这样实现：将类中的一些属性和方法用private关键字修饰，将他们“私有化（即不对外直接公开）”,使外部其他类不能通过创建该类对象或通过类名直接访问这些属性和方法;只对外提供公有的方法，外部其他类必须通过该类对外提供的公有方法来访问该类的相应成员；例如： class Person{ private String name;//将name属性私有化（封装）［相当于了上锁］使外部其他类不能直接访问到 public SetName(String name){//对外提供公有方法（相当于房门钥匙）供外部其他类访问到本类属性 this.name=name; } } 2.继承： 从字面来说继承就是子父类关系的简称，就是儿子（女儿也行，好吧）会继承老爸的一些属性和行为 在java中如何描述继承关系呢？ 注意： 第一得知道在java中继承是类与类之间或者是接口与接口之间才有继承关系；通过extends关键字来描述继承关系 例如：老爸这个类 class Dad{ String sex=man; void smoke(){ System.out.println(“老子会抽烟！”); } } 那么我们怎么来让儿子这个类继承老爸这个类呢？ class Son extends Dad{//通过extends关键字儿子这个类就继承老爸这个类了 String name;//定义自己的属性 String sex=man;//继承过来的属性，无须再定义，这里写出来是为了好理解 void smoke(){//继承过来的方法，无须再定义，这里写出来是为了好理解 System.out.println(“老子会抽烟！”); } void playBall(){//定义自己的方法 System.out.println(“儿子即会打球又会抽烟！”); } void somke(){//重写的方法 System.out.println(“我不抽20块以下的烟”); } void smoke(int n){//重载的方法 System.out.println(“我抽了+n+”年的烟了“); } } 那么具有继承关系的两个类有什么特点呢？ 1）子类会将父类的属性和方法继承过来，当然子类也可以自己定义的属性和方法 2）当子类自己定义的方法和父类继承过来的方法相同时会发生“重写“现象！3）父类用private关键字私有的方法是不能被继承的！4）子类可以使用super访问父类的属性和方法 5）子类通过重写父类方法，修改父类的功能 6）子类构造器一定调用父类的无参构造器 7）构造器不能继承 3.多态： 字面意思就是多种形态,也就是说一种事物同时局部多种形态.注意：要出现多态情况，那么类和类之间一定得是继承关系，或者类和接口是实现关系 我觉得：在java中多态是相对于一个对象而言的，就是父类型引用变量引用子类对象，并且父类型引用变量可以接受不同子类的对象 例如：拿上面的举例 Dad uncle=new Son();父类引用变量uncle即具备Son类的成员又具备父类的成员；这也称为“向上造型”； 多态时的特点 1）多态时访问成员变量，如uncle.name;编译时看等号左边，父类有该成员变量则编译通过，否则编译出错！运行时也看等号左边，有则运行结果 2）多态时访问方法,如uncle.smoke()编译时看等号左边，父类有该成员方法则编译通过，否则编译出错！运行时看等号右边，父类有该方法，子类没有该方法执行父类方法；父类有该方法，子类也有该方法执行子类方法 3）多态时访问静态方法 编译运行都看等号左边 ****************************************************************************************************************************************************************************************************************************************************************** 4.抽象(有争议)： 什么是抽象？ 抽象就是不具体。 一般我们把不能具体描述的东西约定俗成为“抽象”的东西。例如：我们说一个人长得很“抽象”,n你想你能具体形容描述出来么？ 在JAVA中如何描述抽象这个概念呢？ 我觉得在java中抽象类是由抽象方法而衍生出来的，为什么呢？ 因为Java规定一个类中定义了抽象方法那这个类就跟着必须定义为抽象类，而不是因为先定义抽象类再跟着规定抽象类中的方法必须是抽象的，可能最后理解的结果是一样的但性质是不一样的（个人理解）简单说：就是有抽象方法的类一定是抽象类，但是抽象类中不一定都是抽象方法，也可以有具体方法。首先就是当我要在一个类定义一个方法时，暂时我不知道该方法具体功能是什么；等我想好了我在用他实现一个功能时我再具体描述他功能，这样我们就可以将这个方法用abstract关键字修饰定义为抽象方法 （还有一点也就是什么时候定义抽象类的？也可以说抽象类是向上抽取而来的，就是几个类据有共同的属性和方法，不想每个类都定义一次，那么定义一个公有类（即抽象类）其他类只要继承抽象类再重写方法就行！） 例如：我有一百块钱，现在我不知道怎么用，等我想好了在具体怎么用！abstract class Money{//因为有了抽象方法所以必须定义为抽象类 public abstract void buySomthing();//现在不知道怎么用，那就把它的功能代码体去掉 } //现在我饿了，想买东西吃了，我就知道怎么用了 class Hungry extends Money{ void buySomething(){ System.out.println(”我饿了，现在我要买东西吃！“) } } 抽象类的特点 1）抽象类不能实例化 2）抽象类可以继承抽象类 3）继承抽象类必须得重写抽象方法 5.抽象类，接口，普通类 的不同点和相同点？ 1）不同点： 普通类 接口 抽象类 可以直接实例化对象 不可以直接实例化对象 不可以直接实例化对象 可以定义任何成员 只能定义抽象成员方法和常量 成员方法必须定义为抽象其他和普通类相同 可以被继承 类可以实现接口，且可以实现多个接口 可以被继承 接口可以继承多个接口 抽象类有构造方法，接口中不能有 抽象类有普通成员变量，接口中没有 抽象类可以有非抽象方法，接口中不能有 抽象类可以用public、protected修饰，接口中只能public（默认public） 抽象类包含静态方法，接口中没有 接口中的变量只能是public static final，抽象类中可以是任意类型修饰 2)相同点：都可以用于描述(封装)事物的，内部类分为哪几种？分别如何创建对象？ 分为 局部内部类，匿名内部类...3种 1）外部类名.内部类名 对象名＝new 外部类名（）.new 内部类名（）2）外部类名.内部类名 对象名＝外部类名.new 内部类名（）3）....不记得了第3种 匿名内部类 二、集合集合的定义？ 集合：用来保存一组数据的数据结构 集合的父接口，实现接口，实现类，实现类的常用方法是什么？(建议以树状图画出来，便于加深印象)。 Collection list set Arraylist LinkedList HashSet TreeSet 1.List集合 List集合的特征是元素可重复且有序 ；我们可以把他看成是一个动态数组，一般通过下标访问 ArrayList和LinkedList最常用的两个子类实现 1)list可以使用for循环遍历 for（int i=;i list.get(i);} 2)list的浅层复制 调用ArraryList.clone()方法 注意：不能使用list.clone(),clone()方法是Object类的方法,list是接口是不能继承Object类的 2.Set集合： 不重复且无序集 遍历set只能迭代器，用迭代器遍历集合遵循的操作原则:先问后取。问一次取一次。Iterator E e=it.next();} 3)map表 Map存储数据使用key-value(键-值)对的形式存储数据的。 对于Map而言，要求key值是唯一的。value值可以重复 获取数据时，使用key可以获取其对应的value 遍历map有3种方法 1）遍历key Set for(String key:keySet){ System.out.println(”key：“ + key); //可以根据每一个key获取其对应的value值 int value = map.get(key);2)遍历value Collection Iterator while(it.hasNext()){ int value = it.next();//不能采用 map.next() System.out.println(”value:“ + value);注意：通过迭代器在遍历集合的过程中，不能通过集合(即不能采用 map.next())去改变集合元素数量 3)遍历键值对 Set for(Entry //获取一组键值对的键和值 String key = entry.getKey(); int value = entry.getValue(); System.out.println(key + ”=" + value); Collection接口方法的定义 这里我主要列举 Iterator iterator()方法的使用 Collection提供的方法 Iterator iterator()方法来获取迭代器 Iterator是一个接口，定义了遍历集合应有的方法。 使用迭代器遍历集合遵循的操作原则:先问后取。问一次取一次。 问：boolean hashNext() 取：Object next() 迭代器可以将取出的数据删除掉 删：remove()将当前获取的元素删除掉。 注意：1)删除的是next()取出的元素。且只能删除一次！ 2)调用1次next()后只能调用一次remove()! 在达内为期两周的实习时间已悄然离去，刚来时的那种新鲜好奇早飞到了九霄云外，更多的是离开时的那种不舍和对自己及所学的反思。 当我第一天来这里时，和其他同学一样怀着兴奋得心情踏进达内IT培训中心，或许是单纯的对这个新环境的好奇、也或许是曾经对这儿有一点了解想亲自见证一下，因为听大二的学长说只有来到达内才能学到与学校不同的东西，才能更接近实际项目工程。的确如他们所说，运行程序前必须作许多准备工作，如：在ClassView内的CSDIDemoDoc文档内创建变量或增加成员函数；在ResourceView内创建快捷键或增加菜单项„„当然做成功一个项目必须先写好需求分析。 就这样既兴奋又好奇的跟着老师一步一步往下走，跟着在键盘上忙碌的敲代码、调整程序。实习时间慢慢的在减少，而程序却相反——越来越难，越来越繁。因为一个小环节与大家拉开了距离，在一个庞大的项目中是不允许任何一处掉链子的。看到同学们早已“轻车熟路”操作自如了，而我却不知所措，立刻就有了压力。一天下来感受最深的就是那种巨大的差距。学校所学与实际应用中的脱节。 在我困惑与迷茫时，老师给我解释说：“咱用的编程软件是VC6.0，更加注重的是对学生实战能力的培养，在学校所学专业知识的基础上让我们学习最新的编程技术，通过做项目的方式来让我们明白实践中的编程到底是怎样的„„”正是冀老师的耐心讲解让我重新找回了自信，几天下来从简单的c++程序到第一个win32程序，从MFC到第一个Dialog„„虽然程序中还是有太多的疑惑但更多的是增长了见识看清了差距。 通过实际项目的开发我有以下几点收获： 1.多向老师、同学虚心请教，也别说自己学的不怎么样，不然会大大减少自己的自信，从而与大家的差距越来越大。 2.编程以前一定要对整个项目有仔细的了解，最好能写好需求分析，这样在实际操作时就会更加调理，而且不会遗漏东西。 3.做任何项目都离不开团队合作。所以我们一定要注意团队合作意识，多和小组内的人交流。 4.在编程中一定要规范，绝对不可以随性 在达内的这半个月培训我感觉获益匪浅。虽然与课本知识不同，至少我看清了实际做项目与书本知识之间的差距，不至于在就业后手足无措。这次实习对我以后的学习甚至就业带来了巨大的帮助。 感谢学校，感谢达内的王老师，冀老师。第二篇：达内培训总结
第三篇：达内学习心得：精心总结的面向对象
第四篇：达内学习心得：精心总结的面向对象
第五篇：达内IT培训学习心得
点击咨询 