Java基础7

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

 

//定义炸弹集合

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

 

//初始化敌人坦克数量

int enSize=6;

 

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

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);

}

}

 

//画出炸弹

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

{

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

//取出炸弹

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)//如果炸弹生命值为0时，就把炸弹从集合中去掉

{

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;

//创建一颗炸弹

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

//把炸弹放入到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;

//创建一颗炸弹

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

//把炸弹放入到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();

}

}

}

}

 

 

//炸弹类

class Bomb

{

//定义炸弹的坐标

int x,y;

//炸弹的生命

int life=9;

//炸弹是否还是活的

boolean isLive=true;

public Bomb(int x,int y)

{

this.x=x;

this.y=y;

}

//减少炸弹生命值

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;

}

}