JAVA面向物件小程式(二)：俄羅斯方塊s
今天，我們來使用Eclipse製作一個小遊戲《Tetris~》
資源在文末
一、遊戲機制
a) 7種小塊兒隨機生成
i. 一塊放置在頂部(隨時間下降)
ii. 另一塊置於右側，提示下一個隨機生成塊
iii. 七種形狀：“O、L、J、I、T、S、Z”
b) 牆與邊界
i. 小塊的移動範圍在邊框之內；
ii. 第一個小塊下降到最底部，觸底碰“牆”，自身嵌入“牆”；
iii. 下一小塊兒的其中某個小方格，底部碰到“牆”，自身嵌入“牆”；
c) 小塊兒的下降、左移、右移、旋轉與平移
i. 新增鍵盤監聽事件
ii. 不允許方塊的越界
iii. 確定旋轉中心，以旋轉中心的相對位置做其餘小塊的行列號修改
d) 消除與積分
i. 當某一排(col)被小方格佔滿，消除某一排
ii. 被消除排 的上方所有小方塊
iii. 積分累加
f) 遊戲的三種狀態：下落、暫停與重新開始
g) 遊戲結束的條件
i. 最上方的生成區域被佔，GameOver
二、設計需求 / 程式設計思想
【遵循javabean規範】
(1)新增兩個(至少)構造器【一個無引數，一個有引數】
(2)屬性一般為私有化【外部類訪問不到】
(3)提供公有的get/set 【提供訪問途徑】
(4)toString用來描述物件資訊
重寫toString屬性的資訊
(5)重寫equals 【物件的值】
(6)重寫hashCode 【物件的雜湊碼(地址)】
幾大部件：【我們要把這幾個傢伙抽象到類 (class) 中】
1.單個的小方格——class Cell
俄羅斯方塊中的最小單位：小方格
* 特徵：屬性
* row--行號
* col--列號
* image--對應圖片
*
* 行為：
* 向左移動
* 向右移動
* 向下移動
對於image屬性，我們可以新增BufferImage類的物件image
記得導包(import)
2.每個不同形狀的四小塊兒組(7種形狀)——class X extends Tetromino
形狀有：O、L、J、I、T、S、Z
* Cell類繼承4塊整體(Trtromino)的屬性
* 構造器初始化
* Cell[] cells = new Cell[4];
* Cell(行號，列號，BufferedImage image)構造器
整體的四種狀態（旋轉），其中S、Z、I型可以只有兩種狀態，O只有一種狀態
*states = new State[4];
*
*/
3.四個小方格組成一個塊兒組——class Tetromino
四格方塊作為一個整體
共同特徵：七種組合的父類
cell--四個方塊(Cell 陣列存放)--protected Cell[ ] cells = new Cell[4]; //4個小方格建立，初值為null
修飾詞protected【子類可訪問】
====================================================================
共同行為：向左向右..
* 屬性：
* 4cells
* 行為：
* 重寫toString
*
* moveLeft()
* moveRight()
* softDrop()軟下降——【按鍵盤'↓'只降一格】
=====================================================================
四種狀態：（相對與旋轉中心）
按照順時針順序：
4.主類——Tetris--------- extends JPanel
此類作為程式的入口，載入靜態資源【圖片緩衝區】
擁有主方法main(){}
在主方法中新增：
1.JFrame(窗體框框)
2.JPanel(面板&畫筆)
（1）.面板會自動呼叫繪製方法paint(Graphics g)
（2）.重寫paint方法，繪製圖片背景
（3）.繪製網格和嵌入牆中的方塊
3.在Panel中呼叫主邏輯start( )
====================================================================
把遊戲的主邏輯封裝入start( )方法中
1.KeyListener(開啟鍵盤監聽)
封裝匿名內部類 keyPressed(KeyEvent e){
【注意：k要小寫】
【Action後馬上重繪】
repaint();
}；
2.面板新增監聽事件
3.當前物件設定成焦點
4.設定程式睡眠【每300ms生成新的小塊兒】
三、程式碼實現
首先強調，Leo遵循的編寫順序為：
(1).Cell類——小細胞
(2).Tetromino類——四個小細胞組成一個整體
(3).七種形狀類“O、L、J、I、T、S、Z”——繼承Tetromino的屬性和行為
(4).最後是主類Tetris——作為遊戲的主邏輯和程式的入口
1.Cell類
import java.awt.image.BufferedImage;
/*
* 俄羅斯方塊中的最小單位：小方格
* 特徵：屬性
* row--行號
* col--列號
* image--對應圖片
*
* 行為：
* 向左
* 向右
* 向下
*/
public class Cell {
private int row; //行號
private int col; //列號
private BufferedImage image;
public Cell(int row, int col, BufferedImage image) {
super();
this.row = row;
this.col = col;
this.image = image;
}
public int getRow() {
return row;
}
public void setRow(int row) {
this.row = row;
}
public int getCol() {
return col;
}
public void setCol(int col) {
this.col = col;
}
public BufferedImage getImage() {
return image;
}
public void setImage(BufferedImage image) {
this.image = image;
}
public void left(){
col --;
}
public void right(){
col ++;
}
public void drop(){
row ++;
}
@Override
public String toString() {
return "(" + row + ", " + col + ")" ;
}
}2.Tetromino類
import java.util.Arrays;
/*
* 4格方塊作為一個整體
* 屬性：
* 4cells
* 行為：
* 重寫toString
*
* moveLeft()
* moveRight()
* softDrop()軟下降，按↓箭頭只下移一個單位
*/
public class Tetromino {
protected Cell[] cells = new Cell[4]; //4個null
//每個方塊都向左 一個單位移動
public void moveLeft(){
for (int i = 0; i < cells.length; i++) {
Cell cell = cells[i];
cell.left();
}
}
//每個方塊都向右 一個單位移動
public void moveRight(){
for (int i = 0; i < cells.length; i++) {
Cell cell = cells[i];
cell.right();
}
}
//每個方塊都向下 一個單位移動
public void softDrop(){
//強迴圈陣列遍歷
for(Cell c:cells){
c.drop();
}
}
@Override
public String toString() {
return Arrays.toString(cells) ;
}
public static Tetromino randomOne(){
//隨機生成4格方塊
//四小塊作為一整體，t賦為null
Tetromino t = null ;
int num = (int)(Math.random()*7);
switch(num){
case 0:t=new T();break;
case 1:t=new O();break;
case 2:t=new L();break;
case 3:t=new J();break;
case 4:t=new I();break;
case 5:t=new Z();break;
case 6:t=new S();break;
}
return t;
}
public static Tetromino randomOne(){
//隨機生成4格方塊
//四小塊作為一整體，t賦為null
Tetromino t = null ;
int num = (int)(Math.random()*7);
switch(num){
case 0:t=new T();break;
case 1:t=new O();break;
case 2:t=new L();break;
case 3:t=new J();break;
case 4:t=new I();break;
case 5:t=new Z();break;
case 6:t=new S();break;
}
return t;
}
//旋轉四格方塊：順時針
public void rotateRight(){
//旋轉一次，計數器自增1
count++;
State s = state[count%state.length];
//需要獲取軸的行號和列號
Cell c = cells[0];
int row = c.getRow();
int col = c.getCol();
cells[1].setRow(row+s.row1);
cells[1].setCol(col+s.col1);
cells[2].setRow(row+s.row2);
cells[2].setCol(col+s.col2);
cells[3].setRow(row+s.row3);
cells[3].setCol(col+s.col3);
}
//旋轉四格方塊：逆時針
public void rotateLeft(){
//旋轉一次，計數器自減1
count--;
State s = state[count%state.length];
//需要獲取軸的行號和列號
Cell c = cells[0];
int row = c.getRow();
int col = c.getCol();
cells[1].setRow(row+s.row1);
cells[1].setCol(col+s.col1);
cells[2].setRow(row+s.row2);
cells[2].setCol(col+s.col2);
cells[3].setRow(row+s.row3);
cells[3].setCol(col+s.col3);
}
/*
* 定義內部類，用於封裝每次
* 旋轉後的相對於軸的其他三個小格子的行列號
*/
public class State{
/*
* 設定8個座標int
* 分別儲存四格方塊元素的相對位置
*/
int row0,col0;
int row1,col1;
int row2,col2;
int row3,col3;
public State() {}
public State(int row0, int col0, int row1, int col1, int row2, int col2, int row3, int col3) {
super();
this.row0 = row0;
this.col0 = col0;
this.row1 = row1;
this.col1 = col1;
this.row2 = row2;
this.col2 = col2;
this.row3 = row3;
this.col3 = col3;
}
}3.七種形狀方塊兒 X 類——extends Tetromino
下面以“T”形狀為例
public class T extends Tetromino{
/*
* 繼承4塊整體(Trtromino)的屬性
* 構造器初始化
* T型四格方塊的位置
* 000000
* 00
*/
public T(){
/*
* Cell[] cells = new Cell[4];
* Cell(行號，列號，BufferedImage image)構造器
*/
cells[0]= new Cell(0,4,Tetris.T); // 初始狀態旋轉中心的座標
cells[1]= new Cell(0,3,Tetris.T); // 初始狀態1號小細胞..
cells[2]= new Cell(0,5,Tetris.T); // 初始狀態2號...
cells[3]= new Cell(1,4,Tetris.T); // ...
state = new State[4]; // 【注意】,不要重新宣告State,在Tetromino.class中已宣告過了
//第一個狀態
state [0] = new State(0,0, 0,-1, 0,1, 1,0);
//第二個狀態
state [1] = new State(0,0, -1,0, 1,0, 0,-1);
state [2] = new State(0,0, 0,1, 0,-1, -1,0);
state [3] = new State(0,0, 1,0, -1,0, 0,1);
}
}4.Tetris主類——extends JPanel（待續）
import java.awt.Graphics;
import java.awt.event.KeyAdapter;
import java.awt.event.KeyEvent;
import java.awt.event.KeyListener;
/*
* 俄羅斯方塊的主類：
* 前提： 一塊麵板JPanel，可以嵌入視窗
* 面板上自帶一個畫筆，有一個功能，自動繪製。
* 呼叫了JPanel
* 載入靜態資源
*
*/
import java.awt.image.BufferedImage;
import java.util.Arrays;
import javax.imageio.ImageIO;
import javax.swing.JFrame;
import javax.swing.JPanel;
public class Tetris extends JPanel{
/*
* 俄羅斯方塊的主類
* 功能： 1.載入靜態資源(背景圖，7種形狀的原始圖)
* 2.設定視窗
* 3.重寫JPanel中的paint()方法，構造器中新增畫筆Graphics g
* 前提：是一塊麵板Panel，可被嵌入視窗
* 屬性：1.正在下落的方塊
* 2.即將下落的方塊
* 3.新增牆(方格)，畫舉矩形
*
*/
//屬性：正在下落的方塊
private Tetromino currentOne = Tetromino.randomOne();
//屬性：即將下落的方塊
private Tetromino nextOne = Tetromino.randomOne();
//屬性：牆 20行10列的方格
private Cell[][] wall= new Cell[20][10];
//屬性：統計分數
int [] scoresPool = {0,1,3,5,10};
private int totalScore = 0;
private int totalLine = 0;
//圖片載入：靜態
private static final int CELL_SIZE = 26;
public static BufferedImage T;
public static BufferedImage I;
public static BufferedImage O;
public static BufferedImage J;
public static BufferedImage L;
public static BufferedImage S;
public static BufferedImage Z;
public static BufferedImage background;
static {
try{
/*
* getResource(String url)
* url:載入圖片的路徑
* 操作：將圖片檔案拖入package Tetris_Day01
* 相對位置是同一個包下
*/
T = ImageIO.read(Tetris.class.getResource("T.png"));
I = ImageIO.read(Tetris.class.getResource("I.png"));
O = ImageIO.read(Tetris.class.getResource("O.png"));
J = ImageIO.read(Tetris.class.getResource("J.png"));
L = ImageIO.read(Tetris.class.getResource("L.png"));
S = ImageIO.read(Tetris.class.getResource("S.png"));
Z = ImageIO.read(Tetris.class.getResource("Z.png"));
background = ImageIO.read(Tetris.class.getResource("tetris.png"));
}catch (Exception e) {
e.printStackTrace();
}
}
/*
* 重寫JPanel中的paint()方法
*/
public void paint(Graphics g){
//繪製背景(圖片，橫座標，縱座標，observer)
/*
* g是畫筆
* g.drawImage(image,x,y,null)
* x,y為開始繪製時的座標
*/
g.drawImage(background, 0, 0, null);
//平移座標軸
g.translate(15, 15);
//繪製牆
paintWall(g);
//繪製正在下落的4格方塊
paintCurrentOne(g);
//繪製下一個將要繪製的4格方塊
paintNextOne(g);
}
/*
* 繪製下一個將要繪製的4格方塊
* 繪製到右上角相應區域
*/
public void paintNextOne(Graphics g) {
//獲取Next物件的4個小方格
Cell[] cells = nextOne.cells;
for (Cell c : cells){
//獲取每一個元素的行列號
int row = c.getRow();
int col = c.getCol();
//橫座標
int x = col*CELL_SIZE+260;
int y = row*CELL_SIZE+26;
g.drawImage(c.getImage(), x, y, null);
}
}
public void paintCurrentOne(Graphics a){
//Cell型別的陣列指向 4方格整體的物件currentOne的cells陣列
Cell[] cells = currentOne.cells;
for (Cell c : cells) {
int x = c.getCol()*CELL_SIZE;
int y = c.getRow()*CELL_SIZE;
a.drawImage(c.getImage(), x, y, null);
}
}
public void paintWall(Graphics a){
//外層迴圈控制行數
//內層迴圈控制列數
for (int i = 0; i < 20; i++) {
for (int j = 0; j < 10; j++) {
int x = j * CELL_SIZE;
int y = i * CELL_SIZE;
Cell cell = wall[i][j];
if(cell == null)
{
a.drawRect(x , y, CELL_SIZE, CELL_SIZE);
}else {
a.drawImage(cell.getImage(),x,y,null);
}
}
}
}
//所有的主邏輯
public void start(){
//開啟鍵盤監聽事件
KeyListener l = new KeyAdapter(){
//匿名內部類
@Override
public void keyPressed(KeyEvent e) {
int code = e.getKeyCode();
switch(code){
case KeyEvent.VK_DOWN:
softDropAction();break;
case KeyEvent.VK_LEFT:
moveLeftAction();break;
case KeyEvent.VK_RIGHT:
moveRightAction();break;
case KeyEvent.VK_UP:
rotateRightAction();break;
case KeyEvent.VK_SPACE:
handDropAction();
}
//Action後馬上重繪
repaint();
}
};
//面板新增監聽事件
this.addKeyListener(l);
//當前物件設定成焦點
this.requestFocus();
while(true){
/*
* 當程式執行到此，進入睡眠狀態
* 睡眠時間為300毫秒
*/
try {
Thread.sleep(900);
} catch (InterruptedException e) {
//打斷異常
e.printStackTrace();
}
//判斷可以下落
if(canDrop()){
currentOne.softDrop();
}else{
landToWall();
//將下一個下落的四格方塊賦值給CurrentOne
destroy();
currentOne = nextOne;
nextOne = Tetromino.randomOne();
}
/*
* 下落之後，重新進行繪製
* 才會在看到下一步的動作
* repaint方法，也是JPanel類的方法
* 此方法呼叫paint
*/
repaint();
}
}
/*
*滿一行就消除，上方所有方塊向下移
*/
public void destroy(){
//統計銷燬行的次數
int lines = 0;
Cell[] cells = currentOne.cells;
for (Cell c : cells){
//取出每個元素的行號
int row = c.getRow();
while (row<20){
if(isFullLine(row)){
lines++;
wall[row] = new Cell[10];
for(int i = row;i>0;i--){
System.arraycopy(wall[i-1], 0, wall[i], 0, 10);
}
wall[0] = new Cell[10];
}
row++;
}
}
totalScore += scoresPool[lines];
}
//判斷行是否為
public boolean isFullLine(int row) {
Cell[] line = wall[row];
for(Cell r : line){
if(r == null){
return false;
}
}
return true;
}
//順時針旋轉的動作
public void rotateRightAction() {
currentOne.rotateRight();
//先判斷越界，再判斷重合
if(outOfBounds()||coincide()){
currentOne.rotateLeft();
}
}
protected void moveRightAction() {
currentOne.moveRight();
//先判斷越界，再判斷重合
if(outOfBounds()||coincide()){
currentOne.moveLeft();
}
}
//監聽使用left鍵控制向左的行為
protected void moveLeftAction() {
currentOne.moveLeft();
//先判斷越界，再判斷重合
if(outOfBounds()||coincide()){
currentOne.moveRight(); //越界，到-1，再移動回來
}
}
//判斷越界
public boolean outOfBounds(){
Cell[] cells = currentOne.cells;
for(Cell c : cells){
int col = c.getCol();
int row = c.getRow();
if(col<0 || col>9 || row>19 || row<0){
return true;
}
}
return false;
}
//判斷重合
public boolean coincide(){
Cell[] cells = currentOne.cells;
for(Cell c:cells){
int row = c.getRow();
int col = c.getCol();
if(wall[row][col]!=null){
return true;
}
}
return false;
}
public void softDropAction(){
if(canDrop()){
currentOne.softDrop();
}else{
//將下一個下落的四格方塊賦值給CurrentOne
landToWall();
destroy();
currentOne = nextOne;
nextOne = Tetromino.randomOne();
}
}
public void handDropAction(){
// while(canDrop()){
//
// }
for(;;){
if(canDrop()){
currentOne.softDrop();
}else{
break;
}
}
landToWall();
destroy();
currentOne = nextOne;
nextOne = Tetromino.randomOne();
}
public boolean canDrop(){
Cell[] cells = currentOne.cells;
/*
* 4格拿出來，遍歷
*/
for(Cell c:cells){
/*
* 獲取每個元素的行、列號
* 判斷:只要有一個元素的下一行有塊
* 或 有一個元素到最後一行
* 就不能下落了
*/
int row = c.getRow();
int col = c.getCol();
if(row == 19){
return false;
}
if(wall[row+1][col]!=null){
return false;
}
}
return true;
}
public void landToWall(){
Cell[] cells = currentOne.cells;
/*
* 4格拿出來，遍歷
*/
for(Cell c:cells){
int row = c.getRow();
int col = c.getCol();
wall[row][col] = c;
}
}
public static void main(String[] args) {
//1.建立視窗物件
JFrame frame = new JFrame("Tetris~");
frame.setVisible(true); //2.可見性
frame.setSize(535, 580); //3.size
frame.setLocationRelativeTo(null); //4.居中
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); //5.關閉並終止遊戲
Tetris panel = new Tetris(); //6.建立遊戲介面，即面板
frame.add(panel); //7.將面板嵌入視窗
// panel.setBackground(Color.yellow); //8.先把面板畫成yellow
//其實呼叫的是JPanel中的paint()方法
//遊戲的主要邏輯封裝在start()
panel.start();
}
}
連結：https://pan.baidu.com/s/1wswwkTyDRdNGs_TUKYrlPw 密碼：t5tj
將資源解壓後拷貝至package下
相關推薦
JAVA面向物件小程式(二)：俄羅斯方塊s
今天，我們來使用Eclipse製作一個小遊戲《Tetris~》 資源在文末 一、遊戲機制 a) 7種小塊兒隨機生成 i. 一塊放置在頂部(隨時間下降) ii. 另一塊
Java面向物件加強---程式執行的順序
知識點： 1）、構造一個類物件，必須先構造它的父類物件。 2）、初始化一個類必須先初始化它的屬性。 即：一個類先執行它的構造方法，構造方法方法之前需要執行super（），然後是成員變數，最後是建構函式內部的語句。下面是一個例子：pub
java 面向物件三大特性之一：繼承
前言： 繼承，既是對現有類的複用。如果子類繼承了父類，那麼子類就擁有了父類的能力了。除此之外，子類還能加入自己新加入的方法，功能，或是重新定義從父類繼承的某項功能。這樣，就可以在現有的功能上開發新的功能，這樣能大大減少開發的週期.|繼承的優點| 現在我們來構建
Java面向物件三大特性一：多型詳解
多型 多型(polymorphism):指的是同一個方法呼叫，由於物件不同可能會有不同的行為。現實生活中，同一個方法，具體實現會完全不同。 所謂多型就是指程式中定義的引用變數所指向的具體型別和通過該引用變數發出的方法呼叫在程式設計時並不確定，而是在程式執行期
黑馬程式設計師——Java面向物件（二）之封裝、繼承、多型、介面等
-----------android培訓、java培訓、java學習型技術部落格、期待與您交流！------------ 五、面向物件的特徵 面向物件主要有三大特徵： 1.特徵一 —— 封裝 1）定義：是指隱藏物件的屬性和實現細節，僅對外提供公共訪問方式。 2）好處：
實驗二：Java面向物件程式設計
實驗二 Java面向物件程式設計 目錄 [一、單元測試和TDD](#first) [任務一：實現百分制成績轉成“優、良、中、及格、不及格”五級製成績的功能](#firstTask) [任務二：以TDD的方式研究學習StringBuffer](#SecondTask)
初學JAVA面向物件最應該看的小程式
跟著視屏敲了一個十分簡單的程式碼小遊戲，感觸很深，讓我對java面向物件的設計理念有了進一步的理解，以及前期所學的java基礎內容得到了鞏固。萬物皆物件，程式設計時思維很清晰。 程式所應用到的大的知識點： 抽象類，
Java面向對象（二）：成員變量—OOP中的內存管理—構造函數
生成 類名 存在 str jdk 項目 -a 系統 show 第一節 成員變量 1.1成員變量與局部變量 成員變量：聲明在類下面，方法外面；作用於整個類中； 局部變量：聲明在方法下面，作用於方法下面。 1.2 成員變量默認值 成員變量的默認值和數組的默認值一樣：
面向物件【day07】：知識點回顧（十二）
本節內容 1、self關鍵字 2、封裝 3、繼承 4、靜態方法 一、self關鍵字 作用：呼叫當前方法的物件 1 2 3
面向物件【day08】：類的起源與metaclass（二）
本節內容 1、概述 2、類的起源 3、__new__方法 4、__metaclass__方法 一、概述 前面我們學習了大篇幅的關於類，通過類建立物件，那我們想知道這個類到底是怎麼產生的呢？它的一切來源是什麼？還有物件，物件是通過什麼方法建立的，現在我們一頭霧水，行
Java開發微信小程式(二)獲取並解密小程式使用者和手機資訊
第二篇 獲取並解密小程式的加密資訊包括使用者和手機資訊。 如果對其他的資訊幹興趣，還可以點選以下的連線 1.小程式登入獲取，小程式的openId和unionId。 2.獲取並解密小程式的加密資訊包括使用者和手機資訊。 3.用小程式給使用者推送服務訊息。 4.給繫結小
Java面向物件——類與方法（練習：將車抽象為類）
程式碼： public class Car{ //屬性 //品牌（不可更改）、產地（不可更改）、顏色、價格 private String brand; private String origin; private String colour; private int price;
（小程式篇：二）伺服器接收小程式圖片
小程式圖片上傳，在伺服器上接收小程式上傳的圖片 前面一篇介紹了本地搭建小程式測試伺服器，但是有一定侷限性：不能上傳圖片。因為小程式上傳圖片需要驗證公用ssl證書，使用一些不正規的免費證書不能完成上傳。所以我在阿里雲上申請了一個用來測試，方法：linux伺服器配置https 。當完成這
微信小程式二維碼（JAVA）
前言 最近在做小程式相關的專案，之前也在網上找過很多資料，遇到不少坑，和大家分享一下成果。 簡介 小程式獲取二維碼有官網三種介面： POST https://api.weixin.qq.com/cgi-bin/wxaapp/createwxaqrcode?access
JAVA面向物件：繼承案例的實現
繼承的相關概念： 繼承：多個類中存在相同屬性和行為時，將這些內容抽取到單獨一個類中，那麼多個類無需再定義這些屬性和行為，只要繼承這個新定義的類即可。java通過extends關鍵字可以實現類與類的繼承： cl
C語言面向物件程式設計（二）：繼承詳解
C++ 中的繼承，從派生類與基類的關係來看（出於對比 C 與 C++，只說公有繼承）： 派生類內部可以直接使用基類的 public 、protected 成員（包括變數和函式） 使用派生類的物件，可以像訪問派生類自己的成員一樣訪問基類的成員 對於被派生
java面向物件程式（利用建構函式，方法，繼承等描述一個人類）
完成一個java application 應用程式，描述一個人類。要求如下： 要求此人類必須包含有人的姓名、性別、出生日期等基本屬性（變數）。 要求此人類描述吃飯的方法（函式）和描述睡覺的方法（函式）。例如睡覺方法的執行體為一個 System.out.pri
Java面向物件與多執行緒綜合實驗（二）之 異常處理
理解異常的基本概念；瞭解Java異常的層次結構；熟悉並掌握Java異常的捕獲處理方法。 （1）閱讀Java™ Platform, Standard Edition 8 API Specification文件，瞭解後續程式設計中將要處理的IOException及其子類FileNotFoundE
JAVA 面向物件程式設計練習（一個回合制的戰鬥遊戲：戰士，騎兵，法師，電腦互相攻擊）
一. 小編有話說 前面一篇文章寫了JAVA面向物件程式設計的思想，本文主要展示關於面向物件程式設計的例項（一個回合制的戰鬥遊戲：戰士，騎兵，法師，電腦互相攻擊），小編的基礎暫時薄弱，如此一來有助於更深入的理解和靈活的運用，以及打下堅實的基礎。 二. 遊戲的要求
Java面向物件——String類（二）
String類的常用方法及基本使用 1.charAt(int index)：返回指定索引處的char值 package m10d27; public class String_3 { publ