JAVA IO详解,包括讲解IO中各种流及其用法_百度文库
两大类热门资源免费畅读
续费一年阅读会员，立省24元！
评价文档：
JAVA IO详解,包括讲解IO中各种流及其用法
J​A​V​A​ ​I​O​详​解​,​包​括​讲​解​I​O​中​各​种​流​及​其​用
阅读已结束，如果下载本文需要使用
想免费下载本文？
你可能喜欢JAVA的I/O介绍 - Cynthia&Sky - 博客园
随笔 - 271, 文章 - 0, 评论 - 0, 引用 - 0
&&疯狂JAVA编程&&第15章有详细介绍,讲的还是相当不错的，我们可以好好看下
IO流分为输入流（InputStream）和输出流（OutputStream）两类按流所处理的数据类型又可以分为字节流和字符流(用于处理Unicode字符数据)两类
字节流主要是由 InputStream和OutputStream作为基类，而字符流主要是由 Reader和Writer作为基类的
节点流(低级流) 和 处理流(高级流):JAVA使用处理流来包装节点流式一种典型的装饰器设计模式，通过使用处理流来包装不同的节点流，既可以消除不同节点流的实现差异，也可以提供更方便的方法来完成输入输出功能,这就允许Java应用程序采用相同的代码，透明的方式来访问不同输入\输出设备的数据流。所以处理流也叫做包装流
下图说明相关体系:
文件类：(File):提供文件操作功能(File可以创建，删除等操作对文件或目录，但是要访问文件内容，就必须用到输入/输出流)
1.创建File类对象:Ff = new File("Test.java");f = new File("E:\\ex\\","Test.java");
2.将目录也当作文件处理File类中提供了实现目录管理功能的方法:File path = new File("E:\\ex\\");File f = new File(path, "Test.java");
方法：f.getName()：返回文件名
temp.datf.getParent()：返回文件所在目录名
dataf.getPath()：返回文件路径
data\temp.datf.getAbsolutePath()：返回绝对路径
&\data\temp.datf.exists()：文件是否存在f.canWrite(), f.canRead()：文件是否可写、读f.isFile(), f.isDirectory()：是否为文件或目录f.lastModified(), f.length(), f.delete()：文件的最后修改日期、长度；删除文件f.mkdir(), f.list()：创建一个目录；列出目录下所有的文件
几个例子说明:
import java.io.*;
class FileTest{
public static void main(String[] str){
File f = new File("E:\\Workspace\\aaa.txt");
//判断是否存在该文件
if (!f.exists()){
System.out.println("file is not exist");
f.createNewFile();//不存在就创建新的文件
} catch (IOException e) {
e.printStackTrace();
File f1 = new File("E:\\Workspace\\aaa1\\sdfsdf\\asdf");
if (f1.mkdir()){ //创建目录
System.out.println("yes");
System.out.println("errors ");
import java.io.*;
//浏览当前目录下的所有文件和目录
class FileDirectory{
public static void main( String[] args ) {
File f1 = new File("");
String ss = f1.getAbsolutePath();
System.out.println("ss= " + ss);
File f = new File(ss);
if( f.isDirectory() ) {
//获取目录下所有的文件列表
File[] files = f.listFiles();
for( int i=0; i&files. i++ ) {
if( files[ i ].isDirectory() ) {
System.out.println( "&dir& " + files[ i ].getName() );
System.out.println( files[ i ].getName() );
catch( Exception e ) {
e.printStackTrace();
import java.io.*;
class SuperTest{
public static void main(String args[]) {
File dir = new File("E:\\Workspace\\Java\\test"); // 用File 对象表示一个目录
Filter filter = new Filter("txt"); // 生成一个名为java的过滤器
System.out.println("list java files in directory " + dir);
String[] files = dir.list(filter); // 列出目录dir下，文件后缀名为txt的所有文件
for (int i = 0; i & files. i++) {
File f = new File(dir, files[i]); // 为目录dir 下的文件或目录创建一个File 对象
if (f.isFile()) // 如果该对象为后缀为java的文件，则打印文件名
System.out.println("file: " + f);
System.out.println("sub directory " + f); // 如果是目录则打印目录名
class Filter implements FilenameFilter {
Filter(String extent) {
this.extent =
public boolean accept(File dir, String name) {
return name.endsWith("." + extent); //返回文件的后缀名
字节文件流：FileInputStream和FileOutputStream
import java.io.*;
*把一个文件的所有内容写到另外一个文件中
class FileStreamTest{
public static void main(String args[]) {
File inFile=new File("test1.txt");
File outFile=new File("test2.txt");
FileInputStream fis=new FileInputStream(inFile);
FileOutputStream fos=new
FileOutputStream(outFile);
while((c=fis.read())!=-1) //读取一个字节
fos.write(c);
fis.close();
fos.close();
}catch(FileNotFoundException e) {
System.out.println("FileStreamsTest: "+e);
}catch(IOException e) {
System.err.println("FileStreamsTest: "+e);
import java.io.*;
class CopyFileTest{
public static void main(String args[]) {
CopyFileTest cf = new CopyFileTest ();
cf.copyFile("test1.txt","test3.txt");
public boolean copyFile(String src,String des){
File srcFile,desF
srcFile = new File(src);
desFile = new File(des);
FileInputStream fis = null;
FileOutputStream fos = null;
desFile.createNewFile();
fis = new FileInputStream(srcFile);
fos = new FileOutputStream(desFile);//覆盖
fos = new FileOutputStream(desFile，true);//追加
int bytesR
byte[] buf = new byte[4 * 1024];
// 4K buffer
while((bytesRead=fis.read(buf))!=-1){
fos.write(buf,0,bytesRead);
fos.flush();
fos.close();
fis.close();
}catch(IOException e){
System.out.println(e);
return false;
return true;
如果只是在尾部追加，而不是覆盖需要调用FileOutputStream(&file&,true)就Ok了，对于字符流文件就是FileWriter(&file&,true)就OK乐。
父类过滤流：FilterInputStream(InputStream in);FilterOutputStream(OutputStream out);
过滤流&缓冲流
类BufferedInputStream和BufferedOutputStream继承FilterInputStream和FilterOutputStream，实现了带缓冲的过滤流，它提供了缓冲机制，把任意的I/O流&捆绑&到缓冲流上，可以提高该I/O流的读取效率，在初始化时，除了要指定所连接的I/O流之外，还可以指定缓冲区的大小。在读写的同时对数据缓存，这样避免每次读写数据都要进行实际的物理读写操作，在用BufferdOutputStream输出时，数据先输入缓冲区，当缓冲区满的时再写入连接的输出流，可以调用flush()来清空缓冲区。
import java.io.*;
class SuperTest{
public static void main(String args[]) {
File inFile = new File("test1.txt");
File outFile = new File("test4.txt");
BufferedInputStream bufFis=new BufferedInputStream(new FileInputStream(inFile),256);
BufferedOutputStream bufFos=new BufferedOutputStream(new FileOutputStream(outFile),256);
byte bArray[]=new byte[256];
System.out.println("while");
len = bufFis.read(bArray);
bufFos.write(bArray,0,len);
System.out.println("len: " +len);
}while (len==256);
bufFis.close();
bufFos.close();
} catch (FileNotFoundException e) {
System.out.println("FileStreamsTest: " + e);
} catch (IOException e) {
System.err.println("FileStreamsTest: " + e);
过滤流&数据流
DataInputStream和DataOutputStream, 继承FilterInputStream和FilterOutputStream，可以用来与计算机无关的格式读写JAVA的基本数据类型以及String对象。readBoolean() 读一字节，非零为真readByte() 以8位读字节readChar() 读Unicode字符readInt() 读整数值writeChar(int v) 把字符写进输出流writeLong(long v) 把长整写进输出流writeInt(int v) 把整数写进输出流
数据输出流可以是一个已经建立好的输入数据流对象,例如网络的连结,文件等。数据流可通过如下方式建立。FileInputStream fis = new
FileInputStream("file1.txt");FileOutputStream fos = new
FileOutputStream("file2.txt");DataInputStream dis = new DataInputStream(fis);DataOutputStream dos = new DataOutputStream(fos);
import java.io.*;
class DataStreamIOTest{
public static void main(String args[]) throws IOException
FileOutputStream fos = new FileOutputStream("a.txt");
DataOutputStream dos = new DataOutputStream(fos);
dos.writeBoolean(true);
dos.writeByte((byte) 123);
dos.writeChar('J');
dos.writeDouble(3.);
dos.writeFloat(2.7182f);
dos.writeInt();
dos.writeLong(332211L);
dos.writeShort((short) 11223);
} finally {
dos.close();
FileInputStream fis = new FileInputStream("a.txt");
DataInputStream dis = new DataInputStream(fis);
System.out.println("\t " + dis.readBoolean());
System.out.println("\t " + dis.readByte());
System.out.println("\t " + dis.readChar());
System.out.println("\t " + dis.readDouble());
System.out.println("\t " + dis.readFloat());
System.out.println("\t " + dis.readInt());
System.out.println("\t " + dis.readLong());
System.out.println("\t " + dis.readShort());
} finally {
dis.close();
}//需要注意的是必须throws IOException才可以编译通过。
例子：利用FileWriter来写文件
FileWriter fw = new FileWriter("mydata.txt");
PrintWriter out = new PrintWriter(fw);
out.print("面朝大海，");
out.println("春暖花开！");
out.println("环境美好!！");
out.close();
fw.close();
}catch(IOException e)
e.printStackTrace();
例子：字符缓冲流BufferedReader
import java.io.*;
class SuperTest{
public static void main(String args[]) throws IOException
File file = new File("mydata.txt");
BufferedReader in = new BufferedReader(new FileReader(file));
s = in.readLine();
while ( s != null ) {
System.out.println("Read: " + s);
s = in.readLine();
in.close();
} catch (FileNotFoundException e1) {
System.err.println("File not found: " + file);
} catch (IOException e2) {
e2.printStackTrace();
例子：拷贝（FileReader和FileWriter）
FileReader input = new FileReader(args[0]);
FileWriter output = new FileWriter(args[1]);
char[] buffer = new char[128];
int charsR
charsRead = input.read(buffer);
while ( charsRead != -1 )
output.write(buffer, 0, charsRead);
charsRead = input.read(buffer);
input.close();
output.close();
} catch (IOException e)
e.printStackTrace();
例子：拷贝(BufferedWriter)
FileReader input = new FileReader(args[0]);
BufferedReader bufInput = new BufferedReader(input);
FileWriter output = new FileWriter(args[1]);
BufferedWriter bufOutput = new BufferedWriter(output);
line = bufInput.readLine();
while ( line != null )
bufOutput.write(line, 0, line.length());
bufOutput.newLine();
line = bufInput.readLine();
bufInput.close();
bufOutput.close();
catch (IOException e)
e.printStackTrace();
随机存取文件流--RandomAccessFile1 RandomAccessFile是一种特殊的文件流，可以用它在文件的任何地方查找或者插入数据 2 RandomAccessFile同时实现了DataInput和DataOutput接口，所以可以用它来读/写文件3构造器:
RandomAccessFile(java.io.File f,String mode) RandomAccessFile(String file,String mode)4 mode可以为&r&或&rw&
方法：1 readXXX()或writeXXX()： 如ReadInt(), ReadLine(), WriteChar(), WriteDouble()等2 int skipBytes(int n)：将指针向下移动若干字节3 length()：返回文件长度4 long getFilePointer()：返回指针当前位置5 void seek(long pos)：将指针调到所需位置
import java.io.*;
import java.util.*;
class RandomAccessFileTest{
public static void main(String args[])
File logfile=new File("mydata.txt");
if(logfile.exists())
RandomAccessFile raf=new RandomAccessFile(logfile,"rw");
System.out.println("leghth = " + raf.length());
raf.seek(raf.length());
for(int i=0;i&5;i++)
raf.writeBytes("Write "+new Date()+ "\r\n");
raf.seek(0);
String x=raf.readLine();
while(x!=null)
System.out.println(x);
x=raf.readLine();
raf.close();
}catch(IOException e){
e.printStackTrace();
JAVA流总结：1 在Java中有数据传输的地方都用到I/O流(通常是文件,网络,内存和标准输入输出等)。2 InputStream 和OutputStream是所有字节流的祖先(只有RandomAccessFile类是一个例外)，read和write是它们最基本的方法，读写单位是字节3 Reader 和Writer是所有字符流的祖先，read和write是它们最基本的方法，读写单位是字符。4 在众多的流对象中，并不是每一种都单独使用，其中过滤流的子类在数据送出去之前做必要的处理5 File, File(Input/Output)Stream, RandomAccessFile是处理本地文件的类。6 Data(Input/Output)Stream是一个过滤流的子类，借此可以读写各种基本数据，在文件和网络中经常使用。如: readByte， writeBoolean等。7 Buffered(Input/Output)Stream的作用是在数据送到目的之前先缓存，达到一定数量时再送到目的，已减少阻塞次。8 Piped(Input/Output)Stream适合与一个处理的输出作为另一个处理的输入的情况File类的基本用法_Demo12_1.java
* 功能 :File类的基本用法
package com
import java
public class Demo12_1
* @param args
public static void main
//创建一个文件对象
File f File
//得到文件的路径
System文件路径："
//得到文件的大小，字节数
System文件大小："
System可读:"可写："
f可执行："
//创建文件和创建文件夹
File f1 File
//可以创建新文件
// TODO Auto-generated catch block
System文件存在不能创建！"
//创建文件夹
File f2 File
System文件夹已存在！"
//文件与文件夹都是文件，文件夹是一种特殊的文件
//列出一个文件夹下的所有文件
File f3 File
File lists
System文件名："
FileInputStream类的使用_Demo12_2.java
* 演示FileInputStream类的使用
package com
import java
public class Demo12_2
* @param args
public static void main
//得到一个文件对象
File f File
//因为File没有读写的能力，所以要使用InputStream流。
FileInputStream fis
//文件输入流
fis FileInputStream
byte定义一个字节数组，相当于缓存
int n用于存放实际读取到的字节数
//循环读取
//如果文件流中的字节数大于数组长度(1024)，循环一次，就从输入文件流中
//读取等于数组长度(1024)的字节存到字节数组bytes中，第二次再读取剩余的，
//如果文件流中的字节数大于数组长度(1024),则一次循环就能文件流中的字节全都存入bytes数组中
//把字节转成String
String s String
// TODO Auto-generated catch block
//关闭文件流必须放在finally块里
// TODO Auto-generated catch block
FileOutputStream的使用_Demo12_3.java
* 演示FileOutputStream的使用
package com
import java
public class Demo12_3
* @param args
public static void main
//定义文件对象
File f File
//字节输出流
FileOutputStream fos
fos FileOutputStream
String s维唯为为 OK,HelloWorld"
String s1中国好！"
//定义字节数组
//byte []bytes=new byte[1024];
//如何把String-&bytes数组
// TODO Auto-generated catch block
// TODO Auto-generated catch block
fos关闭文件流
// TODO Auto-generated catch block
图片拷贝Demo12_4.java
* 图片拷贝
package com
import java
public class Demo12_4
* @param args
public static void main
//思路先把图片读入到内存--&写入到某个文件
//因为是二进制文件，因此只能用字节流完成
FileInputStream fis//定义输入流
FileOutputStream fos//定义输出流
fis FileInputStream输入流
fos FileOutputStream输出流
byte buf byte
//循环读取
//输出到指定文件
fis关闭输入流
fos关闭输出流
文件字符流_Demo12_5.java
* 演示文件字符流的案例
package com
import java
public class Demo12_5
* @param args
public static void main
//文件读取出字符流对象(输入流)
FileReader fr
//写入到文件(输出流)
FileWriter fw
//创建fr输入对象
fr FileReader
//创建fw输出对象
fw FileWriter
int n记录实际读取的字符数
//读入内存
char c char
whilen循环读出
String s String
//将c中有效字符存到s中
缓冲字符流_Demo12_6.java
* 演示缓冲字符流案例
package com
import java
public class Demo12_6
* @param args
public static void main
BufferedReader br//Buf输入流
BufferedWriter bw//Buf输出流
//先创建FileReader对象
FileReader fr FileReader
br BufferedReader
//创建FileWriter对象
FileWriter fw FileWriter赵云.txt"
bw BufferedWriter
//循环读取文件
whiles //从buf流中读取
//输出到磁盘
// TODO Auto-generated catch block
// TODO: handle exception
记事本_Demo12_7.java
* 我的记事本(界面+功能)
package com
import java
import java
import java
import javax
public class Notepad extends JFrame implements ActionListener
//定义需要的组件
JTextArea jta //文本域
JMenuBar jmb //菜单条
JMenu jml //第一JMenu
JMenuItem jmi1//菜单项
JMenuItem jmi2//菜单项
public static void main
Notepad notepad Notepad
//构造函数
public Notepad
jta JTextArea
jmb JMenuBar
jml JMenu文件"
//设置助记符
jmi1 JMenuItem打开(o)" ImageIcon
//注册监听
jmi2 JMenuItem保存(s)" ImageIcon
//加入菜单条
thissetJMenuBar
//把菜单jml放入菜单条jmb
//把菜单项(jmi1)放入菜单(jml)
//放入到JFrame
thissetDefaultCloseOperation
thissetSize
thissetVisible
public void actionPerformed
//判断是哪个菜单被选中
ife打开菜单
System点击了打开菜单项！"
//隆重推荐JFileChooser
//文件选择组件
JFileChooser jfc1 JFileChooser
//设置名字
jfc1请选择文件...."
//按默认方式显示打开文件对话框
//得到用户选择的文件全路径
String filename
//读取文件中的内容
FileReader fr
BufferedReader br
fr FileReader
br BufferedReader
//从文件中读取信息并显示到jta
String allCon
//放置到jta
System点击了保存菜单项！"
//隆重推荐JFileChooser
//出现保存对话框
JFileChooser jfc1 JFileChooser
//设置名字
jfc1另存为...."
//按默认方式显示保存文件对话框
//得到用户选择的文件全路径
String filename
//把内容写入到指定的文件
FileWriter fw
BufferedWriter bw
fw FileWriter
bw BufferedWriter
测试声音_ TestAudio.java
* 测试声音
package com
import java
import javax
public class TestAudio
* @param args
public static void main
//1.创建建一个AePlayWave对象实例
AePlayWave apw AePlayWave声音.wav"
//2.启动该线程播放
//播放声音的类
class AePlayWave extends Thread
private String filename
public AePlayWave
public void run
File soundFile
AudioInputStream audioInputStream
audioInputStream
AudioFormat format
SourceDataLine auline
int nBytesRead
//这是缓冲
nBytesRead
坦克大战v4.0_ MyTankGame3.java
* 功能：坦克大战v4.0
* 1.画出坦克
* 2.我的坦克可以上下左右移动
* 3.可以发射子弹，子弹连发(最多5颗)
* 4.当子弹击中敌人坦克时，敌人坦克消失(爆炸效果)
* 5.我被击中时，显示爆炸效果
* 6.防止敌人坦克重叠运动
* 6.1决定把判断是否碰撞的函数写到EnemyTank类中去
* 7.可以分关
* 7.1做一个开始的Panel，它是一个空的
* 7.2字体闪烁效果
* 8.可以在玩游戏的时候暂停和继续
* 8.1当用户点暂停时，子弹的速度和坦克速度设为0，并让坦克的方向不变化
* 9.可以记录玩家的成绩
* 9.1用文件流
* 9.2单写一个记录类，完成对玩家的记录
* 9.3先完成保存共击毁了多少敌人坦克的功能
* 9.4存盘退出游戏，可以记录当时敌人坦克的坐标，并可以恢复
* 10.java如何操作声音文件
* 10.1对声音文件的操作
* 11.网络对决....
package com
import java
import javax
import javax
import java
import java
import java
public class MyTankGame3 extends JFrame implements ActionListener
MyPanel mp //游戏面板
MyStartPanel msp //开始面板
//需要的菜单
JMenuBar jmb
//开始游戏
JMenu jm1 //菜单
JMenuItem jmi1//菜单项
JMenuItem jmi2//退出
JMenuItem jmi3//存盘退出
JMenuItem jmi4//续上局
//构造函数
public MyTankGame3
//创建菜单及菜单项
jmb JMenuBar
jm1 JMenu游戏(G)"
jm1设置快捷方式
jmi1 JMenuItem开始新游戏(N)"
jmi1设置快捷方式
jmi2 JMenuItem退出游戏(E)"
jmi2设置快捷方式
jmi3 JMenuItem存盘退出游戏(E)"
jmi3设置快捷方式
jmi4 JMenuItem继续上局游戏(R)"
jmi4设置快捷方式
jm1将菜单项(jmi1)加入菜单(jm1)
jmb将菜单(jm1)加入菜单栏
//对jmi1i添加事件响应
//加入提示面板
msp MyStartPanel
Thread t Thread
thissetJMenuBar加入菜单栏
thissetSize
thissetLocation
thissetDefaultCloseOperation
thissetVisible
public static void main
MyTankGame3 mtg MyTankGame3
public void actionPerformed
//开始新的游戏
//创建游戏战场面板
mp MyPanel
//启动mp线程
Thread t Thread
thisremove先删除旧的开始面板
thisadd然后加入新的游戏面板
//注册监听
thisaddKeyListener
//显示、刷新JFrame
thissetVisible
//用户点击了退出系统的菜单
//保存击毁敌人数量
System退出,0代表正常退出,-1代表异常退出
//对存盘退出处理
Recorder rd Recorder
//保存击毁敌人的数量和坐标
System退出
else ife续上局
//创建游戏战场面板
mp MyPanel
//mp.flag="con";
//启动mp线程
Thread t Thread
thisremove先删除旧的开始面板
thisadd然后加入新的游戏面板
//注册监听
thisaddKeyListener
//显示、刷新JFrame
thissetVisible
//开始提示面板
class MyStartPanel extends JPanel implements Runnable
public void paint
superpaint
//提示信息
//开关信息的字体
g设置画笔颜色
Font myFont Font华文彩云"
public void run
thisrepaint
//我的面板
class MyPanel extends JPanel implements KeyListener
//定义一个我的坦克
//判断是续上局，还是新游戏
//String flag="newGame";
//定义敌人的坦克组
Vector Vector
Vector Vector
//定义炸弹集合
Vector Vector
//初始化敌人坦克数量
int enSize
//定义三张图片，组成成一颗炸弹
Image image1
Image image2
Image image3
//构造函数
public MyPanel
//构造函数中的参数，用于判断是续上局，还是新游戏
Recorder恢复记录
ifflag如果是新游戏
//初始化敌人的坦克
//创建一个辆敌人的坦克对象
EnemyTank et EnemyTank
et设置颜色
et设置方向
//将MyPanel的敌人坦克向量交给敌人坦克
//启动敌人的坦克
Thread t Thread
//给敌人坦克添加一颗子弹
Shot s Shot
//把子弹加入给敌人
//启动子弹敌人的子弹线程
Thread t2 Thread
else //如果不新游戏
nodes Recorder恢复敌人坦克
//初始化敌人的坦克
//创建一个辆敌人的坦克对象
EnemyTank et EnemyTank
et设置颜色
et设置方向
//将MyPanel的敌人坦克向量交给敌人坦克
//启动敌人的坦克
Thread t Thread
//给敌人坦克添加一颗子弹
Shot s Shot
//把子弹加入给敌人
//启动子弹敌人的子弹线程
Thread t2 Thread
image1 File
image2 File
image3 File
//播放开战声音
AePlayWave apw AePlayWave声音.wav"
//初始化图片
//image1=Toolkit.getDefaultToolkit().getImage(Panel.class.getResource("/bomb_1.gif"));
//image2=Toolkit.getDefaultToolkit().getImage(Panel.class.getResource("/bomb_2.gif"));
//image3=Toolkit.getDefaultToolkit().getImage(Panel.class.getResource("/bomb_3.gif"));
//画出提示信息坦克(该坦克不参与战斗)
public void showInfo
//敌人的坦克提示信息
thisdrawTank
//我的坦克提示信息
thisdrawTank
//画出玩家的总成绩
Font f Font宋体"
g您的总成绩："
thisdrawTank敌人坦克
//重写paint函数
public void paint
superpaint这句不能少
g设置游戏面板背景
//画出提示信息
thisshowInfo
//画出自己的坦克
thisdrawTankhero
//从ss中取出每一颗子弹，并画出
forint ihero设置子弹连发
//取出一颗子弹
Shot myShot
//画出一颗子弹
ifherohero
g设置子弹颜色
ifmyShot//如果子弹已经死亡
//从ss中删除掉该子弹
//画出炸弹
//System.out.println("bombs.size()="+bombs.size());
//取出炸弹
//让b的生命值减小
ifb如果炸弹生命值为0时，就把炸弹从集合中去掉
//画出敌人的坦克
EnemyTank et
ifet画出还是活的坦克
thisdrawTank
//再画出敌人的子弹
//取出子弹
Shot enemyShot
ifenemyShot
g设置子弹颜色
else //如果敌人的坦克死亡了就从Vector去掉
//判断我的子弹是否击中敌人的坦克
public void hitEnemyTank
//在这run函数里判断子弹是否击中敌人坦克
//取出子弹
Shot myShot
ifmyShot判断子弹是否还是活的或有效
//取出每个坦克，与它判断
//取出坦克
EnemyTank et
//减少一个敌人坦克
//增加我的记录(战绩)
//敌人的子弹是否击中我
public void hitMe
//取出每一个敌人的坦克
forint iets
//取出坦克
EnemyTank et
//取出每一颗子弹
//取出子弹
Shot enemyShot
thishitTank
//1.写一个专门判断子弹是否击中敌人坦克的函数
public boolean hitTank
boolean bool //判断坦克是否被击中
//判断该坦克的方向
//如果敌人坦克的方向是右或者是左
s //子弹死亡
et//敌人坦克死亡
//创建一颗炸弹
Bomb b Bomb
//把炸弹放入到Vector
//如果敌人坦克的方向是上或者是下
s //子弹死亡
et//敌人坦克死亡
//创建一颗炸弹
Bomb b Bomb
//把炸弹放入到Vector
return bool
//画出坦克的函数(扩展)
public void drawTank
//判断坦克的类型
switchtype
//判断方向
switchdirect
case 0向右
//画出上面的矩形
//画出下面的矩形
//画出中间的矩形
//画出圆形
case 1向左
//画出上面的矩形
//画出下面的矩形
//画出中间的矩形
//画出圆形
case 2向下
//画出我的坦克(到时封装成一个函数)
//1.画出左边的矩形
//2.画出右边的矩形
//3.画出中间矩形
//4.画出中间的圆形
//5.画出线
case 3向上
//画出我的坦克(到时封装成一个函数)
//1.画出左边的矩形
//2.画出右边的矩形
//3.画出中间矩形
//4.画出中间的圆形
//5.画出线
public void keyPressed键按下处理
//a表示向左，s表示向上，w表示向上，d表示向右
thishero设置我的坦克的方向,向右
thishero向左
thishero向下
thishero向上
//判断玩家是否按下j
//发射子弹
ifhero连发子弹小于5
//重绘Panel
thisrepaint
public void keyReleased
public void keyTyped
public void run
//每隔100毫秒去重绘
// TODO Auto-generated catch block
//2.什么地方调用-判断子弹是否击中敌人坦克的函数
thishitEnemyTank子弹是否击中敌人坦克
thishitMe敌人的坦克是否击中我了
thisrepaint
Members.java
package com
import java
import java
import javax
import javax
import javax
import javax
import javax
//播放声音的类
class AePlayWave extends Thread
private String filename
public AePlayWave
public void run
File soundFile
AudioInputStream audioInputStream
audioInputStream
AudioFormat format
SourceDataLine auline
int nBytesRead
//这是缓冲
nBytesRead
//坦克恢复点
class Node
public Node
thisdirect
//记录类，同时也可以保存玩家的设置
class Recorder
//记录每关有多少敌人
private static int enNum
//设置我有多少可以用的坦克
private static int myLife
//记录总共消灭了多少敌人
private static int allEnNum
private static FileWriter fw//文件流
private static BufferedWriter bw//buf流
private static FileReader fr
private static BufferedReader br
//定义一个集合用于保存敌人的坦克
private Vector Vector
//从文件中恢复记录点
static Vector Vector
public Vector
return ets
public void setEts
public static int getAllEnNum
return allEnNum
public static void setAllEnNum
public static int getEnNum
return enNum
public static void setEnNum
public static int getMyLife
return myLife
public static void setMyLife
//减少敌人数
public static void redurceEnNum
//消灭敌人
public static void addEnNumRec
//保存击毁敌人坦克的数量、坐标和方向
public void keeyRecAndEnemyTank
fw FileWriter
bw BufferedWriter
//System.out.println("size="+ets.size());
//保存当前活的敌人坦克的坐标和方向
//取出第一个坦克
EnemyTank et
//活的就保存,坐标与方向
String recorde
//后开先关闭
//把玩家击毁敌人坦克数量保存到文件中
public static void keepRecording
fw FileWriter
bw BufferedWriter
//完成恢复退出时的记录
public Vector
fr FileReader
br BufferedReader读取记录
n先读取一行
String 读取以空格分隔的字符
Node node Node
// TODO Auto-generated catch block
return nodes
//从文件中读取记录
public static void getRecording
fr FileReader
br BufferedReader读取记录
String n将读取的记录存到string中
// TODO Auto-generated catch block
class Bomb
//定义炸弹的坐标
//炸弹的生命
//炸弹是否还是活的
boolean isLive
public Bomb
//减少炸弹生命值
public void lifeDown
thisisLive
class Shot implements Runnable
//是否还活着
boolean isLive
public Shot
thisdirect
public void run
//子弹向前跑动
// TODO Auto-generated catch block
switchdirect
case 0子弹向右
case 1子弹向左
case 2子弹向下
case 3子弹向上
//System.out.println("子弹坐标x="+x+" y="+y);
//子弹何时死亡
//判断该子弹是否碰到边缘
thisisLive
class Tank
//表示坦克的横坐标
//坦克纵坐标
//坦克方向
int direct表示右，1表示左，2表示下，3表示上
//坦克的速度
//坦克的颜色
boolean isLive
public int getColor
return color
public void setColor
public int getSpeed
return speed
public void setSpeed
public int getDirect
return direct
public void setDirect
thisdirect
public int getX
public void setX
public int getY
public void setY
public Tank
//敌人的坦克,把敌人坦克做成线程类
class EnemyTank extends Tank implements Runnable
//boolean isLive=//是否死亡
//定义一个集合向量可以访问到MyPanel上所有敌人的坦克
Vector Vector
//定义一个集合向量，可以存放敌人的子弹
Vector Vector
//敌人添加子弹，应当在刚刚创建坦克和敌人的坦克子弹是死亡之后
public EnemyTank
//得到MyPanel的敌人坦克向量
public void setEts
public Vector
return ets
//判断是否碰到了别的敌人坦克
public boolean isTouchOtherEnemy
switchdirect
case 0坦克向右
//取出所有的敌人坦克
//取出第一个坦克
EnemyTank et
ifet//如果不是自己
//如果敌人的方向是向上或向下
//如果此坦克的右上角点在其它坦克矩形区域内
return true
//如果此坦克的右下角点在其它坦克矩形区域内
return true
//如果敌人的方向是向左或向右
//如果此坦克的右上角点在其它坦克矩形区域内
return true
//如果此坦克的右下角点在其它坦克矩形区域内
return true
case 1坦克向左
//取出所有的敌人坦克
//取出第一个坦克
EnemyTank et
ifet//如果不是自己
//如果敌人的方向是向上或向下
//如果此坦克的左上角点在其它坦克矩形区域内
return true
//如果此坦克的左下角点在其它坦克矩形区域内
return true
//如果敌人的方向是向左或向右
//如果此坦克的左上角点在其它坦克矩形区域内
return true
//如果此坦克的左下角点在其它坦克矩形区域内
return true
case 2我的坦克向下
//取出所有的敌人坦克
//取出第一个坦克
EnemyTank et
ifet//如果不是自己
//如果敌人的方向是向上或向下
//如果此坦克的左下角点在其它坦克矩形区域内
return true
//如果此坦克的右下角点在其它坦克矩形区域内
return true
//如果敌人的方向是向左或向右
//如果此坦克的左下角点在其它坦克矩形区域内
return true
//如果此坦克的右下角点在其它坦克矩形区域内
return true
case 3坦克向上
//取出所有的敌人坦克
//取出第一个坦克
EnemyTank et
ifet//如果不是自己
//如果敌人的方向是向上或向下
//如果此坦克的左上角点在其它坦克矩形区域内
return true
//如果此坦克的右上角点在其它坦克矩形区域内
return true
//如果敌人的方向是向左或向右
//如果此坦克的左上角点在其它坦克矩形区域内
return true
//如果此坦克的右上角点在其它坦克矩形区域内
return true
public void run
//让敌人坦克坐标不停的变化
switchdirect
case 0说明坦克正在向右移动
ifxisTouchOtherEnemy限制坦克不移出边界
// TODO Auto-generated catch block
case 1说明坦克正在向左移动
ifxisTouchOtherEnemy限制坦克不移出边界
// TODO Auto-generated catch block
case 2说明坦克正在向下移动
ifyisTouchOtherEnemy限制坦克不移出边界
// TODO Auto-generated catch block
case 3说明坦克正在向上移动
ifyisTouchOtherEnemy限制坦克不移出边界
// TODO Auto-generated catch block
iftimes秒时间到了
//添加子弹
switchdirect
case 0坦克朝右
//创建一颗子弹
//把子弹加入集合向量
case 1坦克朝左
//把子弹加入向量
case 2坦克朝下
//把子弹加入向量
case 3坦克朝上
//把子弹加入向量
//启动子弹线程
Thread t Thread
//让坦克随机产生一个新的方向
thisdirect
//判断敌人坦克是否死亡
//让坦克死亡后退出线程
//我的坦克
class Hero extends Tank
//定义一个用于存放子弹的集合
Vector Vector
public Hero
superx用父类的构造函数初始化子类的成员变量
//发射子弹
public void shotEnemy
switchdirect
case 0坦克朝右
//创建一颗子弹
//把子弹加入集合向量
case 1坦克朝左
//把子弹加入向量
case 2坦克朝下
//把子弹加入向量
case 3坦克朝上
//把子弹加入向量
//启动子弹线程
Thread t Thread因为子弹类Shot实现了Runnable接口
//坦克向上移动
public void moveUp
//坦克向右移动
public void moveRight
//坦克向下移动
public void moveDown
//坦克向左移动
public void moveLeft
阅读(...) 评论() &}