达内学习心得：Oracle_11g常用SQL语句(高级工程师必备)[精选五篇]

第一篇：达内学习心得：Oracle_11g常用SQL语句(高级工程师必备)

达内学习心得：Oracle_11g常用SQL语句（高级工程师必备）

参赛学员：吴贤志 获奖奖项：三等奖

--退出 SQLPLUS exit;

--修改 system(sys)账号密码 SQLPLUS /NOLOG CONN /AS SYSDBA ALTER USER SYSTEM IDENTIFIED BY tarring;

--清除 SQLPLUS 屏幕 CLEAR SCREEN;CL SCR;

--查看数据文件位置

SELECT NAME FROM v$datafile;

--查看控制文件位置

SELECT NAME FROM v$controlfile;

--查看日志文件位置

SELECT MEMBER FROM v$logfile;

--建立表空间

CREATE TABLESPACE ts01

DATAFILE 'D:DataBaseOracle11goradataorcltest_db01.dbf'SIZE 100M AUTOEXTEND ON NEXT 100M MAXSIZE 1024M DEFAULT STORAGE(INITIAL 10m NEXT 1M)PERMANENT ONLINE LOGGING;

--修改表空间

ALTER TABLESPACE ts01 NOLOGGING;

--表空间增加数据文件 ALTER TABLESPACE ts01

ADD DATAFILE 'D:DataBaseOracle11goradataorcltest_db02.dbf'SIZE 100M REUSE AUTOEXTEND ON NEXT 100M MAXSIZE UNLIMITED;

--删除表空间 DROP TABLESPACE ts01;

--删除表空间同时删除数据文件

DROP TABLESPACE ts01 INCLUDING CONTENTS AND DATAFILES;

--表空间中建表

CREATE TABLE student(student_id VARCHAR2(10), student_name VARCHAR2(20))TABLESPACE ts01;

--查看表所属表空间

SELECT TABLE_NAME, TABLESPACE_NAME FROM tabs WHERE TABLE_NAME = 'STUDENT';

--查看表结构

DESCRIBE student;DESC student;

--增加表注释

COMMENT ON TABLE student IS '学生信息表';

--查看表注释

SELECT * FROM USER_TAB_COMMENTS WHERE TABLE_NAME = 'STUDENT';SELECT * FROM ALL_TAB_COMMENTS WHERE TABLE_NAME = 'STUDENT';

--表字段增加注释

COMMENT ON COLUMN STUDENT.STUDENT_ID IS '学生编号';

--查看表字段注释

SELECT * FROM USER_COL_COMMENTS WHERE TABLE_NAME = 'STUDENT';SELECT * FROM ALL_COL_COMMENTS WHERE TABLE_NAME = 'STUDENT';

--查看用户所有表

SELECT * FROM User_Tables;

--查看用户拥有的所有对象 SELECT * FROM User_Objects;

--查看用户拥有的 表 试图 序列 SELECT * FROM User_Catalog;

--表字段修改

ALTER TABLE student MODIFY(student_id CHAR(15));

--表字段增加

ALTER TABLE STUDENT ADD(AGE NUMBER(2));

--删除表字段

ALTER TABLE STUDENT DROP COLUMN student_name;

--修改表名称

RENAME STUDENT TO STU;

--删除表

DROP TABLE STUDENT;

CREATE TABLE student(s_id Varchar2(10), s_name varchar2(20), s_age Number(3), s_birthday DATE)TABLESPACE ts01;

--增加一条记录 INSERT INTO student(s_id, s_name, s_age, s_birthday)

VALUES('S000000001', 'Tarring01', 10, to_date('1982-10-06','yyyy-mm-dd'));

INSERT INTO student(s_id, s_name, s_age, s_birthday)

VALUES('S000000002', 'Tarring02', 10, Sysdate);

--使用替代变量时，输入字符串字段时一样要写上引号 INSERT INTO student(s_id, s_name, s_age, s_birthday)VALUES(&s_id, &s_name, 10, Sysdate);

--修改记录

UPDATE student SET s_name = '陶川', s_age = 20 WHERE s_id = 'S000000002';

--删除记录

DELETE FROM student WHERE s_id = 'S000000002';

--截断表

TRUNCATE TABLE student;

--事务处理 COMMIT;--提交事务

INSERT INTO student(s_id, s_name)VALUES('S001', 'tarring1');ROLLBACK;--回滚，回滚到上一次提交过后的点

--带恢复点的事务 COMMIT;INSERT INTO student(s_id, s_name)VALUES('S001', 'tarring1');SAVEPOINT firstdate;INSERT INTO student(s_id, s_name)VALUES('S002', 'tarring2');SAVEPOINT seconddate;DELETE FROM student;ROLLBACK TO firstdate;SELECT * FROM student;

--约束条件

说明

--------UNIQUE

指定字段的值，必须是唯一的

--PRIMARY KEY

主键，会为指定的字段作索引，并且也是唯一的值--NOT NULL

不可以是空值【'' NULL】或0（零）--CHECK

检查，必须符合指定的条件

--FOREIGN KEY

外键，用来创建一个参考表之间的关系

--建表同时建立唯一约束 CREATE TABLE student(s_id Varchar2(10), s_name varchar2(20), s_age Number(3), s_birthday DATE, CONSTRAINT s_name_uk UNIQUE(s_name))TABLESPACE ts01;

--查看唯一约束

SELECT table_name, constraint_name, constraint_type FROM User_Constraints WHERE table_name = 'STUDENT';

--作业：数据字典【分类 常用】

--建表同时建立主键 CREATE TABLE student(s_id Varchar2(10), s_name varchar2(20), s_age Number(3), s_birthday DATE, CONSTRAINT s_id_pk PRIMARY KEY(s_id))TABLESPACE ts01;

--查看主键约束

SELECT table_name, constraint_name, constraint_type FROM User_Constraints WHERE table_name = 'STUDENT';

--建表同时建立非空字段 CREATE TABLE student(s_id Varchar2(10), s_name varchar2(20)NOT NULL, s_age Number(3), s_birthday DATE, CONSTRAINT s_id_pk PRIMARY KEY(s_id))TABLESPACE ts01;

INSERT INTO student(s_id, s_name)VALUES('S001', NULL);--插入一个null

--查看非空约束

SELECT table_name, constraint_name, constraint_type, search_condition User_Constraints WHERE table_name = 'STUDENT';

--建表同时建立检查 CREATE TABLE student(s_id Varchar2(10), s_name varchar2(20), s_age Number(3), s_birthday DATE, CONSTRAINT s_age_ck CHECK(s_age BETWEEN 1 AND 100)--端点值可以使用)TABLESPACE ts01;

--查看检查约束

SELECT table_name, constraint_name, constraint_type, search_condition User_Constraints WHERE table_name = 'STUDENT';

--外键的使用

CREATE TABLE team(t_id Varchar2(10), t_name Varchar2(20), CONSTRAINT t_id_pk PRIMARY KEY(t_id))TABLESPACE ts01;

CREATE TABLE student(s_id Varchar2(10)，FROM FROM team_id VARCHAR2(10), s_name varchar2(20), CONSTRAINT s_id_pk PRIMARY KEY(s_id), CONSTRAINT s_team_id_fk FOREIGN KEY(team_id)REFERENCES team(t_id))TABLESPACE ts01;

--查看表的外键约束

SELECT table_name, constraint_name, constraint_type FROM User_Constraints WHERE table_name = 'STUDENT';

drop table team;--被引用表是不能删除的

insert into team(t_id, t_name)values('t001', 'lansene');insert into student(s_id, s_name, team_id)values('s001','tarring', 't001');delete from team;--被引用的记录是不能删除的

--关闭一个约束

ALTER TABLE student DISABLE CONSTRAINT s_team_id_fk;

--启用一个约束

ALTER TABLE student ENABLE CONSTRAINT s_team_id_fk;

--删除一个约束

ALTER TABLE student DROP CONSTRAINT s_team_id_fk;

--已创建的表增加一个约束

ALTER TABLE student ADD CONSTRAINT s_team_id_fk FOREIGN KEY(team_id)REFERENCES team(t_id);

/********************************************************************************************| |

SQL语句5大类型

| 命令

| 说明

| |********************************************************************************************| | Data Retrieval数据检索

| select

| 查询记录

| |********************************************************************************************| | Date Manipulation Language【DML】数据操纵语言 | insert

| 添加记录

| |

| update

| 修改记录

| |

| delete

| 删除记录

| |********************************************************************************************| | Data Definition Language【DDL】数据定义语言

| create

| 创建

| |

| alter

| 修改

| |

| drop

| 丢弃【删除】

| |

| rename

| 重命名

| |

| truncate | 截断

| |********************************************************************************************| | Transaction Control事务控制

| commit

| 确认命令

| |

| rollback | 回退至前一次确认的命令或保存点 | |

| savepoint | 设置保存点

| |********************************************************************************************| | Data Control Language【DCL】数据控制语言

| grant

| 授予权限

| |

| revoke

| 撤消权限

| |********************************************************************************************/

/*************************************| |

系统权限

|

说明

| |*************************************| |

create session

| 连接数据库

| |*************************************| |

create table

| 创建表

| |*************************************| |

create sequence

| 创建序列

| |*************************************| |

create view

| 创建视图

| |*************************************| |

create proceduer

| 创建程序

| |*************************************/

/*******************************************************************| |

对象 | 表【table】 | 视图【view】 | 程序【procedure】

| | 权限

|

|

|

| |*******************************************************************| |

insert

|

Y

|

Y

|

| |*******************************************************************| |

alter

|

Y

|

|

| |*******************************************************************| |

update

|

Y

|

Y

|

| |*******************************************************************| |

delete

|

Y

|

Y

|

| |*******************************************************************| |

select

|

Y

|

Y

|

| |*******************************************************************| |

index

|

Y

|

|

| |*******************************************************************| |

execute

|

|

|

Y

| |*******************************************************************/

--创建用户

CREATE USER u01 IDENTIFIED BY p01;

--创建用户并制定默认表空间

CREATE USER u01 IDENTIFIED BY p01 DEFAULT TABLESPACE QUOTA 2M ON ts01;--quota 表空间中可使用的配额

--修改用户密码

ALTER USER u01 IDENTIFIED BY p001;

--修改用户表空间配额

ALTER USER u01 QUOTA 20M ON ts01;ALTER USER u01 QUOTA UNLIMITED ON ts01;--用户对表空间没有配额限制

--回收unlimited tablespace权限

REVOKE UNLIMITED TABLESPACE FROM ts01;

--删除用户

DROP USER u01;

--切换连接数据库的用户 CONNECT u01/p01;conn u01/p01;

--授权用户连接数据库的权限

GRANT CREATE SESSION TO u01;

--授权用户创建序列(sequence)的权限 GRANT CREATE sequence TO u01;

--授权用户创建表的权限

GRANT CREATE TABLE TO u01;--授权用户查表的权限

grant select on ts01.user1 to wangkai；--授权用户修改表的权限

grant alter on user1 to wangkai；

--授权用户删除表的权限(没有此权限)grant drop on user1 to wangkai；(错误)--授权用户对一个表的所有权限 grant all on user1 to wangkai;

--授权所有用户对一个表的所有权限 grant all on user1 to public;

--收回用户创建表的权限

REVOKE CREATE TABLE FROM u01;--收回用户查表的权限

REVOKE select on user1 FROM u01;--收回用户修改的权限

REVOKE select on user1 FROM u01;--收回用户对一个表的所有权限 revoke all on user1 from wangkai;--收回所有用户对一个表的所有权限 revoke all on user1 to public;

--创建角色

CREATE ROLE r01;

--角色授权

GRANT CREATE SESSION, CREATE TABLE TO r01;

--收回角色权限

REVOKE CREATE TABLE FROM r01;

--查看角色权限

SELECT ROLE,PRIVILEGE FROM role_sys_privs WHERE ROLE='R01'

--角色赋给用户 GRANT r01 TO u01;

--查看当前用户角色

SELECT * FROM user_role_privs;

--删除角色

DROP ROLE r01;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

} }

第四篇：达内Java学习心得-第一个月

学习心得

七月之始，我们的达内java班又开始正式上课了，从上课第一天到现在，已经有一个月了，在这短暂的一个月里，我学到是java的基础知识，重点是JavaSE。感觉时间过的是非常快的，短短一个月就这样被我们给熬过去了，当中既有心酸也有快乐。

学习之初，有着一点点的不适应，首先是时间段的不适应，每天有这规定的时间上课，下课，休息。或许是在大学这个懒散的环境下，我们已经渐渐的远离了规定与约束，过分的放纵自己。随着时间的一天天过去，慢慢的，我们开始适应了这种学习的时间安排以及这样的学习氛围，从一种自由放纵中摆脱出来，有了所谓的上进心，开始了各自的Java之路。

在这段时间里，自己感觉最明显的就是打字速度和以前相比有了明显的提升，此外就是对一些基本的代码的理解和运用有了一定自己的意识。这两点是最明显的变化。个人感觉学了这些基本知识之后，对于Java的认识上的确有了一个提升，起初对它的认识感觉和其他的编程语言应该没有多大区别，但是学完这些这些基本的知识之后，我的认识是Java很强大，我们需要不断地去学，更多的是要不断的去敲，把它练熟，这样自己在从业的时候才会有底气，敢于和别人去竞争。

虽然我们的课堂是看视频来学习，但是个人觉得只要是能学到知识，这些学的形式只是一种次要的因素而已，对于一个想要学习的人来说，他每时每刻都在学习者，因为他爱学习。有了这一个月的学习经历之后，感觉自己当初选择达内来学习Java是一个正确的选择，我相信我只要有学习渴望，达内一定能给我所要学的。一个都不爱学习的人，你给他再好的学习环境和最好的学习条件，无亚于对牛弹琴，无动于衷。结果还有一个浪费资源，浪费精力。

整个学习的时间是四个月，对于余下的三个月，我拭目以待，相信自己一定能够在有限的时间内能够学好这一门语言，为自己以后多一个机会。

相信，我可以！

第五篇：达内学习心得：精心总结的面向对象

达内学习心得：精心总结的面向对象

参赛学员：方钱有

获奖奖项：二等奖

什么面向对象:

个人分析觉得：在程序设计里,面向对象是一种相对说法，相对于面向过程而言的；

面向“对象“：即重点在于“对象”；而面向过程：则重点在于“过程”，简单说：就是我我们看待事物在眼光上注重点不一样；比如说：我们评判一个女孩漂亮与否，有的人看重外表，有的人则看重“心灵”，只是侧重点不一样。

举个例子：把大象装进冰箱！

面向过程面向对象（注重一系列动作即过程）（注重动作所操作的承受者［“对象”］）

“打开”冰箱“冰箱”打开“装入”大象“大象”装入“关闭”冰箱“冰箱”关闭

类：通俗的说类就是“一类事物的简称”，并且这些事物至少具有一点“共同的”特征.比如说：动物就是一个类

对象：就是某一类中一个具体的（就是可以具体描述出来的）东西，比如：动物(类)里的“狗”就是一个对象。(个人觉得对象相对于类而言的,因为狗又可以分好多种，‘狗’相对于‘哈士奇’是一个类,‘哈士奇’是‘狗’类的一个具体对象)

在生活中就拿描述汽车来说，我们都知道汽车都有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 it=set.iterator();

while(it.hashnext()){

E e=it.next();

}

3)map表

Map存储数据使用key-value(键-值)对的形式存储数据的。

对于Map而言，要求key值是唯一的。value值可以重复

获取数据时，使用key可以获取其对应的value

遍历map有3种方法

1）遍历key

Set keySet = map.keySet();

for(String key:keySet){

System.out.println(”key：“ + key);

//可以根据每一个key获取其对应的value值

int value = map.get(key);

2)遍历value

Collection values = map.values();

Iterator it = values.iterator();

while(it.hasNext()){

int value = it.next();//不能采用 map.next()

System.out.println(”value:“ + value);

注意：通过迭代器在遍历集合的过程中，不能通过集合(即不能采用 map.next())去改变集合元素数量

3)遍历键值对

Set> entries= map.entrySet();

for(Entry entry : entries){

//获取一组键值对的键和值

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()!