Java学习基础_小程序

简易游戏项目实战
原创 于 2010-01-23 15:24:22 发布 · 157 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#Java #Socket #J# #Swing #多线程

  几个不算完整的小项目:

 

  一 : 豆子吃妖精?

   

/**独立一个类,设置豆子的位置和图片...
 * */
package lyh.projects.pacman;

import java.awt.Rectangle;
import java.awt.image.BufferedImage;
import java.io.IOException;

import javax.imageio.ImageIO;

/*读入所有要用到的图片到内存中..
 * 还有图片的位置...
 * */
public class PacMan {
	Rectangle rt;       //控制图片的位置....
	BufferedImage current;
	BufferedImage c1;
	BufferedImage c2;
	BufferedImage c3;
	BufferedImage c4;
	//在实例化这个类的时候,就通过构造读入内存中...
	public PacMan(){
		rt = new Rectangle(220,350,35,35);
		try{
			//获得地址...读入内存...
	    	current = ImageIO.read(this.getClass().getResourceAsStream("/images/stop.png"));
	    	//多读几张图片,换方向
	    	c1 = ImageIO.read(this.getClass().getResourceAsStream("/images/u.png"));
	    	c2 = ImageIO.read(this.getClass().getResourceAsStream("/images/d.png"));
	    	c3 = ImageIO.read(this.getClass().getResourceAsStream("/images/l.png"));
	    	c4 = ImageIO.read(this.getClass().getResourceAsStream("/images/r.png"));
		}catch(IOException e){
			e.printStackTrace();
		}
	} 
//    public static void main(String[] args){
//	    PacMan man = new PacMan();
//    }
}

 

/**独立一个类,设置保存妖精的位置和图片...
 * */
package lyh.projects.pacman;

import java.awt.Rectangle;
import java.awt.image.BufferedImage;
import java.io.IOException;

import javax.imageio.ImageIO;

/*读入所有要用到的图片到内存中..
 * 还有图片的位置...
 * */
public class PacMonter {
	Rectangle rt;
	BufferedImage current;
	BufferedImage c1;
	BufferedImage c2;
	BufferedImage c3;
	BufferedImage c4;
	
    public PacMonter(){
    	rt = new Rectangle(0,0,35,35);
    	try{
            //找到它的地址,将图片读入内存
        	current = ImageIO.read(this.getClass().getResourceAsStream("/images/m_001.png"));
        	//多读几张图片,换状态
        	c1 = ImageIO.read(this.getClass().getResourceAsStream("/images/m_002.png"));
        	c2 = ImageIO.read(this.getClass().getResourceAsStream("/images/m_003.png"));
        	c3 = ImageIO.read(this.getClass().getResourceAsStream("/images/m_004.png"));
        	c4 = ImageIO.read(this.getClass().getResourceAsStream("/images/m_001.png"));
        	}catch(IOException e){
        		e.printStackTrace();
        	}
        }
//    public static void main(String[] args){
//    	PacMonter monter = new PacMonter();
//    }
}

 

程序入口:

/**豆子吃妖精:
 * 1: 初始化界面:JFrame
 * 2: 另建两个类,保存图片和位置...
 * 3: 加载JPANEL,画出图形...
 * 4: 建立一个键盘监听,让豆子动起来...
 * 5: 建立一个线程类,让妖精动起来...主要是用开关实现判断越界!
 * 6: 画出分数...
 *    <<测试,完善...
 * 7: 后续: 子弹...妖精血量?...[飞机大战?呵呵]
 * */
package lyh.projects.pacman;

import java.awt.Color;
import java.awt.Graphics;
import java.awt.event.KeyEvent;
import java.awt.event.KeyListener;
import java.util.Random;

import javax.swing.JFrame;
import javax.swing.JPanel;

//public类，实现所有功能？？

public class PacGame {
	JFrame jframe;
	PacPanel panel;
	 /*初始化窗体.... */
	public PacGame(){	
		//实例化一个窗体并设置背景...
		jframe = new JFrame("豆子吃妖精...");
		jframe.setBackground(Color.BLACK);
		//设置窗体不可改变大小...
		jframe.setResizable(false);
		//没置窗体显示在Windows的位置,和它自己的位置...
		jframe.setBounds(100, 100, 640, 460);
		//加载JPANEL画板.
		panel = new PacPanel();
		jframe.setContentPane(panel);
		
		//加载一个键盘监听,实现控制豆子的移动...匿名内部类,实现接口所有方法....
		jframe.addKeyListener(new KeyListener(){	
			//键盘按下去事件...
			public void keyPressed(KeyEvent e) {
			    if(e.getKeyCode() == KeyEvent.VK_UP){
			    	   //设置换方向的图片..
			    	panel.pacman.current = panel.pacman.c1;
			    	if(panel.pacman.rt.y > 10){       //判断是否越界...
			    	panel.pacman.rt.y = panel.pacman.rt.y - 10;
			    	}
			    }
			    if(e.getKeyCode() == KeyEvent.VK_DOWN){
			    	panel.pacman.current = panel.pacman.c2;
			    	if(panel.pacman.rt.y < 390){
			    	panel.pacman.rt.y = panel.pacman.rt.y + 10;
			    	}
			    }
			    if(e.getKeyCode() == KeyEvent.VK_LEFT){
			    	panel.pacman.current = panel.pacman.c3;
			    	if(panel.pacman.rt.x > 10){
			    	panel.pacman.rt.x = panel.pacman.rt.x - 10;
			    	}
			    }
			    if(e.getKeyCode() == KeyEvent.VK_RIGHT){
			    	panel.pacman.current = panel.pacman.c4;
			    	if(panel.pacman.rt.x < 600){
			    	panel.pacman.rt.x = panel.pacman.rt.x + 10;
			    	}
			    }
			    jframe.repaint();
			}
			public void keyReleased(KeyEvent e) {
			}
			public void keyTyped(KeyEvent e) {
			}
		});
		//起动控制妖精移动线程...
		Thread t1 = new MonterThread();
		t1.start();
		//窗体关闭退出程序...
		jframe.setDefaultCloseOperation(jframe.EXIT_ON_CLOSE);
		//设置窗体可见..
		jframe.setVisible(true);      
	}
	
/*
*新建一个内部线程类,控制妖精的(随机?)移动...
*并断判豆子与妖精是否相遇...
*实现相遇后被吃(换图片,换位置)...*/
	boolean movex = true;
	boolean movey = true;
class MonterThread extends Thread{
		//起动线程时自动调用RUN方法..
		public void run(){
			boolean isStop = true;
			while(isStop){
				
				//判断豆子,妖精是否相遇(被吃)
				if(panel.monter.rt.intersects(panel.pacman.rt)){
					int random = getRandom();
					//用随机四张图片来表示妖精被吃...
					switch (random) {
					case 1 :	panel.monter.current = panel.monter.c1;       break;
					case 2 :	panel.monter.current = panel.monter.c2;       break;
					case 3 :	panel.monter.current = panel.monter.c3;       break;
					case 4 :	panel.monter.current = panel.monter.c4;       break;
					default : panel.monter.current = panel.monter.current;  break;
					}
					panel.monter.rt.x = new Random().nextInt(600);
					panel.monter.rt.y = new Random().nextInt(390);
					panel.scope += 10;
				}
				 /* 移动思路... 
				 *panel.monter.rt.x = panel.monter.rt.x +(int)(Math.random()*11);
				 *panel.monter.rt.y = panel.monter.rt.y +(int)(Math.random()*11);
	             *    ----------
				/*用movex,movey开(+)关(-)[判断是否越界],来控制妖精的移动...
				 * */
				if(movex == true){
					//给出随机移动象素大小,产生一个飘移效果...
					panel.monter.rt.x += (int)(Math.random()*11);    
					if(panel.monter.rt.x >= 600){
						movex = false;
					}
				}else{
					panel.monter.rt.x -= (int)(Math.random()*11);
				    if(panel.monter.rt.x <= 0){
				    	movex = true;
				    }
				}
				if(movey == true){
					panel.monter.rt.y += (int)(Math.random()*11);
					if(panel.monter.rt.y >= 390){
						movey = false;
					}
				}else{
					panel.monter.rt.y -= (int)(Math.random()*11);
					if(panel.monter.rt.y <= 0){
						movey = true;
					}
				}
				try{
					//移动一次就停0.06秒,不然看不见,移动太快...
				Thread.sleep(60);
				}catch(Exception e){
					e.printStackTrace();
				}
				jframe.repaint();       //刷新
			}
		}
}   
    public int getRandom(){
    	return (new Random().nextInt(4)) + 1; 
    }
    public static void main(String[] args){
    	PacGame game = new PacGame();
    }
}

/*新建一个PANEL容器类,画出图片,并控制图片的位置...
 * */
class PacPanel extends JPanel{
	//实例化两个图片类...
	PacMan pacman = new PacMan();
	PacMonter monter = new PacMonter();
	int scope = 0;
	//继承基类的PAINT方法,画出图片...
	public void paint(Graphics g) {
	    g.drawImage(pacman.current,pacman.rt.x,pacman.rt.y,
	    		      pacman.rt.width,pacman.rt.height,null);
	
	    g.drawImage(monter.current,monter.rt.x,monter.rt.y,
	    		monter.rt.width,monter.rt.height,null);
	    g.setColor(Color.RED);
	    g.drawString("当前分数为: " + scope, 280, 420);
  
	}
}

  

2 : 两人五子棋...

    

/** 1:建立客户端...
 *  2:初始化棋盘...jframe,jpanel
 *  3:加载图片,并在jpanel中画出(并且select.gif能随着鼠标移动)
 *  4:初始化二维数组,并实现落子功能...
 *  5:发送落子坐标给服务器...传送给另一方实现交互..('频道'属性文件设置..)
 *  6:建立一个线程使终等待服务器信息...
 *  7:画出对方落子...
 *  8:判断输赢...
 *  9:黑白竞手...
 *     <<<边代码边测试....
 * */
package lyh.projects.gobangnet;

import java.awt.Dimension;
import java.awt.Graphics;
import java.awt.event.MouseAdapter;
import java.awt.event.MouseEvent;
import java.awt.event.MouseMotionListener;
import java.awt.image.BufferedImage;
import java.io.BufferedReader;
import java.io.File;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.net.Socket;

import javax.imageio.ImageIO;
import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.JOptionPane;

public class GobangClient {
	private JPanel panel;
	private int[][] border;
	//关于table用到的些常量
	private int BOARD_SIZE = 15;      //多少个格子,常量
	private final int TABLE_WIDTH = 535;
	private final int TABLE_HEIGHT = 536;
	private final int RATE = TABLE_WIDTH / BOARD_SIZE;  //设置光标一次移动一个格子
	private final int X_OFFSET = 5;      //偏移量
	private final int Y_OFFSET = 6;
	//把几张要用到的图片加载到内存...
	BufferedImage table;
	BufferedImage selected;
	BufferedImage black;
	BufferedImage white;
	//光标移动坐标...
	private int movex = 0;
	private int movey = 0;
	//鼠标点击坐标
	private int pointx = 0;
	private int pointy = 0;
	
	private final int EMPTY = 0;
	private final int WHITE = 1;
	private final int BLACK= 2;
	
	boolean isGo = true;
	
	private PrintWriter pw = null;
	//构造函数..建立连接..
	public GobangClient(){
		try{
	    Socket client = new Socket("127.0.0.1",8899);
	    init();
	    pw = new PrintWriter(client.getOutputStream());
	    new ClientThread(client).start();   //起动线程
		}catch(IOException e){
			e.printStackTrace();
		}
	}
	//初始化棋盘..
	public void init(){
		JFrame jframe = new JFrame("局域五子棋...");
		try{
		    table = ImageIO.read(new File("image/board.jpg"));
		    selected = ImageIO.read(new File("image/selected.gif"));
		    black = ImageIO.read(new File("image/black.gif"));
		    white = ImageIO.read(new File("image/white.gif"));
		}catch(IOException e){
			e.printStackTrace();
		}
		//初始化数组..初始每一元素为0;
		border = new int[BOARD_SIZE][BOARD_SIZE];
		for(int i = 0; i < BOARD_SIZE; i++){
			for(int j = 0; j < BOARD_SIZE; j++){
				border[i][j] = EMPTY;
			}
		}
		panel = new jpanel();
		//加载jpanel,并设置它的大小...
		panel.setPreferredSize(new Dimension(TABLE_WIDTH,TABLE_HEIGHT));
		//在panel里面加载一个鼠标移动监听,实现光标随鼠标移动功能
		panel.addMouseMotionListener(new MouseMotionListener(){

			public void mouseDragged(MouseEvent e) {
		
			}
			public void mouseMoved(MouseEvent e) {
				//优化鼠标移动..一次移动一个格...
			    movex = (int)((e.getX() - X_OFFSET) / RATE);
			    movey = (int)((e.getY() - Y_OFFSET) / RATE);
			    panel.repaint();
			}
		});
		//鼠标点击监听,获得坐标,实现落子功能...
		panel.addMouseListener(new MouseAdapter(){
			
			public void mousePressed(MouseEvent e) {

				 if(isGo){     //黑白竞手...
					 pointx = (int)((e.getX() - X_OFFSET) / RATE);
					 pointy = (int)((e.getY() - Y_OFFSET) / RATE);
					 border[pointx][pointy] = BLACK;     //往数组里面放值..
					 panel.repaint();
					 //加载属性文件...
					 pw.println(Protocols.POINTXY+pointx + "," + pointy+Protocols.POINTXY);
					 pw.flush();      //加载属性文件...
				 }
				 isGo = false;		
				 
				 //调用方法,判断输赢...
				 if(isWin()){
					 pw.println(Protocols.WIN);
					 JOptionPane.showMessageDialog(panel, "恭喜你,赢了...");
				 }
			}
		});
		jframe.add(panel);
		jframe.pack();     //设置为填充显示...
		jframe.setResizable(false);  //不可改变大小...
		jframe.setDefaultCloseOperation(jframe.EXIT_ON_CLOSE);
		jframe.setVisible(true);   //窗体可见...
	}
//一个内部类jpanel,继承JPanel,画出图形...
class jpanel extends JPanel{

	public void paint(Graphics g) {
	    g.drawImage(table,0,0,null);  
	    g.drawImage(selected,movex * RATE + X_OFFSET,movey * RATE + X_OFFSET,null);
	    for(int i = 0; i < BOARD_SIZE; i++){
	    	for(int j = 0; j < BOARD_SIZE; j++){
	    		//遍历数姐值,画出黑白子...
	    		if(border[i][j] == BLACK){
	    			g.drawImage(black,i * RATE + X_OFFSET,j * RATE + X_OFFSET,null);	
	    		}else if(border[i][j] == WHITE){
	    			g.drawImage(white,i * RATE + X_OFFSET,j * RATE + X_OFFSET,null);
	    		}
	    	}
	    }
	}
}
/*建立一个线程使终等待服务器信息...
 * 处理信息并落子
 *  */
class ClientThread extends Thread{
	Socket client;
	public ClientThread(Socket client){
		this.client = client;
	}
	public void run(){
		try{
		BufferedReader br = new BufferedReader(
				               new InputStreamReader(client.getInputStream()));
		String temp = br.readLine();
		System.out.println(temp);
		boolean isStop = true;
		while(isStop){
			//处理信息
			if(temp.startsWith(Protocols.POINTXY)){
				SplitMessage(SubMessage(temp));
			}else if(temp.equals("%$")){
				JOptionPane.showMessageDialog(panel, "对方赢了...");
			}
			temp = br.readLine();
		}
		}catch(IOException e){
			e.printStackTrace();
		}
	}	
}
    //切割字符串生成坐标,并落子...
    public void SplitMessage(String temp){
    	String[] temps = temp.split(",");
    	int x = Integer.parseInt(temps[0]);
    	int y = Integer.parseInt(temps[1]);
    	border[x][y] = WHITE;
        isGo = true;     //黑白竞手...
    	panel.repaint();
    }
    //截取字符串(处理信息)
    public String SubMessage(String temp){
    	return temp.substring(2,temp.length() - 2);
    }
	   //判断赢的方法...
    public boolean isWin(){
    	//横向判断...
    	for(int i = 0; i < border.length; i++){
    		 int sum = 0;
    		 int count = 0;
    		for(int j = 0; j < border.length; j++){
    			if(border[j][i] == BLACK){			    				
    			    sum += border[j][i];
    			    ++count;
    			}
    			if(sum == 10 && count == 5){
                	return true;
                }
    		}
    	}
    	//纵向判断...
    	for(int i = 0; i < border.length; i++){
    		int sum = 0;
    		int count = 0;
    		for(int j = 0; j < border.length; j++){
    			if(border[i][j] == BLACK){
    			sum += border[i][j];
    			count++;
    			}
    			if(sum == 10 && count == 5){
                	return true;
                }
    		}
    	}
    	//右下对角线...
    	for(int i = -(border.length - 2); i < border.length - 1; i++){
    		int sum = 0;
    		int count = 0;
    		for(int j = 0; j < border.length; j++){
    			int line = i + j;   //截取没有越界的点...
    			if(line >= 0 && line < border.length){
    				if(border[j][line] == BLACK){
    				sum += border[j][line];
        			count++;
    				}
    				if(sum == 10 && count == 5){
                    	return true;
                    }
    			}
    		}
    	}
    	//右下对角线...
    	for(int i = 1; i < 2 * (border.length - 1); i++){
    		int sum = 0;
    		int count = 0;
    		for(int j = 0; j < border.length; j++){
    			int line = i - j;
    			if(line >= 0 && line < border.length){
    				if(border[j][line] == BLACK){
    				sum += border[j][line];
        			count++;
    				}
                    if(sum == 10 && count == 5){
                    	return true;
                    }
    			}
    		}
  	    }
    return false;
    }
    public static void main(String[] args){
    	GobangClient client = new GobangClient();
    }
}

 

/** 1:建立服务器端...
 *  2:接收信息,转发...
 * */
package lyh.projects.gobangnet;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.ArrayList;
import java.util.List;

//一个public类，实现所有的功能。
public class GobangServer {
	//容器,保存两客户端的信息
	private List<Socket> clients = new ArrayList<Socket>(2);
	//构造函数,建立服务器端
	public GobangServer(){
		try{
	    ServerSocket ss = new ServerSocket(8899);
	    boolean isStop = true;
	    while(isStop){
		    Socket client = ss.accept();
		    System.out.println("连接成功...");
		    new ServerThread(client).start();   //起动线程...
		    clients.add(client);      //保存信息...
	    }
		}catch(IOException e){
			e.printStackTrace();
		}
	}
//一个线程,使终等待守候信息...
class ServerThread extends Thread{
	//ServerThread构造函数..听说线程只有这一种获得参数的方式..
	Socket client;
	public ServerThread(Socket client){
		this.client = client;
	}
	//读入客户端信息反回给别一端...
	public void run(){
		try{
	    BufferedReader br = new BufferedReader(
	    		                new InputStreamReader(client.getInputStream()));
	    String temp = br.readLine();
	    boolean isStop = true;
	    while(isStop){
	    	//获得另一端...
	        for(int i = 0; i < clients.size(); i++){
	        	Socket s = clients.get(i);
	        	 if(client != s){
	        		 //把信息发送给另一端...
	 	        	PrintWriter pw = new PrintWriter(s.getOutputStream());
	 	        	pw.println(temp);
	 	        	pw.flush();
	 	        	temp = br.readLine();
	 	        }
	        }
	    }
		}catch(IOException e){
			e.printStackTrace();
		}
	}
}
    public static void main(String[] args){
    	new GobangServer();
    }
}

 

package lyh.projects.gobangnet;
//它们通信的一个协议!
public class Protocols {
	
	//坐标
   public final static String POINTXY = "!@";
   public final static String STOP = "#$";
   public final static String WIN = "%$";
   
}

 

3：

**图书管理系统......

4：

**模拟QQ软件......

5：

**记事本......

6：

7：

8：

9：

 

评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值