`

Java笔记7(IO操作、图片拷贝、记事本、测试声音、坦克大战)

    博客分类：
  • Java
 
阅读更多 
File类的基本用法_Demo12_1.java 

/* 

* 功能 :File类的基本用法 

*/ 

 

package com.test1; 

import java.io.*; 

 

public class Demo12_1 { 

 

/** 

* @param args 

*/ 

public static void main(String[] args) { 

 

//创建一个文件对象 

File f=new File("d:\\aa.txt"); 

//得到文件的路径 

System.out.println("文件路径："+f.getAbsolutePath()); 

//得到文件的大小，字节数 

System.out.println("文件大小："+f.length()); 

System.out.println("可读:"+f.canRead()+" 可写："+ 

f.canWrite()+" 可执行："+f.canExecute()); 

 

//创建文件和创建文件夹 

File f1=new File("d:\\ff\\bb.txt"); 

if(!f1.exists()) 

{ 

//可以创建新文件 

try { 

f1.createNewFile(); 

} catch (IOException e) { 

// TODO Auto-generated catch block 

e.printStackTrace(); 

} 

} 

else 

{ 

System.out.println("文件存在不能创建！"); 

} 

 

//创建文件夹 

File f2=new File("d:\\ff"); 

if(f2.isDirectory()) 

{ 

System.out.println("文件夹已存在！"); 

} 

else 

{ 

//创建 

f2.mkdir(); 

} 

 

//文件与文件夹都是文件，文件夹是一种特殊的文件 

//列出一个文件夹下的所有文件 

File f3=new File("d:\\ff"); 

if(f3.isDirectory()) 

{ 

File lists[]=f3.listFiles(); 

for(int i=0;i<lists.length;i++) 

{ 

System.out.println("文件名："+lists[i].getName()); 

} 

} 

} 

 

} 

FileInputStream类的使用_Demo12_2.java 

/* 

* 演示FileInputStream类的使用 

*/ 

 

package com.test2; 

import java.io.*; 

 

public class Demo12_2 { 

 

/** 

* @param args 

*/ 

public static void main(String[] args) { 

//得到一个文件对象 

File f=new File("d:/test.txt"); 

//因为File没有读写的能力，所以要使用InputStream流。 

FileInputStream fis=null; 

try { 

//文件输入流 

fis=new FileInputStream(f); 

byte []bytes=new byte[1024];//定义一个字节数组，相当于缓存 

int n=0; //用于存放实际读取到的字节数 

//循环读取 

while((n=fis.read(bytes))!=-1) 

//如果文件流中的字节数大于数组长度(1024)，循环一次，就从输入文件流中 

//读取等于数组长度(1024)的字节存到字节数组bytes中，第二次再读取剩余的， 

//如果文件流中的字节数大于数组长度(1024),则一次循环就能文件流中的字节全都存入bytes数组中 

{ 

//把字节转成String 

String s=new String(bytes,0,n); 

System.out.println(s); 

} 

} catch (Exception e) { 

// TODO Auto-generated catch block 

e.printStackTrace(); 

}finally{ 

//关闭文件流必须放在finally块里 

try { 

fis.close(); 

} catch (IOException e) { 

// TODO Auto-generated catch block 

e.printStackTrace(); 

} 

} 

} 

} 

FileOutputStream的使用_Demo12_3.java 

/* 

* 演示FileOutputStream的使用 

*/ 

 

package com.test3; 

import java.io.*; 

 

public class Demo12_3 { 

 

/** 

* @param args 

*/ 

public static void main(String[] args) { 

//定义文件对象 

File f=new File("d:\\ss.txt"); 

//字节输出流 

FileOutputStream fos=null; 

try { 

fos=new FileOutputStream(f); 

String s="维唯为为 OK,HelloWorld"; 

String s1="中国好！"; 

//定义字节数组 

//byte []bytes=new byte[1024]; 

//如何把String->bytes数组 

try { 

fos.write(s.getBytes("UTF-8")); 

fos.write(s1.getBytes("UTF-8")); 

} catch (IOException e) { 

// TODO Auto-generated catch block 

e.printStackTrace(); 

} 

} catch (FileNotFoundException e) { 

// TODO Auto-generated catch block 

e.printStackTrace(); 

}finally 

{ 

try { 

fos.close(); //关闭文件流 

} catch (IOException e) { 

// TODO Auto-generated catch block 

e.printStackTrace(); 

} 

} 

} 

 

} 

图片拷贝Demo12_4.java 

/* 

* 图片拷贝 

*/ 

 

package com.test4; 

import java.io.*; 

 

public class Demo12_4 { 

 

/** 

* @param args 

*/ 

public static void main(String[] args) { 

//思路 先把图片读入到内存-->写入到某个文件 

//因为是二进制文件，因此只能用字节流完成 

 

FileInputStream fis=null;//定义输入流 

FileOutputStream fos=null;//定义输出流 

try { 

fis=new FileInputStream("d:/ff/a.jpg");//输入流 

fos=new FileOutputStream("d:/a.jpg");//输出流 

byte buf[]=new byte[512]; 

int n=0; 

//循环读取 

while((n=fis.read(buf))!=-1) 

{ 

//输出到指定文件 

fos.write(buf); 

} 

} catch (Exception e) { 

e.printStackTrace(); 

}finally{ 

try { 

fis.close();//关闭输入流 

fos.close();//关闭输出流 

} catch (IOException e) { 

e.printStackTrace(); 

} 

} 

} 

 

} 

文件字符流_Demo12_5.java 

/* 

* 演示文件字符流的案例 

*/ 

 

package com.test5; 

import java.io.*; 

 

public class Demo12_5 { 

 

/** 

* @param args 

*/ 

public static void main(String[] args) { 

//文件读取出字符流对象(输入流) 

FileReader fr=null; 

//写入到文件(输出流) 

FileWriter fw=null; 

try{ 

//创建fr输入对象 

fr=new FileReader("d://test.txt"); 

//创建fw输出对象 

fw=new FileWriter("d:/vvvv.txt"); 

int n=0;//记录实际读取的字符数 

//读入内存 

char c[]=new char[1024]; 

while((n=fr.read(c))!=-1)//循环读出 

{ 

String s=new String(c,0,n); 

//将c中有效字符存到s中 

System.out.println(s); 

fw.write(c, 0, n); 

} 

}catch (Exception e){ 

e.printStackTrace(); 

}finally{ 

try { 

fr.close(); 

fw.close(); 

} catch (IOException e) { 

e.printStackTrace(); 

} 

} 

} 

 

} 

缓冲字符流_Demo12_6.java 

/* 

* 演示缓冲字符流案例 

*/ 

 

package com.test6; 

import java.io.*; 

 

public class Demo12_6 { 

 

/** 

* @param args 

*/ 

public static void main(String[] args) { 

// 

BufferedReader br=null;//Buf输入流 

BufferedWriter bw=null;//Buf输出流 

try { 

//先创建FileReader对象 

FileReader fr=new FileReader("d:/test.txt"); 

br=new BufferedReader(fr); 

 

//创建FileWriter对象 

FileWriter fw=new FileWriter("d:/赵云.txt"); 

bw=new BufferedWriter(fw); 

 

//循环读取文件 

String s=""; 

while((s=br.readLine())!=null) //从buf流中读取 

{ 

System.out.println(s); 

//输出到磁盘 

bw.write(s+"\r\n"); 

} 

} catch (Exception e) { 

// TODO Auto-generated catch block 

e.printStackTrace(); 

}finally{ 

try { 

br.close(); 

bw.close(); 

} catch (Exception e2) { 

// TODO: handle exception 

} 

} 

} 

 

} 

记事本_Demo12_7.java 

/* 

* 我的记事本(界面+功能) 

*/ 

 

package com.test7; 

import java.io.*; 

import java.awt.*; 

import java.awt.event.*; 

 

import javax.swing.*; 

 

public class Notepad extends JFrame implements ActionListener{ 

 

//定义需要的组件 

JTextArea jta=null; //文本域 

JMenuBar jmb=null; //菜单条 

JMenu jml=null; //第一JMenu 

JMenuItem jmi1=null;//菜单项 

JMenuItem jmi2=null;//菜单项 

public static void main(String[] args) { 

// 

Notepad notepad=new Notepad(); 

} 

 

//构造函数 

public Notepad() 

{ 

//创建jta 

jta=new JTextArea(); 

jmb=new JMenuBar(); 

jml=new JMenu("文件"); 

//设置助记符 

jml.setMnemonic('F'); 

jmi1=new JMenuItem("打开(o)",new ImageIcon("./src/new.jpg")); 

//注册监听 

jmi1.addActionListener(this); 

jmi1.setActionCommand("open"); 

jmi2=new JMenuItem("保存(s)",new ImageIcon("./src/save.jpg")); 

jmi2.addActionListener(this); 

jmi2.setActionCommand("save"); 

//加入菜单条 

this.setJMenuBar(jmb); 

//把菜单jml放入菜单条jmb 

jmb.add(jml); 

//把菜单项(jmi1)放入菜单(jml) 

jml.add(jmi1); 

jml.add(jmi2); 

 

//放入到JFrame 

this.add(jta); 

this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); 

this.setSize(400,500); 

this.setVisible(true); 

} 

 

@Override 

public void actionPerformed(ActionEvent e) { 

//判断是哪个菜单被选中 

if(e.getActionCommand().equals("open"))//打开菜单 

{ 

System.out.println("点击了打开菜单项！"); 

//隆重推荐JFileChooser 

//文件选择组件 

JFileChooser jfc1=new JFileChooser(); 

//设置名字 

jfc1.setDialogTitle("请选择文件...."); 

//按默认方式显示打开文件对话框 

jfc1.showOpenDialog(null); 

//显示 

jfc1.setVisible(true); 

 

//得到用户选择的文件全路径 

String filename=jfc1.getSelectedFile().getAbsolutePath(); 

 

//读取文件中的内容 

FileReader fr=null; 

BufferedReader br=null; 

try { 

fr=new FileReader(filename); 

br=new BufferedReader(fr); 

//从文件中读取信息并显示到jta 

String s=""; 

String allCon=""; 

while((s=br.readLine())!=null) 

{ 

allCon+=s+"\r\n"; 

} 

//放置到jta 

jta.setText(allCon); 

 

} catch (Exception e2) { 

e2.printStackTrace(); 

}finally{ 

try { 

fr.close(); 

br.close(); 

} catch (Exception e3) { 

e3.printStackTrace(); 

} 

} 

} 

else if(e.getActionCommand().equals("save")) 

{ 

System.out.println("点击了保存菜单项！"); 

//隆重推荐JFileChooser 

//出现保存对话框 

JFileChooser jfc1=new JFileChooser(); 

//设置名字 

jfc1.setDialogTitle("另存为...."); 

//按默认方式显示保存文件对话框 

jfc1.showSaveDialog(null); 

//显示 

jfc1.setVisible(true); 

 

//得到用户选择的文件全路径 

String filename=jfc1.getSelectedFile().getAbsolutePath(); 

 

//把内容写入到指定的文件 

FileWriter fw=null; 

BufferedWriter bw=null; 

try { 

fw=new FileWriter(filename); 

bw=new BufferedWriter(fw); 

//写入 

bw.write(this.jta.getText()); 

 

} catch (Exception e2) { 

e2.printStackTrace(); 

}finally{ 

try { 

bw.close(); 

fw.close(); 

} catch (Exception e3) { 

e3.printStackTrace(); 

} 

} 

} 

} 

} 

 

测试声音_ TestAudio.java 

/* 

* 测试声音 

*/ 

 

package com.test2; 

 

import java.io.*; 

import javax.sound.sampled.*; 

 

 

public class TestAudio { 

 

/** 

* @param args 

*/ 

public static void main(String[] args) { 

//1.创建建一个AePlayWave对象实例 

AePlayWave apw=new AePlayWave("./src/声音.wav"); 

//2.启动该线程播放 

apw.start(); 

} 

 

} 

 

//播放声音的类 

class AePlayWave extends Thread { 

 

private String filename; 

public AePlayWave(String wavfile) { 

filename = wavfile; 

 

} 

 

public void run() { 

 

File soundFile = new File(filename); 

 

AudioInputStream audioInputStream = null; 

try { 

audioInputStream = AudioSystem.getAudioInputStream(soundFile); 

} catch (Exception e1) { 

e1.printStackTrace(); 

return; 

} 

 

AudioFormat format = audioInputStream.getFormat(); 

SourceDataLine auline = null; 

DataLine.Info info = new DataLine.Info(SourceDataLine.class, format); 

 

try { 

auline = (SourceDataLine) AudioSystem.getLine(info); 

auline.open(format); 

} catch (Exception e) { 

e.printStackTrace(); 

return; 

} 

 

auline.start(); 

int nBytesRead = 0; 

//这是缓冲 

byte[] abData = new byte[512]; 

 

try { 

while (nBytesRead != -1) { 

nBytesRead = audioInputStream.read(abData, 0, abData.length); 

if (nBytesRead >= 0) 

auline.write(abData, 0, nBytesRead); 

} 

} catch (IOException e) { 

e.printStackTrace(); 

return; 

} finally { 

auline.drain(); 

auline.close(); 

} 

} 

} 

坦克大战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.test1; 

import java.awt.*; 

 

import javax.imageio.ImageIO; 

import javax.swing.*; 

 

import java.awt.event.*; 

import java.util.*; 

import java.io.*; 

 

public class MyTankGame3 extends JFrame implements ActionListener 

{ 

 

MyPanel mp=null; //游戏面板 

MyStartPanel msp=null; //开始面板 

//需要的菜单 

JMenuBar jmb=null; 

//开始游戏 

JMenu jm1=null; //菜单 

JMenuItem jmi1=null;//菜单项 

JMenuItem jmi2=null;//退出 

JMenuItem jmi3=null;//存盘退出 

JMenuItem jmi4=null;//续上局 

 

//构造函数 

public MyTankGame3() 

{ 

//创建菜单及菜单项 

jmb=new JMenuBar(); 

jm1=new JMenu("游戏(G)"); 

jm1.setMnemonic('G');//设置快捷方式 

 

jmi1=new JMenuItem("开始新游戏(N)"); 

jmi1.setMnemonic('N');//设置快捷方式 

jmi2=new JMenuItem("退出游戏(E)"); 

jmi2.setMnemonic('E');//设置快捷方式 

jmi3=new JMenuItem("存盘退出游戏(E)"); 

jmi3.setMnemonic('C');//设置快捷方式 

jmi4=new JMenuItem("继续上局游戏(R)"); 

jmi4.setMnemonic('R');//设置快捷方式 

 

jm1.add(jmi1);//将菜单项(jmi1)加入菜单(jm1) 

jm1.add(jmi2); 

jm1.add(jmi3); 

jm1.add(jmi4); 

jmb.add(jm1);//将菜单(jm1)加入菜单栏 

 

//对jmi1i添加事件响应 

jmi1.addActionListener(this); 

jmi1.setActionCommand("newGame"); 

jmi2.addActionListener(this); 

jmi2.setActionCommand("exit"); 

jmi3.addActionListener(this); 

jmi3.setActionCommand("saveExit"); 

jmi4.addActionListener(this); 

jmi4.setActionCommand("conGame"); 

 

//加入提示面板 

msp=new MyStartPanel(); 

this.add(msp); 

Thread t=new Thread(msp); 

t.start(); 

 

this.setJMenuBar(jmb);//加入菜单栏 

this.setSize(600,500); 

this.setLocation(200,200); 

this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); 

this.setVisible(true); 

} 

 

public static void main(String[] args) { 

MyTankGame3 mtg=new MyTankGame3(); 

} 

 

@Override 

public void actionPerformed(ActionEvent e) { 

//开始新的游戏 

if(e.getActionCommand().equals("newGame")) 

{ 

//创建游戏战场面板 

mp=new MyPanel("newGame"); 

 

//启动mp线程 

Thread t=new Thread(mp); 

t.start(); 

this.remove(msp);//先删除旧的开始面板 

this.add(mp); //然后加入新的游戏面板 

 

//注册监听 

this.addKeyListener(mp); 

//显示、刷新JFrame 

this.setVisible(true); 

} 

else if(e.getActionCommand().equals("exit")) 

{ 

//用户点击了退出系统的菜单 

//保存击毁敌人数量 

Recorder.keepRecording(); 

 

System.exit(0);//退出,0代表正常退出,-1代表异常退出 

} 

//对存盘退出处理 

else if(e.getActionCommand().equals("saveExit")) 

{ 

//工作 

Recorder rd=new Recorder(); 

rd.setEts(mp.ets); 

//保存击毁敌人的数量和坐标 

rd.keeyRecAndEnemyTank(); 

System.exit(0);//退出 

} 

else if(e.getActionCommand().equals("conGame"))//续上局 

{ 

//创建游戏战场面板 

mp=new MyPanel("conGame"); 

//mp.flag="con"; 

 

//启动mp线程 

Thread t=new Thread(mp); 

t.start(); 

this.remove(msp);//先删除旧的开始面板 

this.add(mp); //然后加入新的游戏面板 

 

//注册监听 

this.addKeyListener(mp); 

//显示、刷新JFrame 

this.setVisible(true); 

} 

} 

} 

//开始提示面板 

class MyStartPanel extends JPanel implements Runnable 

{ 

int times=0; 

public void paint(Graphics g) 

{ 

super.paint(g); 

g.fillRect(0, 0, 400, 300); 

//提示信息 

if(times%2==0) 

{ 

//开关信息的字体 

g.setColor(Color.yellow);//设置画笔颜色 

Font myFont=new Font("华文彩云",Font.BOLD,30); 

g.setFont(myFont); 

g.drawString("stage:1", 130, 150); 

} 

} 

 

@Override 

public void run() { 

// 

while(true) 

{ 

//休眠 

try { 

Thread.sleep(100); 

} catch (Exception e) { 

e.printStackTrace(); 

} 

times++; 

//重画 

this.repaint(); 

} 

} 

} 

 

//我的面板 

class MyPanel extends JPanel implements KeyListener,Runnable 

{ 

//定义一个我的坦克 

Hero hero=null; 

 

//判断是续上局，还是新游戏 

//String flag="newGame"; 

 

//定义敌人的坦克组 

Vector<EnemyTank>ets=new Vector<EnemyTank>(); 

Vector<Node>nodes=new Vector<Node>(); 

 

//定义ZhaDan集合 

Vector<Bomb>bombs=new Vector<Bomb>(); 

 

//初始化敌人坦克数量 

int enSize=6; 

 

//定义三张图片，组成成一颗ZhaDan 

Image image1=null; 

Image image2=null; 

Image image3=null; 

 

//构造函数 

public MyPanel(String flag) 

//构造函数中的参数，用于判断是续上局，还是新游戏 

{ 

Recorder.getRecording();//恢复记录 

 

hero=new Hero(100,200); 

if(flag.equals("newGame"))//如果是新游戏 

{ 

//初始化敌人的坦克 

for(int i=0;i<enSize;i++) 

{ 

//创建一个辆敌人的坦克对象 

EnemyTank et=new EnemyTank((i+1)*50,0); 

et.setColor(0);//设置颜色 

et.setDirect(2);//设置方向 

//将MyPanel的敌人坦克向量交给敌人坦克 

et.setEts(ets); 

//启动敌人的坦克 

Thread t=new Thread(et); 

t.start(); 

//给敌人坦克添加一颗子弹 

Shot s=new Shot(et.x+10,et.y+30,2); 

//把子弹加入给敌人 

et.ss.add(s); 

//启动子弹敌人的子弹线程 

Thread t2=new Thread(s); 

t2.start(); 

//加入 

ets.add(et); 

} 

} 

else //如果不新游戏 

{ 

nodes=new Recorder().getNodesAndEnNums();//恢复敌人坦克 

//初始化敌人的坦克 

for(int i=0;i<nodes.size();i++) 

{ 

Node node=nodes.get(i); 

//创建一个辆敌人的坦克对象 

EnemyTank et=new EnemyTank(node.x,node.y); 

et.setColor(0);//设置颜色 

et.setDirect(node.direct);//设置方向 

//将MyPanel的敌人坦克向量交给敌人坦克 

et.setEts(ets); 

//启动敌人的坦克 

Thread t=new Thread(et); 

t.start(); 

//给敌人坦克添加一颗子弹 

Shot s=new Shot(et.x+10,et.y+30,2); 

//把子弹加入给敌人 

et.ss.add(s); 

//启动子弹敌人的子弹线程 

Thread t2=new Thread(s); 

t2.start(); 

//加入 

ets.add(et); 

} 

} 

try{ 

image1=ImageIO.read(new File("./src/bomb_1.gif")); 

image2=ImageIO.read(new File("./src/bomb_2.gif")); 

image3=ImageIO.read(new File("./src/bomb_3.gif")); 

}catch (Exception e) 

{ 

e.printStackTrace(); 

} 

 

//播放开战声音 

AePlayWave apw=new AePlayWave("./src/声音.wav"); 

apw.start(); 

 

//初始化图片 

//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(Graphics g) 

{ 

//敌人的坦克提示信息 

this.drawTank(60, 330, g, 3, 0); 

g.setColor(Color.black); 

g.drawString(Recorder.getEnNum()+"", 85, 350); 

//我的坦克提示信息 

this.drawTank(130, 330, g, 3, 1); 

g.setColor(Color.black); 

g.drawString(Recorder.getMyLife()+"", 155, 350); 

 

//画出玩家的总成绩 

g.setColor(Color.black); 

Font f=new Font("宋体",Font.BOLD,20); 

g.setFont(f); 

g.drawString("您的总成绩：", 420, 30); 

 

this.drawTank(430, 60, g, 3, 0);//敌人坦克 

g.setColor(Color.black); 

g.drawString(Recorder.getAllEnNum()+"", 460, 80); 

} 

 

 

//重写paint函数 

public void paint(Graphics g) 

{ 

super.paint(g); //这句不能少 

g.fillRect(0,0,400,300);//设置游戏面板背景 

 

//画出提示信息 

this.showInfo(g); 

 

//画出自己的坦克 

if(hero.isLive) 

{ 

this.drawTank(hero.getX(), hero.getY(), g, this.hero.direct, 1); 

} 

//从ss中取出每一颗子弹，并画出 

for(int i=0;i<this.hero.ss.size();i++) //设置子弹连发 

{ 

//取出一颗子弹 

Shot myShot=hero.ss.get(i); 

 

//画出一颗子弹 

if(hero.s!=null&&hero.s.isLive==true) 

{ 

g.setColor(Color.WHITE);//设置子弹颜色 

g.fill3DRect(myShot.x, myShot.y, 3, 3, true); 

} 

if(myShot.isLive==false)//如果子弹已经死亡 

{ 

//从ss中删除掉该子弹 

hero.ss.remove(myShot); 

} 

} 

 

//画出ZhaDan 

for(int i=0;i<bombs.size();i++) 

{ 

//System.out.println("bombs.size()="+bombs.size()); 

//取出ZhaDan 

Bomb b=bombs.get(i); 

if(b.life>6) 

{ 

g.drawImage(image1, b.x, b.y, 30, 30, this); 

} 

else if(b.life>4) 

{ 

g.drawImage(image2, b.x, b.y, 30, 30, this); 

} 

else 

{ 

g.drawImage(image3, b.x, b.y, 30, 30, this); 

} 

//让b的生命值减小 

b.lifeDown(); 

if(b.life==0)//如果ZhaDan生命值为0时，就把ZhaDan从集合中去掉 

{ 

bombs.remove(b); 

} 

} 

 

//画出敌人的坦克 

for(int i=0;i<ets.size();i++) 

{ 

EnemyTank et=ets.get(i); 

if(et.isLive) //画出还是活的坦克 

{ 

this.drawTank(et.getX(), et.getY(), g, et.getDirect(), 0); 

//再画出敌人的子弹 

for(int j=0;j<et.ss.size();j++) 

{ 

//取出子弹 

Shot enemyShot=et.ss.get(j); 

if(enemyShot.isLive) 

{ 

g.setColor(Color.PINK);//设置子弹颜色 

g.fill3DRect(enemyShot.x, enemyShot.y, 3, 3, true);//画子弹 

} 

else //如果敌人的坦克死亡了就从Vector去掉 

{ 

et.ss.remove(enemyShot); 

} 

} 

} 

} 

} 

 

//判断我的子弹是否击中敌人的坦克 

public void hitEnemyTank() 

{ 

//在这run函数里判断子弹是否击中敌人坦克 

for(int i=0;i<hero.ss.size();i++) 

{ 

//取出子弹 

Shot myShot=hero.ss.get(i); 

if(myShot.isLive)//判断子弹是否还是活的或有效 

{ 

//取出每个坦克，与它判断 

for(int j=0;j<ets.size();j++) 

{ 

//取出坦克 

EnemyTank et=ets.get(j); 

if(et.isLive) 

{ 

if(this.hitTank(myShot,et)) 

{ 

//减少一个敌人坦克 

Recorder.redurceEnNum(); 

//增加我的记录(战绩) 

Recorder.addEnNumRec(); 

} 

} 

} 

} 

} 

} 

 

//敌人的子弹是否击中我 

public void hitMe() 

{ 

//取出每一个敌人的坦克 

for(int i=0;i<this.ets.size();i++) 

{ 

//取出坦克 

EnemyTank et=ets.get(i); 

 

//取出每一颗子弹 

for(int j=0;j<et.ss.size();j++) 

{ 

//取出子弹 

Shot enemyShot=et.ss.get(j); 

if(hero.isLive) 

{ 

this.hitTank(enemyShot, hero); 

} 

} 

} 

} 

 

//1.写一个专门判断子弹是否击中敌人坦克的函数 

public boolean hitTank(Shot s,Tank et) 

{ 

boolean bool=false; //判断坦克是否被击中 

//判断该坦克的方向 

switch(et.direct) 

{ 

//如果敌人坦克的方向是右或者是左 

case 0: 

case 1: 

if(s.x>et.x&&s.x<et.x+30&&s.y>et.y&&s.y<et.y+20) 

{ 

//击中 

s.isLive=false; //子弹死亡 

et.isLive=false;//敌人坦克死亡 

bool=true; 

//创建一颗ZhaDan 

Bomb b=new Bomb(et.x,et.y); 

//把ZhaDan放入到Vector 

bombs.add(b); 

} 

break; 

//如果敌人坦克的方向是上或者是下 

case 2: 

case 3: 

if(s.x>et.x&&s.x<et.x+20&&s.y>et.y&&s.y<et.y+30) 

{ 

//击中 

s.isLive=false; //子弹死亡 

et.isLive=false;//敌人坦克死亡 

bool=false; 

//创建一颗ZhaDan 

Bomb b=new Bomb(et.x,et.y); 

//把ZhaDan放入到Vector 

bombs.add(b); 

} 

break; 

} 

return bool; 

} 

 

 

//画出坦克的函数(扩展) 

public void drawTank(int x,int y,Graphics g,int direct,int type) 

{ 

//判断坦克的类型 

switch(type) 

{ 

case 0: 

g.setColor(Color.cyan); 

break; 

case 1: 

g.setColor(Color.yellow); 

break; 

} 

 

//判断方向 

switch(direct) 

{ 

case 0: //向右 

//画出上面的矩形 

g.fill3DRect(x, y, 30, 5, false); 

//画出下面的矩形 

g.fill3DRect(x, y+15, 30, 5, false); 

//画出中间的矩形 

g.fill3DRect(x+5, y+5, 20, 10, false); 

//画出圆形 

g.fillOval(x+10, y+5, 10, 10); 

//画出线 

g.drawLine(x+15, y+10, x+30, y+10); 

//画齿轮 

g.setColor(Color.darkGray); 

g.drawLine(x+2, y+1, x+2, y+4); 

g.drawLine(x+5, y+1, x+5, y+4); 

g.drawLine(x+8, y+1, x+8, y+4); 

g.drawLine(x+11, y+1, x+11, y+4); 

g.drawLine(x+14, y+1, x+14, y+4); 

g.drawLine(x+17, y+1, x+17, y+4); 

g.drawLine(x+20, y+1, x+20, y+4); 

g.drawLine(x+23, y+1, x+23, y+4); 

g.drawLine(x+26, y+1, x+26, y+4); 

 

g.drawLine(x+2, y+16, x+2, y+19); 

g.drawLine(x+5, y+16, x+5, y+19); 

g.drawLine(x+8, y+16, x+8, y+19); 

g.drawLine(x+11, y+16, x+11, y+19); 

g.drawLine(x+14, y+16, x+14, y+19); 

g.drawLine(x+17, y+16, x+17, y+19); 

g.drawLine(x+20, y+16, x+20, y+19); 

g.drawLine(x+23, y+16, x+23, y+19); 

g.drawLine(x+26, y+16, x+27, y+19); 

break; 

case 1: //向左 

//画出上面的矩形 

g.fill3DRect(x, y, 30, 5, false); 

//画出下面的矩形 

g.fill3DRect(x, y+15, 30, 5, false); 

//画出中间的矩形 

g.fill3DRect(x+5, y+5, 20, 10, false); 

//画出圆形 

g.fillOval(x+10, y+5, 10, 10); 

//画出线 

g.drawLine(x+15, y+10, x, y+10); 

//画齿轮 

g.setColor(Color.darkGray); 

g.drawLine(x+2, y+1, x+2, y+4); 

g.drawLine(x+5, y+1, x+5, y+4); 

g.drawLine(x+8, y+1, x+8, y+4); 

g.drawLine(x+11, y+1, x+11, y+4); 

g.drawLine(x+14, y+1, x+14, y+4); 

g.drawLine(x+17, y+1, x+17, y+4); 

g.drawLine(x+20, y+1, x+20, y+4); 

g.drawLine(x+23, y+1, x+23, y+4); 

g.drawLine(x+26, y+1, x+26, y+4); 

 

g.drawLine(x+2, y+16, x+2, y+19); 

g.drawLine(x+5, y+16, x+5, y+19); 

g.drawLine(x+8, y+16, x+8, y+19); 

g.drawLine(x+11, y+16, x+11, y+19); 

g.drawLine(x+14, y+16, x+14, y+19); 

g.drawLine(x+17, y+16, x+17, y+19); 

g.drawLine(x+20, y+16, x+20, y+19); 

g.drawLine(x+23, y+16, x+23, y+19); 

g.drawLine(x+26, y+16, x+27, y+19); 

break; 

case 2: //向下 

//画出我的坦克(到时封装成一个函数) 

//1.画出左边的矩形 

g.fill3DRect(x, y, 5, 30,false); 

//2.画出右边的矩形 

g.fill3DRect(x+15, y, 5, 30,false); 

//3.画出中间矩形 

g.fill3DRect(x+5, y+5, 10, 20,false); 

//4.画出中间的圆形 

g.fillOval(x+5, y+10, 10, 10); 

//5.画出线 

g.drawLine(x+10, y+15, x+10, y+30); 

 

//画齿轮 

g.setColor(Color.darkGray); 

g.drawLine(x+1, y+2, x+4, y+2); 

g.drawLine(x+1, y+5, x+4, y+5); 

g.drawLine(x+1, y+8, x+4, y+8); 

g.drawLine(x+1, y+11, x+4, y+11); 

g.drawLine(x+1, y+14, x+4, y+14); 

g.drawLine(x+1, y+17, x+4, y+17); 

g.drawLine(x+1, y+20, x+4, y+20); 

g.drawLine(x+1, y+23, x+4, y+23); 

g.drawLine(x+1, y+27, x+4, y+27); 

 

g.drawLine(x+16, y+2, x+19, y+2); 

g.drawLine(x+16, y+5, x+19, y+5); 

g.drawLine(x+16, y+8, x+19, y+8); 

g.drawLine(x+16, y+11, x+19, y+11); 

g.drawLine(x+16, y+14, x+19, y+14); 

g.drawLine(x+16, y+17, x+19, y+17); 

g.drawLine(x+16, y+20, x+19, y+20); 

g.drawLine(x+16, y+23, x+19, y+23); 

g.drawLine(x+16, y+27, x+19, y+27); 

break; 

case 3: //向上 

//画出我的坦克(到时封装成一个函数) 

//1.画出左边的矩形 

g.fill3DRect(x, y, 5, 30,false); 

//2.画出右边的矩形 

g.fill3DRect(x+15, y, 5, 30,false); 

//3.画出中间矩形 

g.fill3DRect(x+5, y+5, 10, 20,false); 

//4.画出中间的圆形 

g.fillOval(x+5, y+10, 10, 10); 

//5.画出线 

g.drawLine(x+10, y+15, x+10, y); 

 

//画齿轮 

g.setColor(Color.darkGray); 

g.drawLine(x+1, y+2, x+4, y+2); 

g.drawLine(x+1, y+5, x+4, y+5); 

g.drawLine(x+1, y+8, x+4, y+8); 

g.drawLine(x+1, y+11, x+4, y+11); 

g.drawLine(x+1, y+14, x+4, y+14); 

g.drawLine(x+1, y+17, x+4, y+17); 

g.drawLine(x+1, y+20, x+4, y+20); 

g.drawLine(x+1, y+23, x+4, y+23); 

g.drawLine(x+1, y+27, x+4, y+27); 

 

g.drawLine(x+16, y+2, x+19, y+2); 

g.drawLine(x+16, y+5, x+19, y+5); 

g.drawLine(x+16, y+8, x+19, y+8); 

g.drawLine(x+16, y+11, x+19, y+11); 

g.drawLine(x+16, y+14, x+19, y+14); 

g.drawLine(x+16, y+17, x+19, y+17); 

g.drawLine(x+16, y+20, x+19, y+20); 

g.drawLine(x+16, y+23, x+19, y+23); 

g.drawLine(x+16, y+27, x+19, y+27); 

break; 

} 

} 

 

@Override 

public void keyPressed(KeyEvent e) //键按下处理 

{ 

//a表示向左，s表示向上，w表示向上，d表示向右 

if(e.getKeyCode()==KeyEvent.VK_D) 

{ 

this.hero.setDirect(0);//设置我的坦克的方向,向右 

this.hero.moveRight(); 

} 

else if(e.getKeyCode()==KeyEvent.VK_A) 

{ 

this.hero.setDirect(1);//向左 

this.hero.moveLeft(); 

} 

else if(e.getKeyCode()==KeyEvent.VK_S) 

{ 

this.hero.setDirect(2);//向下 

this.hero.moveDown(); 

} 

else if(e.getKeyCode()==KeyEvent.VK_W) 

{ 

this.hero.setDirect(3);//向上 

this.hero.moveUp(); 

} 

 

if(e.getKeyCode()==KeyEvent.VK_J) 

{ 

//判断玩家是否按下j 

//发射子弹 

if(this.hero.ss.size()<=4)//连发子弹小于5 

{ 

this.hero.shotEnemy(); 

} 

} 

//重绘Panel 

this.repaint(); 

} 

 

@Override 

public void keyReleased(KeyEvent e) 

{ 

 

} 

 

@Override 

public void keyTyped(KeyEvent e) 

{ 

 

} 

 

@Override 

public void run() { 

//每隔100毫秒去重绘 

while(true) 

{ 

try { 

Thread.sleep(100); 

} catch (InterruptedException e) { 

// TODO Auto-generated catch block 

e.printStackTrace(); 

} 

 

//2.什么地方调用-判断子弹是否击中敌人坦克的函数 

 

this.hitEnemyTank();//子弹是否击中敌人坦克 

 

this.hitMe();//敌人的坦克是否击中我了 

 

//重绘 

this.repaint(); 

} 

} 

} 

Members.java 

package com.test1; 

 

import java.util.*; 

import java.io.*; 

 

import javax.sound.sampled.AudioFormat; 

import javax.sound.sampled.AudioInputStream; 

import javax.sound.sampled.AudioSystem; 

import javax.sound.sampled.DataLine; 

import javax.sound.sampled.SourceDataLine; 

 

//播放声音的类 

class AePlayWave extends Thread { 

 

private String filename; 

public AePlayWave(String wavfile) { 

filename = wavfile; 

 

} 

 

public void run() { 

 

File soundFile = new File(filename); 

 

AudioInputStream audioInputStream = null; 

try { 

audioInputStream = AudioSystem.getAudioInputStream(soundFile); 

} catch (Exception e1) { 

e1.printStackTrace(); 

return; 

} 

 

AudioFormat format = audioInputStream.getFormat(); 

SourceDataLine auline = null; 

DataLine.Info info = new DataLine.Info(SourceDataLine.class, format); 

 

try { 

auline = (SourceDataLine) AudioSystem.getLine(info); 

auline.open(format); 

} catch (Exception e) { 

e.printStackTrace(); 

return; 

} 

 

auline.start(); 

int nBytesRead = 0; 

//这是缓冲 

byte[] abData = new byte[512]; 

 

try { 

while (nBytesRead != -1) { 

nBytesRead = audioInputStream.read(abData, 0, abData.length); 

if (nBytesRead >= 0) 

auline.write(abData, 0, nBytesRead); 

} 

} catch (IOException e) { 

e.printStackTrace(); 

return; 

} finally { 

auline.drain(); 

auline.close(); 

} 

} 

} 

 

 

//坦克恢复点 

class Node 

{ 

int x,y,direct; 

public Node(int x,int y,int z) 

{ 

this.x=x; 

this.y=y; 

this.direct=direct; 

} 

} 

 

//记录类，同时也可以保存玩家的设置 

class Recorder 

{ 

//记录每关有多少敌人 

private static int enNum=20; 

//设置我有多少可以用的坦克 

private static int myLife=3; 

//记录总共消灭了多少敌人 

private static int allEnNum=0; 

 

private static FileWriter fw=null;//文件流 

private static BufferedWriter bw=null;//buf流 

private static FileReader fr=null; 

private static BufferedReader br=null; 

//定义一个集合用于保存敌人的坦克 

private Vector<EnemyTank>ets=new Vector<EnemyTank>(); 

//从文件中恢复记录点 

static Vector<Node> nodes=new Vector<Node>(); 

 

public Vector<EnemyTank> getEts() { 

return ets; 

} 

public void setEts(Vector<EnemyTank> ets) { 

this.ets = ets; 

} 

public static int getAllEnNum() { 

return allEnNum; 

} 

public static void setAllEnNum(int allEnNum) { 

Recorder.allEnNum = allEnNum; 

} 

public static int getEnNum() { 

return enNum; 

} 

public static void setEnNum(int enNum) { 

Recorder.enNum = enNum; 

} 

public static int getMyLife() { 

return myLife; 

} 

public static void setMyLife(int myLife) { 

Recorder.myLife = myLife; 

} 

//减少敌人数 

public static void redurceEnNum() 

{ 

enNum--; 

} 

//消灭敌人 

public static void addEnNumRec() 

{ 

allEnNum++; 

} 

 

//保存击毁敌人坦克的数量、坐标和方向 

public void keeyRecAndEnemyTank() 

{ 

try { 

//创建 

fw=new FileWriter("./myRecording.txt"); 

bw=new BufferedWriter(fw); 

 

bw.write(allEnNum+"\r\n"); 

//System.out.println("size="+ets.size()); 

//保存当前活的敌人坦克的坐标和方向 

for(int i=0;i<ets.size();i++) 

{ 

//取出第一个坦克 

EnemyTank et=ets.get(i); 

if(et.isLive) 

{ 

//活的就保存,坐标与方向 

String recorde=et.x+" "+et.y+" "+et.direct; 

//写入 

bw.write(recorde+"\r\n"); 

} 

} 

 

} catch (Exception e) { 

e.printStackTrace(); 

}finally{ 

 

//关闭流 

try { 

//后开先关闭 

bw.close(); 

fw.close(); 

} catch (Exception e) { 

e.printStackTrace(); 

} 

} 

} 

 

//把玩家击毁敌人坦克数量保存到文件中 

public static void keepRecording() 

{ 

try { 

//创建 

fw=new FileWriter("./myRecording.txt"); 

bw=new BufferedWriter(fw); 

 

bw.write(allEnNum+"\r\n"); 

} catch (Exception e) { 

e.printStackTrace(); 

}finally{ 

try { 

bw.close(); 

fw.close();//关闭流 

} catch (IOException e) { 

e.printStackTrace(); 

} 

} 

} 

 

 

//完成恢复退出时的记录 

public Vector<Node> getNodesAndEnNums() 

{ 

try { 

fr=new FileReader("./myRecording.txt"); 

br=new BufferedReader(fr); //读取记录 

String n=""; 

n=br.readLine();//先读取一行 

allEnNum=Integer.parseInt(n); 

while((n=br.readLine())!=null) 

{ 

String []xyz=n.split(" ");//读取以空格分隔的字符 

Node node=new Node(Integer.parseInt(xyz[0]), 

Integer.parseInt(xyz[1]),Integer.parseInt(xyz[2])); 

nodes.add(node); 

 

} 

 

} catch (Exception e) { 

e.printStackTrace(); 

}finally{ 

try { 

br.close(); 

fr.close();//关闭流 

} catch (IOException e) { 

// TODO Auto-generated catch block 

e.printStackTrace(); 

} 

} 

return nodes; 

} 

 

//从文件中读取记录 

public static void getRecording() 

{ 

try { 

fr=new FileReader("./myRecording.txt"); 

br=new BufferedReader(fr); //读取记录 

String n=br.readLine(); //将读取的记录存到string中 

allEnNum=Integer.parseInt(n); 

} catch (Exception e) { 

e.printStackTrace(); 

}finally{ 

try { 

br.close(); 

fr.close();//关闭流 

} catch (IOException e) { 

// TODO Auto-generated catch block 

e.printStackTrace(); 

} 

} 

} 

} 

 

 

//ZhaDan类 

class Bomb 

{ 

//定义ZhaDan的坐标 

int x,y; 

//ZhaDan的生命 

int life=9; 

//ZhaDan是否还是活的 

boolean isLive=true; 

public Bomb(int x,int y) 

{ 

this.x=x; 

this.y=y; 

} 

//减少ZhaDan生命值 

public void lifeDown() 

{ 

if(life>0) 

{ 

life--; 

} 

else 

{ 

this.isLive=false; 

} 

} 

} 

 

//子弹类 

class Shot implements Runnable 

{ 

int x,y,direct; 

int speed=3; 

//是否还活着 

boolean isLive=true; 

 

public Shot(int x,int y,int direct) 

{ 

this.x=x; 

this.y=y; 

this.direct=direct; 

} 

 

@Override 

public void run() { 

//子弹向前跑动 

while(true) 

{ 

try { 

Thread.sleep(50); 

} catch (InterruptedException e) { 

// TODO Auto-generated catch block 

e.printStackTrace(); 

} 

switch(direct) 

{ 

case 0: //子弹向右 

x+=speed; 

break; 

case 1: //子弹向左 

x-=speed; 

break; 

case 2: //子弹向下 

y+=speed; 

break; 

case 3: //子弹向上 

y-=speed; 

break; 

} 

//System.out.println("子弹坐标x="+x+" y="+y); 

 

//子弹何时死亡 

//判断该子弹是否碰到边缘 

if(x<0||x>400||y<0||y>300) 

{ 

this.isLive=false; 

break; 

} 

} 

} 

} 

 

 

//坦克类 

class Tank 

{ 

//表示坦克的横坐标 

int x=0; 

//坦克纵坐标 

int y=0; 

//坦克方向 

int direct=3;//0表示右，1表示左，2表示下，3表示上 

//坦克的速度 

int speed=1; 

//坦克的颜色 

int color; 

 

boolean isLive=true; 

 

public int getColor() { 

return color; 

} 

 

public void setColor(int color) { 

this.color = color; 

} 

 

public int getSpeed() { 

return speed; 

} 

 

public void setSpeed(int speed) { 

this.speed = speed; 

} 

 

public int getDirect() { 

return direct; 

} 

 

public void setDirect(int direct) { 

this.direct = direct; 

} 

 

public int getX() { 

return x; 

} 

 

public void setX(int x) { 

this.x = x; 

} 

 

public int getY() { 

return y; 

} 

 

public void setY(int y) { 

this.y = y; 

} 

 

public Tank(int x,int y) 

{ 

this.x=x; 

this.y=y; 

} 

 

} 

 

//敌人的坦克,把敌人坦克做成线程类 

class EnemyTank extends Tank implements Runnable 

{ 

//boolean isLive=true;//是否死亡 

int times=0; 

 

//定义一个集合向量可以访问到MyPanel上所有敌人的坦克 

Vector<EnemyTank>ets=new Vector<EnemyTank>(); 

 

//定义一个集合向量，可以存放敌人的子弹 

Vector<Shot>ss=new Vector<Shot>(); 

 

//敌人添加子弹，应当在刚刚创建坦克和敌人的坦克子弹是死亡之后 

 

public EnemyTank(int x,int y) 

{ 

super(x,y); 

} 

 

//得到MyPanel的敌人坦克向量 

public void setEts(Vector<EnemyTank> ets) { 

this.ets = ets; 

} 

public Vector<EnemyTank> getEts() { 

return ets; 

} 

 

 

//判断是否碰到了别的敌人坦克 

public boolean isTouchOtherEnemy() 

{ 

boolean b=false; 

switch(this.direct) 

{ 

case 0: //坦克向右 

//取出所有的敌人坦克 

for(int i=0;i<ets.size();i++) 

{ 

//取出第一个坦克 

EnemyTank et=ets.get(i); 

if(et!=this)//如果不是自己 

{ 

//如果敌人的方向是向上或向下 

if(et.direct==3||et.direct==2) 

{ 

//如果此坦克的右上角点在其它坦克矩形区域内 

if(this.x+30>=et.x&&this.x+30<=et.x+20 

&&this.y>=et.y&&this.y<=et.y+30) 

{ 

return true; 

} 

//如果此坦克的右下角点在其它坦克矩形区域内 

if(this.x+30>=et.x&&this.x+30<=et.x+20 

&&this.y+20>=et.y&&this.y+20<=et.y+30) 

{ 

return true; 

} 

} 

//如果敌人的方向是向左或向右 

if(et.direct==1||et.direct==0) 

{ 

//如果此坦克的右上角点在其它坦克矩形区域内 

if(this.x+30>=et.x&&this.x+30<=et.x+30 

&&this.y>=et.y&&this.y<=et.y+20) 

{ 

return true; 

} 

//如果此坦克的右下角点在其它坦克矩形区域内 

if(this.x+30>=et.x&&this.x+30<=et.x+30 

&&this.y+20>=et.y&&this.y+20<=et.y+20) 

{ 

return true; 

} 

} 

} 

} 

break; 

case 1: //坦克向左 

//取出所有的敌人坦克 

for(int i=0;i<ets.size();i++) 

{ 

//取出第一个坦克 

EnemyTank et=ets.get(i); 

if(et!=this)//如果不是自己 

{ 

//如果敌人的方向是向上或向下 

if(et.direct==3||et.direct==2) 

{ 

//如果此坦克的左上角点在其它坦克矩形区域内 

if(this.x>=et.x&&this.x<=et.x+20 

&&this.y>=et.y&&this.y<=et.y+30) 

{ 

return true; 

} 

//如果此坦克的左下角点在其它坦克矩形区域内 

if(this.x>=et.x&&this.x<=et.x+20 

&&this.y+20>=et.y&&this.y+20<=et.y+30) 

{ 

return true; 

} 

} 

//如果敌人的方向是向左或向右 

if(et.direct==1||et.direct==0) 

{ 

//如果此坦克的左上角点在其它坦克矩形区域内 

if(this.x>=et.x&&this.x<=et.x+30 

&&this.y>=et.y&&this.y<=et.y+20) 

{ 

return true; 

} 

//如果此坦克的左下角点在其它坦克矩形区域内 

if(this.x>=et.x&&this.x<=et.x+30 

&&this.y+20>=et.y&&this.y+20<=et.y+20) 

{ 

return true; 

} 

} 

} 

} 

break; 

case 2: //我的坦克向下 

//取出所有的敌人坦克 

for(int i=0;i<ets.size();i++) 

{ 

//取出第一个坦克 

EnemyTank et=ets.get(i); 

if(et!=this)//如果不是自己 

{ 

//如果敌人的方向是向上或向下 

if(et.direct==3||et.direct==2) 

{ 

//如果此坦克的左下角点在其它坦克矩形区域内 

if(this.x>=et.x&&this.x<=et.x+20 

&&this.y+30>=et.y&&this.y+30<=et.y+30) 

{ 

return true; 

} 

//如果此坦克的右下角点在其它坦克矩形区域内 

if(this.x+20>=et.x&&this.x+20<=et.x+20 

&&this.y+30>=et.y&&this.y+30<=et.y+30) 

{ 

return true; 

} 

} 

//如果敌人的方向是向左或向右 

if(et.direct==1||et.direct==0) 

{ 

//如果此坦克的左下角点在其它坦克矩形区域内 

if(this.x>=et.x&&this.x<=et.x+30 

&&this.y+30>=et.y&&this.y+30<=et.y+20) 

{ 

return true; 

} 

//如果此坦克的右下角点在其它坦克矩形区域内 

if(this.x+20>=et.x&&this.x+20<=et.x+30 

&&this.y+30>=et.y&&this.y+30<=et.y+20) 

{ 

return true; 

} 

} 

} 

} 

break; 

case 3: //坦克向上 

//取出所有的敌人坦克 

for(int i=0;i<ets.size();i++) 

{ 

//取出第一个坦克 

EnemyTank et=ets.get(i); 

if(et!=this)//如果不是自己 

{ 

//如果敌人的方向是向上或向下 

if(et.direct==3||et.direct==2) 

{ 

//如果此坦克的左上角点在其它坦克矩形区域内 

if(this.x>=et.x&&this.x<=et.x+20 

&&this.y>=et.y&&this.y<=et.y+30) 

{ 

return true; 

} 

//如果此坦克的右上角点在其它坦克矩形区域内 

if(this.x+20>=et.x&&this.x+20<=et.x+20 

&&this.y>=et.y&&this.y<=et.y+30) 

{ 

return true; 

} 

} 

//如果敌人的方向是向左或向右 

if(et.direct==1||et.direct==0) 

{ 

//如果此坦克的左上角点在其它坦克矩形区域内 

if(this.x>=et.x&&this.x<=et.x+30 

&&this.y>=et.y&&this.y<=et.y+20) 

{ 

return true; 

} 

//如果此坦克的右上角点在其它坦克矩形区域内 

if(this.x+20>=et.x&&this.x+20<=et.x+30 

&&this.y>=et.y&&this.y<=et.y+20) 

{ 

return true; 

} 

} 

} 

} 

break; 

} 

 

return b; 

} 

 

 

@Override 

public void run() { 

//让敌人坦克坐标不停的变化 

while(true) 

{ 

switch(this.direct) 

{ 

case 0: //说明坦克正在向右移动 

for(int i=0;i<30;i++) 

{ 

if(x<380&&!this.isTouchOtherEnemy())//限制坦克不移出边界 

{ 

try { 

Thread.sleep(50); 

} catch (InterruptedException e) { 

// TODO Auto-generated catch block 

e.printStackTrace(); 

} 

x+=speed; 

} 

} 

break; 

case 1: //说明坦克正在向左移动 

for(int i=0;i<30;i++) 

{ 

if(x>0&&!this.isTouchOtherEnemy())//限制坦克不移出边界 

{ 

try { 

Thread.sleep(50); 

} catch (InterruptedException e) { 

// TODO Auto-generated catch block 

e.printStackTrace(); 

} 

x-=speed; 

} 

} 

break; 

case 2: //说明坦克正在向下移动 

for(int i=0;i<30;i++) 

{ 

if(y<280&&!this.isTouchOtherEnemy())//限制坦克不移出边界 

{ 

try { 

Thread.sleep(50); 

} catch (InterruptedException e) { 

// TODO Auto-generated catch block 

e.printStackTrace(); 

} 

y+=speed; 

} 

} 

break; 

case 3: //说明坦克正在向上移动 

for(int i=0;i<30;i++) 

{ 

if(y>0&&!this.isTouchOtherEnemy())//限制坦克不移出边界 

{ 

try { 

Thread.sleep(50); 

} catch (InterruptedException e) { 

// TODO Auto-generated catch block 

e.printStackTrace(); 

} 

y-=speed; 

} 

} 

break; 

} 

 

this.times++; 

 

if(times%2==0)//3秒时间到了 

{ 

if(isLive) 

{ 

if(ss.size()<5) 

{ 

Shot s=null; 

//添加子弹 

switch(direct) 

{ 

case 0: //坦克朝右 

//创建一颗子弹 

s=new Shot(x+30,y+9,0); 

//把子弹加入集合向量 

ss.add(s); 

break; 

case 1: //坦克朝左 

s=new Shot(x,y+9,1); 

//把子弹加入向量 

ss.add(s); 

break; 

case 2: //坦克朝下 

s=new Shot(x+9,y+30,2); 

//把子弹加入向量 

ss.add(s); 

break; 

case 3: //坦克朝上 

s=new Shot(x+9,y,3); 

//把子弹加入向量 

ss.add(s); 

break; 

} 

 

//启动子弹线程 

Thread t=new Thread(s); 

t.start(); 

} 

} 

} 

 

//让坦克随机产生一个新的方向 

this.direct=(int)(Math.random()*4); 

 

//判断敌人坦克是否死亡 

if(this.isLive==false) 

{ 

//让坦克死亡后退出线程 

break; 

} 

} 

} 

} 

 

//我的坦克 

class Hero extends Tank 

{ 

//子弹 

Shot s=null; 

//定义一个用于存放子弹的集合 

Vector<Shot> ss=new Vector<Shot>(); 

 

public Hero(int x,int y) 

{ 

super(x,y);//用父类的构造函数初始化子类的成员变量 

} 

 

//发射子弹 

public void shotEnemy() 

{ 

switch(this.direct) 

{ 

case 0: //坦克朝右 

//创建一颗子弹 

s=new Shot(x+30,y+9,0); 

//把子弹加入集合向量 

ss.add(s); 

break; 

case 1: //坦克朝左 

s=new Shot(x,y+9,1); 

//把子弹加入向量 

ss.add(s); 

break; 

case 2: //坦克朝下 

s=new Shot(x+9,y+30,2); 

//把子弹加入向量 

ss.add(s); 

break; 

case 3: //坦克朝上 

s=new Shot(x+9,y,3); 

//把子弹加入向量 

ss.add(s); 

break; 

} 

//启动子弹线程 

Thread t=new Thread(s); //因为子弹类Shot实现了Runnable接口 

t.start(); 

} 

 

//坦克向上移动 

public void moveUp() 

{ 

y-=speed; 

} 

//坦克向右移动 

public void moveRight() 

{ 

x+=speed; 

} 

//坦克向下移动 

public void moveDown() 

{ 

y+=speed; 

} 

//坦克向左移动 

public void moveLeft() 

{ 

x-=speed; 

} 

}
分享到：
| Java笔记6(多线程、机票售票系统、坦克大战 ...
评论
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    Java坦克大战+各开发过程版本+笔记

    本篇将详细介绍Java坦克大战的开发过程、关键技术和学习笔记。 首先，我们要理解Java坦克大战的基本架构。游戏通常由以下几个核心部分组成：游戏主循环、图形渲染、用户输入处理、物理引擎和游戏逻辑。在Java坦克...

    java学习笔记1（java io/nio）

    java学习笔记1（java io/nio）设计模式

    java记事本（仿有道云笔记）

    【标题】：“java记事本（仿有道云笔记）” 这个项目是一个基于Java编程语言实现的记事本软件，其设计灵感来源于知名的在线笔记应用——有道云笔记。与传统的Windows记事本相比，它提供了更为丰富和现代的功能，...

    JAVA编写的日历记事本 实现日历及记事本功能

    【标题】"JAVA编写的日历记事本 实现日历及记事本功能" 描述了一款基于Java编程语言开发的应用程序，该程序集成了日历和记事本两大功能。在Java中，这样的应用通常涉及到GUI（图形用户界面）设计、事件处理以及数据...

    java中IO完整笔记

    java 中文件的操作，适合基本入门的 ，

    java io流学习笔记1

    Java IO流是Java编程语言中处理输入输出操作的重要部分，尤其在数据传输、文件读写等方面发挥着核心作用。本文将深入探讨Java IO流的基本概念、类型以及它们在实际开发中的应用。 首先，理解IO流的基本概念至关重要...

    javaIO流笔记

    在Java中，输入/输出（Input/Output，简称IO）操作是程序与外部设备进行数据交换的重要方式。Java提供了强大的IO流处理类库，主要位于`java.io`包中。这些类库支持多种数据类型的操作，包括文本文件、二进制文件等。...

    java IO流详细笔记

    Java IO流详解

    教你如何将java代码拷贝到有道云笔记

    1. 代码准备：首先，你需要在开发环境中，比如MyEclipse中编写好Java代码，然后选中需要拷贝的代码段，执行复制操作。这一步骤中，确保代码是完整且没有语法错误的，因为一旦发现错误，高亮工具将无法正确解析。 2....

    java学习笔记之Java-IO操作共19页.pdf.zi

    Java-IO操作共19页的笔记详细介绍了这一关键领域，旨在帮助开发者掌握如何有效地读取、写入和管理数据。Java IO API提供了一套丰富的类和接口，使得开发者可以方便地进行文件读写、网络通信、流处理等操作。 1. **...

    日历记事本（java语言版）.rar

    《Java语言实现的日历记事本系统》 在IT领域，编程语言的运用无处不在，其中Java以其跨平台、面向对象的特点深受开发者喜爱。本项目“日历记事本（java语言版）”就是一个典型的应用实例，它充分展示了Java在开发...

    Java 的 IO流笔记.md

    ### Java IO流学习笔记 #### 一、IO流的四大抽象类 - **InputStream/OutputStream**：字节的输入输出流的抽象类。 - 数据单位：字节（8比特，范围0-255） - **Reader/Writer**：字符的输入输出流的抽象类。 - ...

    Java学习笔记-IO篇

    ### Java学习笔记-IO篇 #### 一、流的基本概念及分类 在Java中，**流**（Stream）是用于处理或传输数据的一种方式。它将数据视为一系列连续的字节序列或者字符序列进行处理。根据不同的标准，流可以分为多种类型：...

    宋红康java笔记.rar

    【宋红康java笔记】是一份综合性的Java学习资料，由知名编程教育者宋红康编撰。这份压缩包文件包含了大量的Java编程知识点，旨在帮助初学者和有经验的开发者深入理解和掌握Java语言的核心概念与高级特性。以下是根据...

    韩顺平循序渐进学java从入门到精通课件-笔记坦克大战全过程

    根据提供的文件内容，我们可以从中提炼出与Java编程和游戏开发相关的一系列知识点。以下是对该文件内容的详细解析： Java基础知识点： 1. Java类和对象的创建：文件中定义了多个类，如`Tanker1.0`、`MyPanel`、`...

    Java IO学习笔记+代码

    Java IO是Java编程语言中用于输入/输出操作的重要部分，它提供了一系列的类和方法来处理数据的读写，文件的创建、删除以及流的管理等。以下是对标题和描述中涉及的知识点的详细说明： 1. **文件对象的生成**： 在...

    java IO流学习笔记

    ### Java IO流学习笔记 #### 异常处理与IO流操作 在进行Java IO流的学习过程中，异常处理是非常重要的一个方面。本节将详细介绍如何在Java中处理异常，并结合具体的IO流操作进行说明。 #### 一、异常处理 在Java...

    java笔记.zip

    尚硅谷康师傅java学习笔记。 、2020-4-5 java学习笔记 2020-4-6 java笔记 ---内部类 2020-4-6 java笔记 ---异常 2020-4-6 java笔记 --多线程 2020-4-8 java笔记 String类 2020-4-9 java 比较器 2020-4-10 java笔记 ...

Magicbox
Global site tag (gtag.js) - Google Analytics