java制作简单飞翔的鸟

创建三个包，存放代码。把图片放进文件中

APP包（运行）
GameApp类
package APP;
import mian.GameFrame;
 
public class GameApp {
	public static void main(String[] args) {
		new GameFrame();
		
	}
}
mian包（主内容）
Barrier 类（障碍物）

package mian;
 
import java.awt.Color;
import java.awt.Graphics;
import java.awt.Rectangle;
import java.awt.image.BufferedImage;
 
import util.Constant;
import util.GameUtil;
 
/*
 * 障碍物类
 */
public class Barrier {
    
    
    
    
    private Rectangle rect;//小鸟矩形对象
    
    //
    private boolean mob=true;
    
    private int speed=3;//障碍物移动速度
    
    private static BufferedImage[] imgs;//障碍物需要的三个图片
    
    
    //障碍物的状态
    private boolean visible;
    
    static {
        final int COUNT=3;
        //类加载的时候将三个图片化
        imgs=new BufferedImage[COUNT];
        for(int i=0;i<COUNT;i++) {
            imgs[i]=GameUtil.loadBufferedImage(Constant.BARRIER_IMG_PATH[i]);
        }
    }
    
    private int x,y;//位置
    private int width,height;//宽度和高度
    private int type;//障碍物的类型
    public static final int TYPE_TOP_NORMAL=0;
    public static final int TYPE_BOTTOM_NORMAL=2;
    public static final int TYPE_HOVER_NORMAL=4;
    public static final int TYPE_MOBLIE=6;
    
    //获得障碍物的宽带和高度
    public static final int BARRIRE_WIDTH=imgs[0].getWidth();
    public static final int BARRIRE_HEIGHT=imgs[0].getHeight();
    public static final int BARRIRE_HEAD_WIDTH=imgs[1].getWidth();
    public static final int BARRIRE_HEAD_HEIGHT=imgs[1].getHeight();
    
    public Barrier() {
        
        rect=new Rectangle();
    }
    
    public Barrier(int x,int y,int height,int type) {
        this.x=x;
        this.y=y;
        this.height=height;
        this.type=type;
        this.width=BARRIRE_WIDTH;
    }
    
    //根据不同的类型绘制不同的障碍物
    public void draw(Graphics g) {
        switch(type) {
        case TYPE_TOP_NORMAL:
            drawTopMormal(g);
            break;
        case TYPE_BOTTOM_NORMAL:
            drawMormalTop(g);
            break;
        case TYPE_HOVER_NORMAL:
            drawHoverNormal(g);
            break;
        case TYPE_MOBLIE:
            drawMobile(g);
           break;
    }
    }
        
    //绘制从上向下的障碍物
    private void drawTopMormal(Graphics g) {
    //求出所需要的障碍物的块数
        int count=(height-BARRIRE_HEAD_HEIGHT)/BARRIRE_HEIGHT+1;
    //for循环绘制障碍物
        for(int i=0;i<count;i++) {
            g.drawImage(imgs[0],x,y+i*BARRIRE_HEIGHT, null);
        }
        
    //绘制头
        int y=height-BARRIRE_HEAD_HEIGHT;
        g.drawImage(imgs[2],x-(BARRIRE_HEAD_WIDTH-BARRIRE_WIDTH)/2,y, null);
        x-=speed;
        if(x<-50) {
            visible=false;
        }
         rect(g);
    }
    
    
    //绘制从下到上的障碍物
    private void drawMormalTop(Graphics g) {
    //求出所需要的障碍物的块数
        int count=height/BARRIRE_HEIGHT+1;
    //for循环绘制障碍物
        for(int i=0;i<count;i++) {
            g.drawImage(imgs[0],x,Constant.FRAM_HEIGHT-i*BARRIRE_HEIGHT, null);
            
        }    
        
    //绘制头
     int y=Constant.FRAM_HEIGHT-height;
     g.drawImage(imgs[1],x-(BARRIRE_HEAD_WIDTH-BARRIRE_WIDTH)/2,y, null);
     x-=speed;
     if(x<-50) {
            visible=false;
        }
     rect(g);
    }    
    
    
    //绘制中间的障碍物
    private void drawHoverNormal(Graphics g) {
    //求出所需要的障碍物的块数
        int count=(height-BARRIRE_HEAD_HEIGHT)/BARRIRE_HEIGHT;
    //绘制上头
        g.drawImage(imgs[1],x,y,null);
    //for循环绘制障碍物
        for(int i=0;i<count;i++) {
            g.drawImage(imgs[0],x,y+BARRIRE_HEAD_HEIGHT+i*BARRIRE_HEIGHT, null);
            
        }    
         rect(g);
        
    //绘制下头
     int y11=y+height-BARRIRE_HEAD_HEIGHT;
     g.drawImage(imgs[2],x,y11, null);
     x-=speed;
     if(x<-50) {
            visible=false;
        }
    
    }    
    
    
    //绘制中间移动的障碍物
    private void drawMobile(Graphics g) {
    //求出所需要的障碍物的块数
        int count=(height-BARRIRE_HEAD_HEIGHT)/BARRIRE_HEIGHT;
    //绘制上头
        g.drawImage(imgs[1],x,y,null);
    //for循环绘制障碍物
        for(int i=0;i<count;i++) {
            g.drawImage(imgs[0],x,y+BARRIRE_HEAD_HEIGHT+i*BARRIRE_HEIGHT, null);
            
        }    
         rect(g);
        
    //绘制下头
     int y11=y+height-BARRIRE_HEAD_HEIGHT;
     g.drawImage(imgs[2],x,y11, null);
     x-=speed;
     if(x<-50) {
            visible=false;
        }
     
     if(mob) {
         y+=5;
         if(y>=250) {
             mob=false;
         }
     }else if(!mob) {
         y-=5;
         if(y<=100) {
             mob=true;
         }
     }
    
    }    
    
    
    /*
     * 绘制障碍物矩形
     */
    public void rect(Graphics g) {
        int x1=this.x;
        int y1=this.y;
        int w1=imgs[0].getWidth();
//        g.drawRect(x1, y1, w1,height);
        setRectyangle(x1,y1,w1,height);
        
    }
    
    /*
     * 障碍物矩形参数
     */
    public void setRectyangle(int x,int y,int width,int height) {
        rect.x=x;
        rect.y=y;
        rect.width=width;
        rect.height=height;
    }
    
    
    
    //判断什么时候绘制下一组障碍物
    public boolean isInFrame() {
        return 600-x>150;
    }
 
    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 getHeight() {
        return height;
    }
 
    public void setHeight(int height) {
        this.height = height;
    }
 
    public int getType() {
        return type;
    }
 
    public void setType(int type) {
        this.type = type;
    }
 
    public boolean isVisible() {
        return visible;
    }
 
    public void setVisible(boolean visible) {
        this.visible = visible;
    }
        
    public Rectangle getRect() {
        return rect;
    }
        
    }

Barrierpool类（管理池中所有的对象的容器）
package mian;
import java.util.ArrayList;
import java.util.List;
 
/*
 * 为了避免反复的创建和销毁对象，使用对象池来提前创建好一些对象
 * 使用的时候从池中获得，使用完毕后，归还
 */
public class Barrierpool {
	//用于管理池中所有的对象的容器
	private static List<Barrier>pool=new ArrayList<>();
	//池中初始的对象个数
	public static final int initCount=16;
	//对象池中最大个数
	public static final int maxCount=20;
	
	static {
		//初始化池中的对象
		for(int i=0;i<initCount;i++) {
			pool.add(new Barrier());
		}
	}
	
	
	
	/*
	 * 从池中获取一个对象
	 */
	public static Barrier getPool() {
		int size=pool.size();
		//如果池中有对象才可以拿
		if(size>0) {
			//移除并返回对象
			System.out.println("拿走一个");
			return pool.remove(size-1);
			
		}else {
			//如果池中没有对象，只能new
			System.out.println("新的对象");
			return new Barrier();
		}
	}
	
	/*
	 * 将对象归还容器中
	 */
	public static void setPool(Barrier barrier) {
		if(pool.size()<maxCount) {
			pool.add(barrier);
			System.out.println("容器归还了");
		}
	}
	
	
	
}
Bird（鸟）
package mian;
import java.awt.Graphics;
import java.awt.Rectangle;
import java.awt.image.BufferedImage;
import static util.Constant.*;
import util.GameUtil;
 
/*
 * 小鸟类
 */
public class Bird {
	
	//小鸟矩形对象
	private Rectangle rect;
	
	//小鸟加速度
	private int acceleration;
	
	
	//小鸟的生命值
	public boolean life=true;
	
	
	//存放小鸟图片
	private BufferedImage[] images;
	public static final int BIRD_IMG_COUNT=3;
	
	//鸟的状态
	private int state;
	public static final int STATE_NORMAR=0;//平着飞
	public static final int STATE_UP=1;//向上飞
	public static final int STATE_DOWN=2;//向下飞
	
	//小鸟的位置
	private int x=200,y=200;
	
	//小鸟的移动方向 上下
	private boolean up=false,down=false;
	
	//小鸟的移动速度
	private int speed=4;
	
	//构造方法中对资源初始化
	public Bird() {
	images=new BufferedImage[BIRD_IMG_COUNT];
	for(int i=0;i<BIRD_IMG_COUNT;i++) {
		images[i]=GameUtil.loadBufferedImage(BIRD_IMG[i]);
	}
	
	int w=images[0].getWidth();
	int h=images[0].getHeight();
	rect=new Rectangle(w,h);
	
	}
	
	//绘制小鸟
	public void draw(Graphics g) {
		flyLogic();
		
		g.drawImage(images[state],x,y, null);
		
		
		//绘制小鸟的矩形
//		g.drawRect(x, y,(int)rect.getWidth(),rect.height);
		rect.x=this.x;
		rect.y=this.y;
	}
	
	
	//控制小鸟移动方向
	public void flyLogic() {
		if(up) {
			acceleration--;
			y+=acceleration;
			if(acceleration<-10) {
				acceleration=-10;
			}
			if(y<20) {
				y=20;
				acceleration=0;
			}
		}
		if(!up) {
			acceleration++;
			y+=acceleration;
			if(acceleration>10) {
				acceleration=10;
			}
			if(y>475) {
				y=475;
				acceleration=0;
			}
		}
	}
	
 
	
	
	public void fly(int fly) {
		switch(fly) {
		case 1:
			state=1;
			up=true;
			break;
		case 5:
			state=2;
			up=false;
			break;
		}
	}
	
	public Rectangle getRect() {
		return rect;
	}
	
	/*
	 * 重新绘制小鸟的位置
	 */
	public void restartDraw() {
		life=true;
		x=200;
		y=200;
		
	}
 
}
Cloud（云彩）
package mian;
import java.awt.Graphics;
import java.awt.image.BufferedImage;
 
/*
 * 云彩类
 */
public class Cloud {
	private BufferedImage img;//云彩图片
	private int speed;//云彩速度
	private int x,y;//云彩位置
	
	public Cloud() {}
	
	public Cloud(BufferedImage img,int speed,int x,int y) {
		this.img=img;
		this.speed=speed;
		this.x=x;
		this.y=y;
	}
	
	public void draw(Graphics g) {
		x-=speed;
		g.drawImage(img, x, y, null);
	}
	
	/*用于判断云彩是否废除屏幕以外
	 * 
	 */
	public boolean isOutFrame() {
		if(x<-100) {
			return true;
		}
		return false;
	}
	
	
}
GameBackground（游戏背景）
package mian;
import java.awt.Color;
import java.awt.Graphics;
import java.awt.image.BufferedImage;
 
import util.Constant;
import util.GameUtil;
 
/*
 * 游戏背景类
 */
public class GameBackground {
	
	private BufferedImage bkimg;//背景需要的资源图片
	
	//构造器初始化资源
	public GameBackground() {
		 bkimg=GameUtil.loadBufferedImage(Constant.BK_CATH_OATH);
	}
 
	//绘制图片
	public  void draw(Graphics g) {
		
		//填充背景颜色
		g.setColor(Constant.BK_COLOR);
		g.fillRect(0, 0, Constant.FRAM_WIDTH,Constant.FRAM_HEIGHT);
		g.setColor(Color.black);
		
		//得到图片的高宽和宽高
		int height=bkimg.getHeight();
		int width=bkimg.getWidth();
		//循环的次数
		int count=Constant.FRAM_WIDTH/width+1;
		for(int i=0;i<count;i++) {
			g.drawImage(bkimg,width*i,Constant.FRAM_HEIGHT-height, null);
		}
	}
}
GameBarrierLayer（游戏中障碍物层） 
package mian;
 
 
 
import java.awt.Color;
import java.awt.Font;
import java.awt.Graphics;
import java.io.BufferedReader;
import java.io.File;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
import java.util.Random;
 
/*
 * 游戏中障碍物层
 */
public class GameBarrierLayer {
	
	private GameTime gameTime;
	
	private int txt;
 
	private Random random=new Random();
	
	private List<Barrier>barriers;
	
	public GameBarrierLayer() {
		barriers=new ArrayList<>();
		gameTime=new GameTime();
	}
	
	//绘制障碍物
	public void draw(Graphics g,Bird bird) throws NumberFormatException, IOException {
		for(int i=0;i<barriers.size();i++) {
			Barrier barrier=barriers.get(i);
			if(barrier.isVisible()) {
				barrier.draw(g);
			
		}else {
			Barrier remove=barriers.remove(i);
			Barrierpool.setPool(remove);
			i--;
		}
		}
		collideBird(bird);
			logic(g);
	}
	
	public void logic(Graphics g) throws NumberFormatException, IOException {
		if(barriers.size()==0) {
			ran();
			
			gameTime.begin();
			insert(600,0,numberTop,0);
			insert(600,500-numberDown,numberDown,2);
			
		}else {
			long differ=gameTime.differ();
			g.setColor(Color.white);
			g.setFont(new Font("微软雅黑",1,20));
			g.drawString("坚持了："+differ+"秒",30,50);
			
			txt=getTxt();
			if(differ<=txt) {
				g.drawString("最高成绩："+txt,200,50);
			}else {
				setTxt(String.valueOf(differ));
				g.drawString("最高成绩："+getTxt(),200,50);
			}
			
			//判断最后一个障碍物是否完全进入屏幕内
			Barrier last=barriers.get(barriers.size()-1);
			if(last.isInFrame()) {
				ran();
				if(number<50) {
					insert(600,32,440,4);
				}else if(number>450){
					insert(600,125,200,6);
				}else {
					insert(600,0,numberTop,0);
					insert(600,500-numberDown,numberDown,2);
				}
				
			}
		}
	}
	
	File file=new File("D:\\飞翔的小鸟.txt");
	
	
	/*
	 * 用于得到文件中的数据
	 */
	public int getTxt() throws NumberFormatException, IOException {
		 BufferedReader in=new BufferedReader(new FileReader(file));
		 int read=Integer.parseInt(in.readLine());
		 in.close();
		 return read;
	}
	
	
	/*
	 * 用于储存数据
	 */
	public void setTxt(String str) throws IOException {
		FileWriter fileWriter=new FileWriter(file);
		fileWriter.write(str);
		fileWriter.close();
	}
	
	
	/*
	 * 用来从池中获取对象，并把参数封装成barrier 存放barriers数组中
	 */
	public void insert(int x,int y,int num,int type) {
		Barrier top=Barrierpool.getPool();
		top.setX(x);
		top.setY(y);
		top.setHeight(num);
		top.setType(type);
		top.setVisible(true);
		barriers.add(top);
	}
	
	
	
	
	
	
	private int numberTop;//上方的随即高度
	private int numberDown;//下方的随即高度
	private int number;
	
	//产生两个100-500之间的随机高度
	public void ran() {
		numberTop=random.nextInt(400)+100;
		numberDown=random.nextInt(400)+100;
		number=random.nextInt(500);
		
		//如果管道重合，则重新随机
		if(numberTop+numberDown>450) {
			ran();
		}
	}
	
	/*
	 * 判断障碍物和小鸟碰撞
	 */
	public boolean collideBird(Bird bird) {
		for(int i=0;i<barriers.size();i++) {
			Barrier barrier=barriers.get(i);
			//判断是否相交
			if(barrier.getRect().intersects(bird.getRect())) {
				System.out.println("撞上啦");
				bird.life=false;
			}
		}
		return false;
	}
	
	
	/*
	 * 用于清空障碍物的池子
	 */
	public void restant() {
		barriers.clear();
	}
	
	
}
GameFrame 
package mian;
import java.awt.Color;
import java.awt.Font;
import java.awt.Frame;
import java.awt.Graphics;
import java.awt.event.KeyAdapter;
import java.awt.event.KeyEvent;
import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;
import java.awt.image.BufferedImage;
import java.io.IOException;
 
import static util.Constant.*;
import util.Constant;
 
public class GameFrame extends Frame{
 
	//实例化GrameBackground类
	private GameBackground gameBackground;
	
	//实例化Bird类
	private Bird bird;
	
	//实例化GameBarrierLayer
	private GameBarrierLayer gameBarrierLayer;
	
	//实例化GameFrontground类
	private GameFrontground gameFrontground;
	
	//存放图片的图片
	private BufferedImage buffimg=new BufferedImage(FRAM_WIDTH,FRAM_HEIGHT,BufferedImage.TYPE_4BYTE_ABGR);
 
	//构造方法中初始化一些参数
	public GameFrame() {
		setVisible(true);//窗口是否可见
		setSize(FRAM_WIDTH,FRAM_HEIGHT);//窗体的大小
		setTitle(FRAM_Ttile);//窗体的标题
		setLocation(FRAM_x,FRAM_y);//窗体的初始位置
		setResizable(false);//窗体的大小不可改变
		
		//窗口的关闭事件
		addWindowListener(new WindowAdapter() {
			public void windowClosing(WindowEvent e) {
				System.exit(0);//结束程序
			}
		});
		
		//初始化游戏对象
		initGame();
		
		new run().start();
		
		//添加案件监听器
		addKeyListener(new KeyAdapter (){
			
			public void keyPressed(KeyEvent e) {
				//super.keyPressed(e);
				add(e);
			}
			
			public void keyReleased(KeyEvent e) {
				//super.keyReleased(e);
				minu(e);
			}
			
		});
		
		
	}
	
	//对游戏中的对象初始化
	public void initGame() {
		gameBackground=new GameBackground();
		bird=new Bird();
		gameFrontground=new GameFrontground();
		gameBarrierLayer=new GameBarrierLayer();
		
	}
	
	
	class run extends Thread{
		public void run() {
			while(true) {
			repaint();
			try {
				Thread.sleep(33);	
			}catch(InterruptedException e) {
				e.printStackTrace();
			}
			}
		}
	}
	
	
	
	/*
	 * 所有的我们需要绘制的内容都在此方法中进行调用绘制
	 */
	@Override
	public void update(Graphics g) {
		if(bird.life) {
			//得到图片的画笔
			Graphics graphics=buffimg.getGraphics();
			
			gameBackground.draw(graphics);
			bird.draw(graphics);
			gameFrontground.draw(graphics);
			try {
				gameBarrierLayer.draw(graphics,bird);
			} catch (NumberFormatException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			} catch (IOException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
			
			//一次性的将图片绘制到屏幕中
			g.drawImage(buffimg,0,0,null);
		}else {
			String over="游戏结束";
			g.setColor(Color.red);
			g.setFont(new Font("微软雅黑",1,60));
			g.drawString(over,300,250);
			
			String reset="Spce Reset Game";
			g.drawString(reset,25,350);
		}
		
		
		
		
		
	}
	
	
	
	
	//按键
	public void add(KeyEvent e) {
		switch(e.getKeyCode()) {
		case KeyEvent.VK_UP:
			bird.fly(1);
			break;
		case KeyEvent.VK_SPACE:
			if(bird.life==false) {
				restart();
			}
			break;
		}
	}
	
	
 
	//抬键
	public void minu(KeyEvent e) {
		switch(e.getKeyCode()) {
		case KeyEvent.VK_UP:
			bird.fly(5);
			break;
		}
	}
	
	
	/*
	 * 
	 * 重置游戏
	 */
	public void restart() {
		gameBarrierLayer.restant();
		bird.restartDraw();
		
	}
	
	
}
GameTime(计时）
package mian;
/*
 * 计时类
 */
public class GameTime {
 
	private long begingTime;//开始
	private long endTime;//结束
	private long differ;//时间差
	
	public GameTime() {
		
	}
	
	public void begin() {
		begingTime=System.currentTimeMillis();
		}
	public long differ() {
		endTime=System.currentTimeMillis();
		return differ=(endTime-begingTime)/1000;
	}
}
util(窗体）
Constant 
package util;
 
 
 
import java.awt.image.BufferedImage;
import java.io.FileInputStream;
import java.io.IOException;
 
import javax.imageio.ImageIO;
 
public class GameUtil {
	public static BufferedImage loadBufferedImage(String imgpath) {
		try {
			return ImageIO.read(new FileInputStream(imgpath));
		}catch(IOException e){
			e.printStackTrace();
		}
		return null;
	}
 
}

运行结果：

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：/a/183500.html

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

如何开发洗鞋店用的小程序

如何开发洗鞋店用的小程序

随着人们生活水平的提高&#xff0c;洗护行业是越来越细分化了&#xff0c;从最开始的干洗店包含洗护行业的所有服务到现在有专门为洗鞋开的店&#xff0c;如果开发一款洗鞋店用的小程序&#xff0c;可以实现用户在家下单直接有人上门取鞋的话&#xff0c;应该如何去开发呢&…
阅读更多...
高质量短效SOCKS5代理IP是什么意思？作为技术你了解吗

高质量短效SOCKS5代理IP是什么意思？作为技术你了解吗

小张是一位网络安全技术测试员&#xff0c;最近他接到了一个头疼的任务&#xff0c;那就是评估公司系统的安全性&#xff0c;因此他前来咨询&#xff0c;在得知SOCKS5代理IP可以帮他之后&#xff0c;他不禁产生疑问&#xff0c;这是什么原理&#xff1f;其实和小张一样的朋友不…
阅读更多...
Lua脚本解决redis实现的分布式锁多条命令原子性问题

Lua脚本解决redis实现的分布式锁多条命令原子性问题

线程1现在持有锁之后&#xff0c;在执行业务逻辑过程中&#xff0c;他正准备删除锁&#xff0c;而且已经走到了条件判断的过程中&#xff0c;比如他已经拿到了当前这把锁确实是属于他自己的&#xff0c;正准备删除锁&#xff0c;但是此时他的锁到期了&#xff0c;那么此时线程2…
阅读更多...
Flutter 小技巧之 3.16 升级最坑 M3 默认适配技巧

Flutter 小技巧之 3.16 升级最坑 M3 默认适配技巧

如果要说 Flutter 3.16 升级里是最坑的是什么&#xff1f;那我肯定要说是 Material 3 default &#xff08;M3&#xff09;。 倒不是说 M3 bug 多&#xff0c;也不是 M3 在 3.16 上使用起来多麻烦&#xff0c;因为虽然从 3.16 开始&#xff0c;MaterialApp 里的 useMaterial3 …
阅读更多...
Shell循环：for（一）

Shell循环：for（一）

语法结构&#xff1a; for 变量名 [ in 取值列表] do 循环体 done 示例1&#xff1a; 1、需求&#xff1a;自动循环创建10个用户 2、演示&#xff1a; [rootlocalhost ~]# vim for.sh #脚本编写 #!/bin/bash for i in {1..10} do useradd "user$…
阅读更多...
探究Kafka原理-2.Kafka基本命令实操

探究Kafka原理-2.Kafka基本命令实操

&#x1f44f;作者简介&#xff1a;大家好&#xff0c;我是爱吃芝士的土豆倪&#xff0c;24届校招生Java选手&#xff0c;很高兴认识大家&#x1f4d5;系列专栏&#xff1a;Spring源码、JUC源码、Kafka原理&#x1f525;如果感觉博主的文章还不错的话&#xff0c;请&#x1f44…
阅读更多...
csv文件添加文件内容和读取

csv文件添加文件内容和读取

append content to file import numpy as np acc_listnp.array([0.97,0.92,0.93,0.89]) # 注意这个地方添加文件不需要特别声明是什么文件 file open("result.csv", "a") print("{:.2f}, {:.2f}".format(acc_list.mean(), acc_list.std()), f…
阅读更多...
服务器安全如何保障

服务器安全如何保障

主机安全是指保护计算机主机&#xff08;也称为服务器、终端或主机设备&#xff09;免受潜在的安全威胁和攻击的一系列措施和实践。主机安全旨在防止未经授权的访问、数据泄露、恶意软件感染和其他安全漏洞的利用&#xff0c;主机一旦被黑客入侵&#xff0c;企业会面临很多安全…
阅读更多...
buck降压电路

buck降压电路

一、Buck电路的拓扑结构 Buck是直流转直流的降压电路，下面是拓扑结构，作为硬件工程师，这个最好是能够记下来，了然于胸。 为啥要记下来，自然是因为这个电路太基础了，并且谁都会用到，更重要的一点，面试可能会考。。。 上图是个异步buck，同步buck就是将里面的二极管换成M…
阅读更多...
手持式无线通信频谱分析仪 MS2713E

手持式无线通信频谱分析仪 MS2713E

MS2713E 手持式无线通信频谱分析仪 安立手持式无线通信频谱分析仪 MS2713E 旨在处理最恶劣的现场条件&#xff0c;使您能够监控、定位、识别和分析各种蜂窝、2G/3G/4G、陆地移动无线电、Wi-Fi 和广播信号。多功能 Spectrum Master 在定位和识别宽频率范围内的信号时&#xff0…
阅读更多...
Java设计模式系列：单例设计模式

Java设计模式系列：单例设计模式

Java设计模式系列&#xff1a;单例设计模式 介绍 所谓类的单例设计模式&#xff0c;就是采取一定的方法保证在整个的软件系统中&#xff0c;对某个类只能存在一个对象实例&#xff0c;并且该类只提供一个取得其对象实例的方法&#xff08;静态方法&#xff09; 比如 Hiberna…
阅读更多...
【云原生 Prometheus篇】Prometheus的动态服务发现机制与认证配置

【云原生 Prometheus篇】Prometheus的动态服务发现机制与认证配置

目录 一、Prometheus服务发现的方式1.1 基于文件的服务发现1.2 基于consul的服务发现1.3 基于 Kubernetes API 的服务发现1.3.1 简介1.3.2 基于Kurbernetes发现机制的部分配置参数 二、实例一&#xff1a;部署基于文件的服务发现2.1 创建用于服务发现的文件2.2 修改Prometheus的…
阅读更多...
中国毫米波雷达产业分析2——毫米波雷达产业链分析

中国毫米波雷达产业分析2——毫米波雷达产业链分析

一、产业链构成 毫米波雷达产业链分为三部分&#xff1a;上游主要包括射频前端组件&#xff08;MMIC&#xff09;、数字信号处理器&#xff08;DSP/FPGA&#xff09;、高频PCB板、微控制器&#xff08;MCU&#xff09;、天线及控制电路等硬件供应商&#xff1b;中游主体是毫米波…
阅读更多...
多线程 02

多线程 02

1.线程的常见构造方法 方法说明Thread()创建线程对象Thread(Runnable target)使用 Runnable 对象创建线程对象Thread(String name)创建线程对象&#xff0c;并命名Thread(Runnable target, String name)使用 Runnable 对象创建线程对象&#xff0c;并命名【了解】Thread(Threa…
阅读更多...
【Flink】状态管理

【Flink】状态管理

目录 1、状态概述 1.1 无状态算子 1.2 有状态算子 2、状态分类 ​编辑 2.1 算子状态 2.1.1 列表状态&#xff08;ListState&#xff09; 2.1.2 联合列表状态&#xff08;UnionListState&#xff09; 2.1.3 广播状态&#xff08;BroadcastState&#xff09; 2.2 按键分…
阅读更多...
YOLO目标检测——泄露检测数据集下载分享【含对应voc、coco和yolo三种格式标签】

YOLO目标检测——泄露检测数据集下载分享【含对应voc、coco和yolo三种格式标签】

实际项目应用&#xff1a;泄露检测数据集说明&#xff1a;泄露检测数据集&#xff0c;真实场景的高质量图片数据&#xff0c;数据场景丰富&#xff0c;含多个类别标签说明&#xff1a;使用lableimg标注软件标注&#xff0c;标注框质量高&#xff0c;含voc(xml)、coco(json)和yo…
阅读更多...
Python爬虫-获取汽车之家新车优惠价

Python爬虫-获取汽车之家新车优惠价

前言 本文是该专栏的第10篇，后面会持续分享python爬虫案例干货，记得关注。 本文以汽车之家新车优惠价为例，获取各车型的优惠价，示例图如下： 地址：aHR0cHM6Ly9idXkuYXV0b2hvbWUuY29tLmNuLzAvMC8wLzQyMDAwMC80MjAxMDAvMC0wLTAtMS5odG1sI3B2YXJlYWlkPTIxMTMxOTU= 需求：获…
阅读更多...
电感热点温度概述及估算方法总结

电感热点温度概述及估算方法总结

🏡《电子元器件学习目录》 目录 1，什么是电感的热点温度2，热点温度参数意义3，热点温度计算方法3.1，测温估算法3.2，电阻变化估算法4，总结1，什么是电感的热点温度 电感的热点指电感的发热点，一般是电感的绕阻。电感的热点温度为电感绕阻的温度。 2，热点温度参数意义 电…
阅读更多...
JDK11新特性

JDK11新特性

目录 一、JShell 二、Dynamic Class-File Constants类文件新添的一种结构 三、局部变量类型推断&#xff08;var ”关键字”&#xff09; 四、新加的一些实用API 1. 新的本机不可修改集合API 2. Stream 加强 3. String 加强 4. Optional 加强 5. 改进的文件API 五、移…
阅读更多...
从0开始学习JavaScript--JavaScript模块化编程

从0开始学习JavaScript--JavaScript模块化编程

JavaScript模块化编程是现代前端开发中的核心概念之一。通过模块化&#xff0c;能够将复杂的代码分割成独立的模块&#xff0c;提高代码的可维护性、可扩展性&#xff0c;同时实现代码的复用。本文将深入探讨JavaScript模块化的各个方面&#xff0c;包括模块的定义、导入导出、…
阅读更多...
最新文章

Copyright @ 2022~2023