纯Java实现坦克大战游戏，源码公开(1)，解决外边距塌陷的问题

用户33914928060
69 阅读6分钟

文末

如果30岁以前，可以还不知道自己想去做什么的话，那30岁之后，真的觉得时间非常的宝贵，不能再浪费时间在一些碎片化的事情上，比如说看综艺，电视剧。一个人的黄金时间也就二，三十年，不能过得浑浑噩噩。所以花了基本上休息的时间，去不断的完善自己的知识体系，希望可以成为一个领域内的TOP。

同样是干到30岁，普通人写业务代码划水，榜样们深度学习拓宽视野晋升管理。

这也是为什么大家都说30岁是程序员的门槛，很多人迈不过去，其实各行各业都是这样都会有个坎，公司永远都缺的高级人才，只用这样才能在大风大浪过后，依然闪耀不被公司淘汰不被社会淘汰。

269页《前端大厂面试宝典》

包含了腾讯、字节跳动、小米、阿里、滴滴、美团、58、拼多多、360、新浪、搜狐等一线互联网公司面试被问到的题目，涵盖了初中级前端技术点。

前端面试题汇总

JavaScript

开源分享：docs.qq.com/doc/DSmRnRG… int enSize=3;//初始敌人坦克数量

//定义爆炸图片
Image image1=null;
Image image2=null;
Image image3=null;
	
//构造函数
public MyPanel(String flag){
	hero=new Hero(200, 270);//我的坦克初始位置
	//恢复游戏记录
	Recorder.getRecoring();
	if(flag.equals("newgame")){
		//播放开战声音
		apw=new AePlayWave("e:\\tankgame\\tankmusic.wav");
		apw.start();
		//初始化敌人的坦克
		for(int i=0;i<enSize;i++){
			//创建一辆敌人的坦克对象
			EnemyTank et=new EnemyTank((i+1)*50, 0);
			//初始敌人坦克颜色
			et.setColor(2);
			//初始敌人坦克的方向
			et.setDirect(1);
			
			//将MyPanel的敌人向量交给该敌人坦克
			et.setEts(ets);
			
			//启动敌人坦克进程
			Thread t=new Thread(et);
			t.start();
			
			//给敌人坦克添加一颗子弹
			Shot s=new Shot(et.x+10, et.y+30, 1);
			//把子弹加入给敌人
			et.ss.add(s);
			Thread t2=new Thread(s);
			t2.start();
			
			//加入敌人坦克
			ets.add(et);
		}
	}else if(flag.equals("congame")){
		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(2);
			//初始敌人坦克的方向
			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, 1);
			//把子弹加入给敌人
			et.ss.add(s);
			Thread t2=new Thread(s);
			t2.start();
			
			//加入敌人坦克
			ets.add(et);
		}
	}
	
	//初始化爆炸图片
	try {
		image1=ImageIO.read(new File("bomb1.gif"));
		image2=ImageIO.read(new File("bomb2.gif"));
		image3=ImageIO.read(new File("bomb3.gif"));
	} catch (Exception e) {
		e.printStackTrace();
	}
}

//画出提示信息
public void showInfo(Graphics g){
	//画出提示信息坦克(该坦克不参与战斗，只是用于显示提示信息)
	this.drawTank(80, 330, g, 1, 0);
	g.setColor(Color.BLACK);
	g.setFont(new Font("宋体",Font.BOLD,20));
	g.drawString(Recorder.getEnNum()+"", 110, 350);//显示敌人坦克数量
	
	this.drawTank(140, 330, g, 0, 0);
	g.setColor(Color.BLACK);
	g.setFont(new Font("宋体",Font.BOLD,20));
	g.drawString(Recorder.getMyLife()+"", 170, 350);//显示我的坦克数量

	//画出玩家的总成绩
	g.setColor(Color.black);
	g.setFont(new Font("宋体",Font.BOLD,20));
	g.drawString("您的总成绩", 420, 30);
	
	this.drawTank(420, 60, g, 1, 0);
	g.setColor(Color.black);
	g.setFont(new Font("宋体",Font.BOLD,20));
	g.drawString(Recorder.getAllEnNum()+"", 460, 80);
}

//重写paint函数
public void paint(Graphics g){
	super.paint(g);//调用父类paint方法
	
	//画出提示信息
	this.showInfo(g);
	
	//设置Panel底色
	g.setColor(Color.black);
	g.fillRect(0, 0, 400, 300);//fillRect(0,0,X?,Y?)中X?/Y?为活动区域
	
	//画出自己的坦克
	if(hero.isLive==true){
		this.drawTank(hero.getX(), hero.getY(), g, 0, this.hero.direct);
	}
	
	//从ss向量中取出每一颗子弹并画出
	for(int i=0;i<this.hero.ss.size();i++){
		Shot myShot=hero.ss.get(i);
		//画出一颗子弹，判断子弹是否为空
		if(myShot!=null&&myShot.isLive==true){
			g.draw3DRect(myShot.x, myShot.y, 1, 1, false);
		}
		//判断子弹是否死亡
		if(myShot.isLive==false){
			//从向量ss中删除该子弹
			hero.ss.remove(myShot);
		}
	}
	
	//画出炸弹
	for(int i=0;i<bombs.size();i++){
		//取出炸弹
		Bomb b=bombs.get(i);
		if(b.life>6){
			g.drawImage(image1, b.x, b.y, 30, 30, this);
		}else if(b.life>3){
			g.drawImage(image2, b.x, b.y, 30, 30, this);
		}else {
			g.drawImage(image3, b.x, b.y, 30, 30, this);
		}
		//让b的生命值减少
		b.lifeDown();
		//如果炸弹生命值为0，就把该炸弹从bombs向量中去掉
		if(b.life==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, 1, et.getDirect());
			//再画出敌人坦克的子弹
			for(int j=0;j<et.ss.size();j++){
				//取出子弹
				Shot enemyShot=et.ss.get(j);
				if(enemyShot.isLive){
					g.draw3DRect(enemyShot.x, enemyShot.y, 1, 1, false);
				}else{
					//如果敌人的坦克死亡了就从向量Vector中去掉
					et.ss.remove(enemyShot);
				}
			}
		}
	}
}

//判断我的子弹是否击中敌人的坦克
public void hitEnemyTank(){
	//遍历Vector集合类
	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)){
						apw=new AePlayWave("e:\\tankgame\\tank_explosion.wav");
						apw.start();
						//调用reduceEnNum()减少敌人坦克统计数
						Recorder.reduceEnNum();
						//调用addEnNumRec()增加消灭敌人坦克统计数
						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){
				if(this.hitTank(enemyShot, hero)){
					
				}
			}
		}
	}
}

//写一个函数专门判断子弹是否击中敌人坦克
public boolean hitTank(Shot s,Tank et){
	boolean b=false;
	//判断该敌人坦克的方向
	switch(et.direct){
	case 0://敌人坦克向上或向下
	case 1:
		if(s.x>et.x&&s.x<et.x+20&&s.y>et.y&&s.y<et.y+29){
			//击中方向为上或下的敌人坦克
			//子弹死亡
			s.isLive=false;
			//敌人坦克死亡
			et.isLive=false;
			b=true;
			//创建一颗炸弹
			Bomb bomb=new Bomb(et.x, et.y);
			//放入Vector向量中管理
			bombs.add(bomb);
		}
		break;
	case 2://敌人坦克向左或向右
	case 3:
		if(s.x>et.x&&s.x<et.x+29&&s.y>et.y&&s.y<et.y+20){
			//击中方向为左或右的敌人坦克
			//子弹死亡
			s.isLive=false;
			//敌人坦克死亡
			et.isLive=false;
			b=true;
			//创建一颗炸弹
			Bomb bomb=new Bomb(et.x, et.y);
			//放入Vector向量中管理
			bombs.add(bomb);
		}
		break;
	}
	return b;
}

//画出坦克的函数
public void drawTank(int x,int y,Graphics g,int type,int direct){
	//判断是什么类型的坦克
	switch(type){
	case 0:
		g.setColor(Color.cyan);//我的坦克颜色
		break;
	case 1:
		g.setColor(Color.yellow);//敌人坦克颜色
		break;
	case 2:
		g.setColor(Color.red);
		break;
	}
	
	//判断坦克的方向
	switch(direct){
	//向上走的坦克
	case 0:
		//画出我的坦克(到时再封装成一个函数)
		//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);
		break;
	//向下走的坦克
	case 1:
		g.fill3DRect(x, y, 5, 30, false);
		g.fill3DRect(x+15, y, 5, 30, false);
		g.fill3DRect(x+5, y+5, 10, 20, false);
		g.fillOval(x+5, y+10, 10, 10);
		g.drawLine(x+10, y+15, x+10, y+29);
		break;
	//向左走的坦克
	case 2:
		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);
		break;
	//向右走的坦克
	case 3:
		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+29, y+10);
		break;
	}
}

public void keyPressed(KeyEvent e) {//按下键事件a向左s向下d向右w向上
	if(e.getKeyCode()==KeyEvent.VK_W||e.getKeyCode()==KeyEvent.VK_UP){
		//向上
		this.hero.setDirect(0);
		this.hero.moveUp();
	}else if(e.getKeyCode()==KeyEvent.VK_S||e.getKeyCode()==KeyEvent.VK_DOWN){
		//设置我的坦克的方向,向下
		this.hero.setDirect(1);
		this.hero.moveDown();
	}else if(e.getKeyCode()==KeyEvent.VK_A||e.getKeyCode()==KeyEvent.VK_LEFT){
		//向左
		this.hero.setDirect(2);
		this.hero.moveLeft();
	}else if(e.getKeyCode()==KeyEvent.VK_D||e.getKeyCode()==KeyEvent.VK_RIGHT){
		//向右
		this.hero.setDirect(3);
		this.hero.moveRight();
	}
	
	//判断玩家是否按下空格键,不可接上面else if。不然不能同时按方向键和空格(space)键
	if(e.getKeyCode()==KeyEvent.VK_SPACE){
		apw=new AePlayWave("e:\\tankgame\\tank_Shelling_sound.wav");
		apw.start();
		//控制子弹连发
		if(this.hero.ss.size()<=4){
			//按下空格后开火
			this.hero.shotEnemy();
		}
	}
	
	//调用repaint()函数，来重绘界面
	this.repaint();
}

public void keyReleased(KeyEvent e) {//弹起键事件
	
}

public void keyTyped(KeyEvent e) {//按键输出值
	
}

//重写run函数
public void run() {
	while(true){
		try {
			Thread.sleep(100);//休息100毫秒后重绘MyPanel面板
		} catch (Exception e) {
			e.printStackTrace();
		}
		
		this.hitEnemyTank();
		//判断敌人的子弹是否击中我的坦克
		this.hitMe();

		//重绘MyPanel面板
		this.repaint();
	}
}

}


### 二、成员类

package com.haiding.tank_7;

import java.util.Vector; import java.io.; import javax.sound.sampled.;

//播放声音的类 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[2048];

	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 direct){ 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 Vector nodes=new Vector();

private static FileWriter fw=null;
private static BufferedWriter bw=null;
private static FileReader fr=null;
private static BufferedReader br=null;
private static Vector<EnemyTank> ets=new Vector<EnemyTank>();

//完成读取任务点任务
public static Vector<Node> getNodesAndEnNums(){
	try {
		fr=new FileReader("e:\\tankgame\\tanksave.txt");
		br=new BufferedReader(fr);
		String n="";
		//先读一行
		n=br.readLine();
		allEnNum=Integer.parseInt(n);		
		while((n=br.readLine())!=null){
			String []Recovery=n.split(" ");//split方法可以按一行字符中有多少个空间来返回数组
			Node node=new Node(Integer.parseInt(Recovery[0]),Integer.parseInt(Recovery[1]),Integer.parseInt(Recovery[2]));
			nodes.add(node);
		}
	} catch (Exception e) {
		e.printStackTrace();
	}finally{
		try {
			br.close();
			fr.close();
		} catch (Exception e2) {
			e2.printStackTrace();
		}
	}
	return nodes;
}

//保存击毁敌人的数量和敌人坦克坐标、方向
public static void keepRecAndEnemyTank(){
	try {
		//创建
		fw=new FileWriter("e:\\tankgame\\tanksave.txt");
		bw=new BufferedWriter(fw);
		bw.write(allEnNum+"\r\n");
		
		//保存当前还活着的敌人坦克坐标、方向
		for(int i=0;i<ets.size();i++){
			//取出第一个坦克
			EnemyTank et=ets.get(i);
			if(et.isLive){
				//活的保存
				String recode=et.x+" "+et.y+" "+et.direct;//得到坐标x,y和方向direct
				//写入到文件
				bw.write(recode+"\r\n");
			}
		}
	} catch (Exception e) {
		e.printStackTrace();
	}finally{
		//关闭流,先开后关，后开先关
		try {
			bw.close();
			fw.close();
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
}

//从文件中读取记录
public static void getRecoring(){
	try {
		fr=new FileReader("e:\\tankgame\\tanksave.txt");
		br=new BufferedReader(fr);
		String n=br.readLine();
		allEnNum=Integer.parseInt(n);
	} catch (Exception e) {
		e.printStackTrace();
	}finally{
		try {
			br.close();
			fr.close();
		} catch (Exception e2) {
			e2.printStackTrace();
		}
	}
}
//把玩家击毁敌人坦克数量保存到文件中
public static void keepRecording(){
	try {
		//创建
		fw=new FileWriter("e:\\tankgame\\tanksave.txt");
		bw=new BufferedWriter(fw);
		bw.write(allEnNum+"\r\n");
	} catch (Exception e) {
		e.printStackTrace();
	}finally{
		//关闭流,先开后关，后开先关
		try {
			bw.close();
			fw.close();
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
}


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 Vector<EnemyTank> getEts() {
	return ets;
}

public static void setEts(Vector<EnemyTank> ets) {
	Recorder.ets = ets;
}

//敌人坦克死亡就减少坦克数
public static void reduceEnNum(){
	enNum--;
}
//当消灭敌人的时候
public static void addEnNumRec(){
	allEnNum++;
}

}

//炸弹类 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,speed=3;//初始子弹x,y坐标,direct子弹方向,speed子弹速度

//子弹是否还活着
boolean isLive=true;//默认为活着

public Shot(int x,int y,int direct){
	this.x=x;
	this.y=y;
	this.direct=direct;
}

public void run(){
	while(true){
		try {
			Thread.sleep(50);//让子弹休息50毫秒，防止快速消费内存
		} catch (Exception e) {
			e.printStackTrace();
		}
		
		switch(direct){
			case 0://向上
				y-=speed;
				break;
			case 1://向下
				y+=speed;
				break;
			case 2://向 左
				x-=speed;
				break;
			case 3://向右
				x+=speed;
				break;
		}
		//子弹何时死亡
		//判断该子弹是否碰到MyPanel面板的边缘
		if(x<0||x>400||y<0||y>300){
			this.isLive=false;
			break;
		}
	}
}

}

//定义坦克类 class Tank{ //表示坦克的X横坐标Y纵坐标 int x=0,y=0; //direct坦克方向,0向上、1向下、2向左、3向右 int direct=0; //坦克的速度 int speed=1; //坦克颜色 int color;

boolean isLive=true;

public Tank(int x,int y){
	this.x=x;
	this.y=y;
}
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 int getDirect() {
	return direct;
}
public void setDirect(int direct) {
	this.direct = direct;
}
public int getSpeed() {
	return speed;
}
public void setSpeed(int speed) {
	this.speed = speed;
}
public int getColor() {
	return color;
}
public void setColor(int color) {
	this.color = color;
}

}

//敌人坦克,把敌人坦克做成线程类 class EnemyTank extends Tank implements Runnable{ int move=30;//敌人坦克移动步长(区域) 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> tank){
	this.ets=tank;
}

//判断敌人坦克是否重叠
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==0||et.direct==1){
					//判断敌人当前坦克左轮与同伴坦克(向上或向下)的位置比较
					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==2||et.direct==3){
					//判断敌人当前坦克右轮与同伴坦克(向左或向右)的位置比较
					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;
	case 1://敌人当前坦克向下
		for(int i=0;i<ets.size();i++){
			EnemyTank et=ets.get(i);
			if(et!=this){
				if(et.direct==0||et.direct==1){
					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==2||et.direct==3){
					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 2://敌人当前坦克向左
		for(int i=0;i<ets.size();i++){
			EnemyTank et=ets.get(i);
			if(et!=this){
				if(et.direct==0||et.direct==1){
					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==2||et.direct==3){
					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 3://敌人当前坦克向右
		for(int i=0;i<ets.size();i++){
			EnemyTank et=ets.get(i);
			if(et!=this){
				if(et.direct==0||et.direct==1){
					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==2||et.direct==3){
					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;
	}
	return b;
}

//重写run()函数
public void run() {
	while(true){
		switch(this.direct){
		case 0://坦克正在向上移动
			for(int i=0;i<move;i++){
				if(y>0&&!this.isTouchOtherEnemy()){//判断敌人坦克向上走不会越界
					y-=speed;
				}
				try {
					Thread.sleep(50);
				} catch (Exception e) {
					e.printStackTrace();
				}
			}

css

1，盒模型 2，如何实现一个最大的正方形 3，一行水平居中，多行居左 4，水平垂直居中 5，两栏布局，左边固定，右边自适应，左右不重叠 6，如何实现左右等高布局 7，画三角形 8，link @import导入css 9，BFC理解

js

1，判断 js 类型的方式 2，ES5 和 ES6 分别几种方式声明变量 3，闭包的概念？优缺点？ 4，浅拷贝和深拷贝 5，数组去重的方法 6，DOM 事件有哪些阶段？谈谈对事件代理的理解 7，js 执行机制、事件循环 8，介绍下 promise.all 9，async 和 await, 10，ES6 的 class 和构造函数的区别 11，transform、translate、transition 分别是什么属性？CSS 中常用的实现动画方式, 12，介绍一下rAF(requestAnimationFrame) 13，javascript 的垃圾回收机制讲一下, 14，对前端性能优化有什么了解？一般都通过那几个方面去优化的？

开源分享：【大厂前端面试题解析+核心总结学习笔记+真实项目实战+最新讲解视频】

avatar
文章
阅读
粉丝