Java 俄罗斯方块，面向对象版本----Swing界面

版权声明：您好，欢迎来到我的技术博客。 https://blog.csdn.net/zwyjg/article/details/82861552

import java.awt.*;
import java.awt.event.*;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;
import java.util.*;
import javax.swing.*;
import java.util.Timer;

public class Hufan extends JFrame{
	HuPanel hp;

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		new Hufan();
	}

	public Hufan() {
		hp = new HuPanel();
		this.addKeyListener(hp);
		this.add(hp, "Center");
		new Thread(hp).start();
		this.setLocation(700, 100);
		this.setSize(500, 650);
		this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
		this.setVisible(true);
	}
}

class HuPanel extends JPanel implements KeyListener,Runnable{
	DownSpeed ds;
	KeyPressTask kpt;
	static int time = 0;
	Timer timer;
	static KeyEvent ke;
	// 面板下落图形种类集合
	static HashMap<Integer, ArrayList<Rect>> frontHm = new HashMap<>();
	static int bianXingCode;
	static int jiShu;
	static boolean keyPress = false;
	// 所有种类图形集合
	static HashMap<Integer, HashMap<Integer, ArrayList<Rect>>> hmAll = new HashMap<>();
	// 到达底部集合
	static ArrayList<Rect> downList = new ArrayList<>();
	static HashMap<Integer, HashMap<Integer, ArrayList<Rect>>> hm;
	//static HashMap<Integer, ArrayList<Rect>> ohm;
	public HuPanel() {
		this.init();
		this.addFrontHm(0);
		ds=new DownSpeed();
		new Thread(ds).start();
		kpt=new KeyPressTask();
		new Thread(kpt).start();
//		timer = new Timer();// 定时器不断
//		timer.schedule(new KeyPressTask(), 1);
	}
	public static void init() {
		/**
		 *       ▇ ▇	0
		 *    ▇ ▇
		 */
		HashMap<Integer, ArrayList<Rect>> hm0 = new HashMap<Integer, ArrayList<Rect>>();

		ArrayList<Rect> rectList1 = new ArrayList<Rect>();
		ArrayList<Rect> rectList2 = new ArrayList<Rect>();

		Rect rect1 = new Rect(3, 0);
		Rect rect2 = new Rect(3, 1);
		Rect rect3 = new Rect(4, 1);
		Rect rect4 = new Rect(4, 2);
		rectList1.add(rect1);
		rectList1.add(rect2);
		rectList1.add(rect3);
		rectList1.add(rect4);
		hm0.put(0, rectList1);

		Rect rect5 = new Rect(4, 0);
		Rect rect6 = new Rect(5, 0);
		Rect rect7 = new Rect(4, 1);
		Rect rect8 = new Rect(3, 1);
		rectList2.add(rect5);
		rectList2.add(rect6);
		rectList2.add(rect7);
		rectList2.add(rect8);
		hm0.put(1, rectList2);
		hmAll.put(0, hm0);
		/**
		 *      ▇ ▇		1
		 *         ▇ ▇
		 */
		HashMap<Integer, ArrayList<Rect>> hm1 = new HashMap<Integer, ArrayList<Rect>>();

		ArrayList<Rect> rectList3 = new ArrayList<Rect>();
		ArrayList<Rect> rectList4 = new ArrayList<Rect>();

		Rect rect9 = new Rect(3, 1);
		Rect rect10 = new Rect(3, 2);
		Rect rect11 = new Rect(4, 0);
		Rect rect12 = new Rect(4, 1);
		rectList3.add(rect9);
		rectList3.add(rect10);
		rectList3.add(rect11);
		rectList3.add(rect12);
		hm1.put(0, rectList3);

		Rect rect13 = new Rect(3, 0);
		Rect rect14 = new Rect(4, 0);
		Rect rect15 = new Rect(4, 1);
		Rect rect16 = new Rect(5, 1);
		rectList4.add(rect13);
		rectList4.add(rect14);
		rectList4.add(rect15);
		rectList4.add(rect16);
		hm1.put(1, rectList4);
		hmAll.put(1, hm1);
		/**
		 *      ▇ ▇	2
		 *      ▇ ▇
		 */
		HashMap<Integer, ArrayList<Rect>> hm2 = new HashMap<Integer, ArrayList<Rect>>();

		ArrayList<Rect> rectList5 = new ArrayList<Rect>();

		Rect rect17 = new Rect(3, 0);
		Rect rect18 = new Rect(4, 0);
		Rect rect19 = new Rect(3, 1);
		Rect rect20 = new Rect(4, 1);
		rectList5.add(rect17);
		rectList5.add(rect18);
		rectList5.add(rect19);
		rectList5.add(rect20);
		hm2.put(0, rectList5);
		HuPanel.hmAll.put(2, hm2);
		/**
		 *      ▇ ▇ ▇ ▇	3
		 *      
		 */
		HashMap<Integer, ArrayList<Rect>> hm3 = new HashMap<Integer, ArrayList<Rect>>();

		ArrayList<Rect> rectList6 = new ArrayList<Rect>();
		ArrayList<Rect> rectList7 = new ArrayList<Rect>();

		Rect rect21 = new Rect(3, 0);
		Rect rect22 = new Rect(3, 1);
		Rect rect23 = new Rect(3, 2);
		Rect rect24 = new Rect(3, 3);
		rectList6.add(rect21);
		rectList6.add(rect22);
		rectList6.add(rect23);
		rectList6.add(rect24);
		hm3.put(0, rectList6);

		Rect rect25 = new Rect(2, 0);
		Rect rect26 = new Rect(3, 0);
		Rect rect27 = new Rect(4, 0);
		Rect rect28 = new Rect(5, 0);
		rectList7.add(rect25);
		rectList7.add(rect26);
		rectList7.add(rect27);
		rectList7.add(rect28);
		hm3.put(1, rectList7);
		HuPanel.hmAll.put(3, hm3);
		/**
		 *       ▇ ▇ ▇		4
		 *       ▇
		 */
		HashMap<Integer, ArrayList<Rect>> hm4 = new HashMap<Integer, ArrayList<Rect>>();

		ArrayList<Rect> rectList8 = new ArrayList<Rect>();
		ArrayList<Rect> rectList9 = new ArrayList<Rect>();
		ArrayList<Rect> rectList10 = new ArrayList<Rect>();
		ArrayList<Rect> rectList11 = new ArrayList<Rect>();

		Rect rect29 = new Rect(3, 0);
		Rect rect30 = new Rect(4, 0);
		Rect rect31 = new Rect(5, 0);
		Rect rect32 = new Rect(3, 1);
		rectList8.add(rect29);
		rectList8.add(rect30);
		rectList8.add(rect31);
		rectList8.add(rect32);
		hm4.put(0, rectList8);

		Rect rect33 = new Rect(3, 0);
		Rect rect34 = new Rect(4, 0);
		Rect rect35 = new Rect(4, 1);
		Rect rect36 = new Rect(4, 2);
		rectList9.add(rect33);
		rectList9.add(rect34);
		rectList9.add(rect35);
		rectList9.add(rect36);
		hm4.put(1, rectList9);

		Rect rect37 = new Rect(5, 0);
		Rect rect38 = new Rect(5, 1);
		Rect rect39 = new Rect(4, 1);
		Rect rect40 = new Rect(3, 1);
		rectList10.add(rect37);
		rectList10.add(rect38);
		rectList10.add(rect39);
		rectList10.add(rect40);
		hm4.put(2, rectList10);

		Rect rect41 = new Rect(3, 0);
		Rect rect42 = new Rect(3, 1);
		Rect rect43 = new Rect(3, 2);
		Rect rect44 = new Rect(4, 2);
		rectList11.add(rect41);
		rectList11.add(rect42);
		rectList11.add(rect43);
		rectList11.add(rect44);
		hm4.put(3, rectList11);
		HuPanel.hmAll.put(4, hm4);
		/**
		 *       ▇ 
		 *       ▇ ▇ ▇		5
		 */
		HashMap<Integer, ArrayList<Rect>> hm5 = new HashMap<Integer, ArrayList<Rect>>();

		ArrayList<Rect> rectList12 = new ArrayList<Rect>();
		ArrayList<Rect> rectList13 = new ArrayList<Rect>();
		ArrayList<Rect> rectList14 = new ArrayList<Rect>();
		ArrayList<Rect> rectList15 = new ArrayList<Rect>();

		Rect rect45 = new Rect(3, 0);
		Rect rect46 = new Rect(3, 1);
		Rect rect47 = new Rect(4, 1);
		Rect rect48 = new Rect(5, 1);
		rectList12.add(rect45);
		rectList12.add(rect46);
		rectList12.add(rect47);
		rectList12.add(rect48);
		hm5.put(0, rectList12);

		Rect rect49 = new Rect(3, 0);
		Rect rect50 = new Rect(4, 0);
		Rect rect51 = new Rect(3, 1);
		Rect rect52 = new Rect(3, 2);
		rectList13.add(rect49);
		rectList13.add(rect50);
		rectList13.add(rect51);
		rectList13.add(rect52);
		hm5.put(1, rectList13);

		Rect rect53 = new Rect(3, 0);
		Rect rect54 = new Rect(4, 0);
		Rect rect55 = new Rect(5, 0);
		Rect rect56 = new Rect(5, 1);
		rectList14.add(rect53);
		rectList14.add(rect54);
		rectList14.add(rect55);
		rectList14.add(rect56);
		hm5.put(2, rectList14);

		Rect rect57 = new Rect(4, 0);
		Rect rect58 = new Rect(4, 1);
		Rect rect59 = new Rect(4, 2);
		Rect rect60 = new Rect(3, 2);
		rectList15.add(rect57);
		rectList15.add(rect58);
		rectList15.add(rect59);
		rectList15.add(rect60);
		hm5.put(3, rectList15);
		HuPanel.hmAll.put(5, hm5);
	}
	//往面板frontList添加一个图形
	public static void addFrontHm(int next) {
		HuPanel.init();
		HashMap<Integer, ArrayList<Rect>> hm=hmAll.get(next);
		for (Integer key : hm.keySet()) {
			ArrayList<Rect> rectList = hm.get(key);
			HuPanel.frontHm.put(key, rectList);
		}
		HuPanel.bianXingCode = new Random().nextInt(HuPanel.frontHm.size());
	}
	/**
     * 对象深度复制(对象必须是实现了Serializable接口)
     *
     * @param obj
     * @return T
     * @author Muscleape
     * @date 2018/8/10 14:39
     */
//    @SuppressWarnings("unchecked")
//	public static <T extends Serializable> T clone(T obj) {
//        T clonedObj = null;
//        try {
//            ByteArrayOutputStream baos = new ByteArrayOutputStream();
//            ObjectOutputStream oos = new ObjectOutputStream(baos);
//            oos.writeObject(obj);
//            oos.close();
//
//            ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray());
//            ObjectInputStream ois = new ObjectInputStream(bais);
//            clonedObj = (T) ois.readObject();
//            ois.close();
//        } catch (Exception e) {
//            e.printStackTrace();
//        }
//        return clonedObj;
//    }
    
	public void paint(Graphics g) {
		super.paint(g);
		// 画格子
		g.setColor(Color.blue);
		for (int i = 0; i <= 20; i++) {
			g.drawLine(10, i * 30 + 10, 310, i * 30 + 10);
		}
		for (int i = 0; i <= 10; i++) {
			g.drawLine(i * 30 + 10, 10, i * 30 + 10, 610);
		}
		// System.out.println(frontHm.size());
		// 画出面板图形
		g.setColor(Color.black);
		for (Integer key : frontHm.keySet()) {
			if (bianXingCode == key) {
				ArrayList<Rect> array = frontHm.get(key);
				for (int i = 0; i < array.size(); i++) {
					Rect rect = array.get(i);
					g.fillRect(rect.x * 30 + 12, rect.y * 30 + 12, 26, 26);
				}
			}
		}
		// 画出到达底部的图形
		for (int i = 0; i < downList.size(); i++) {
			Rect rect = downList.get(i);
			g.fillRect(rect.x * 30 + 12, rect.y * 30 + 12, 26, 26);
		}
	}
	
	@Override
	public void run() {
		while (true) {

			try {
				Thread.sleep(20);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			this.repaint();
		}
	}
	public void keyTyped(KeyEvent e) {}
	public void keyReleased(KeyEvent e) {
		this.ke=e;
		this.keyPress=false;
		this.time=0;
	}
	public void keyPressed(KeyEvent e) {
		this.ke=e;
		this.keyPress=true;
	}
	//删除一行
	public static void delRectLine(int del) {
		for(int i=0;i<10;i++) {
			HuPanel.downList.remove(new Rect(i,del));
		}
		for(int j=0;j<HuPanel.downList.size();j++) {
			Rect re=HuPanel.downList.get(j);
			if(re.y<del) {
				re.y+=1;
			}
		}
	}
}
class DownSpeed implements Runnable{
		
	@Override
	public void run() {
		// TODO Auto-generated method stub
		while(true) {
			
			for (Integer key : HuPanel.frontHm.keySet()) {// 遍历面板种类图形，并取出一个图形
				ArrayList<Rect> array = HuPanel.frontHm.get(key);
			
				if (Rect.isDownStop == true) {
					for (int i = 0; i < array.size(); i++) {
						Rect rect = array.get(i);
						rect.y += 1;
					}
				}

				if (HuPanel.bianXingCode == key) {
					for (int i = 0; i < array.size(); i++) {
						Collections.sort(array, new SortByY());
						Rect rect = array.get(array.size() - 1);
						if (rect.y == 19) {
							Rect.isDownStop = false;// 到达底部，就停止，并退出循环
							break;
						}
					}
				}

				if (HuPanel.bianXingCode == key) {
					for (int i = 0; i < array.size(); i++) {
						Rect frontRect = array.get(i);
						for (int j = 0; j < HuPanel.downList.size(); j++) {
							Rect downRect = HuPanel.downList.get(j);
							if (frontRect.y + 1 == downRect.y && frontRect.x == downRect.x) {
								Rect.isDownStop = false;
								break;
							}
						}
					}
				}

				if (Rect.isDownStop == false) {
					HuPanel.downList.addAll(array);
					HuPanel.frontHm.clear();

					int next = new Random().nextInt(6);
					HuPanel.addFrontHm(next);
					Rect.isDownStop = true;
					Rect.isLeftStop = true;
					Rect.isRightStop = true;

					for (int y = 0; y < 20; y++) {
						for (int i = 0; i < HuPanel.downList.size(); i++) {
							Rect rect = HuPanel.downList.get(i);
							for (int x = 0; x < 10; x++) {
								if (rect.x == x && rect.y == y) {
									HuPanel.jiShu++;
									if (HuPanel.jiShu == 10) {
										HuPanel.delRectLine(y);
									}
								}
							}
						}
						HuPanel.jiShu = 0;
					}
					break;
				}
			}
			
			try {
				Thread.sleep(400);
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
	}
	
}
class KeyPressTask extends TimerTask implements Runnable{
	@SuppressWarnings("unchecked")
	@Override
	public void run() {
		// TODO Auto-generated method stub
		while (true) {
			if (HuPanel.keyPress) {
				
				for (Integer key : HuPanel.frontHm.keySet()) {// 遍历面板种类图形，并取出一个图形
					ArrayList<Rect> array = HuPanel.frontHm.get(key);

					if (HuPanel.ke.getKeyCode() == 38) {// 上
						HuPanel.time += 1;
						if (HuPanel.time == 1) {
							HuPanel.bianXingCode += 1;
							if (HuPanel.bianXingCode >= HuPanel.frontHm.size()) {
								HuPanel.bianXingCode = 0;
							}
						}
					}else if (HuPanel.ke.getKeyChar() == '/') {
						
					}else if (HuPanel.ke.getKeyCode() == 40) {// 下
						if (Rect.isDownStop == true) {
							for (int i = 0; i < array.size(); i++) {
								Rect rect = array.get(i);
								rect.y += 1;
							}
						}

						if (HuPanel.bianXingCode == key) {
							for (int i = 0; i < array.size(); i++) {
								Collections.sort(array, new SortByY());
								Rect rect = array.get(array.size() - 1);
								if (rect.y == 19) {
									Rect.isDownStop = false;// 到达底部，就停止，并退出循环
									break;
								}
							}
						}

						if (HuPanel.bianXingCode == key) {
							for (int i = 0; i < array.size(); i++) {
								Rect frontRect = array.get(i);
								for (int j = 0; j < HuPanel.downList.size(); j++) {
									Rect downRect = HuPanel.downList.get(j);
									if (frontRect.y + 1 == downRect.y && frontRect.x == downRect.x) {
										Rect.isDownStop = false;
										break;
									}
								}
							}
						}

						if (Rect.isDownStop == false) {
							HuPanel.downList.addAll(array);
							HuPanel.frontHm.clear();

							int next = new Random().nextInt(6);
							HuPanel.addFrontHm(next);
							Rect.isDownStop = true;
							Rect.isLeftStop = true;
							Rect.isRightStop = true;

							for (int y = 0; y < 20; y++) {
								for (int i = 0; i < HuPanel.downList.size(); i++) {
									Rect rect = HuPanel.downList.get(i);
									for (int x = 0; x < 10; x++) {
										if (rect.x == x && rect.y == y) {
											HuPanel.jiShu++;
											if (HuPanel.jiShu == 10) {
												HuPanel.delRectLine(y);
											}
										}
									}
								}
								HuPanel.jiShu = 0;
							}
							break;
						}

					} else if (HuPanel.ke.getKeyCode() == 37) {// 左

						for (int i = 0; i < array.size(); i++) {
							Collections.sort(array, new SortByX());
							Rect rect = array.get(0);

							if (rect.x == 0) {
								Rect.isLeftStop = false;
								Rect.isRightStop = true;
								break;
							} else if (rect.x > 0 && rect.x < 9) {
								Rect.isLeftStop = true;
								Rect.isRightStop = true;
							}
						}

						if (HuPanel.bianXingCode == key) {
							for (Rect frontRect : array) {
								for (Rect downRect : HuPanel.downList) {
									if (frontRect.x - 1 == downRect.x && frontRect.y == downRect.y) {
										Rect.isLeftStop = false;
									}
								}
							}
						}

						if (Rect.isLeftStop == true) {
							for (int i = 0; i < array.size(); i++) {
								Rect rect = array.get(i);
								rect.x -= 1;
							}
						}

					} else if (HuPanel.ke.getKeyCode() == 39) {// 右

						for (int i = 0; i < array.size(); i++) {
							Collections.sort(array, new SortByX());
							Rect rect = array.get(array.size() - 1);

							if (rect.x == 9) {
								Rect.isRightStop = false;
								Rect.isLeftStop = true;
							} else if (rect.x < 9 && rect.x > 0) {
								Rect.isLeftStop = true;
								Rect.isRightStop = true;
							}
						}
						if (HuPanel.bianXingCode == key) {
							for (Rect frontRect : array) {
								for (Rect downRect : HuPanel.downList) {
									if (frontRect.x + 1 == downRect.x && frontRect.y == downRect.y) {
										Rect.isRightStop = false;
									}
								}
							}
						}
						if (Rect.isRightStop == true) {
							for (int i = 0; i < array.size(); i++) {
								Rect rect1 = array.get(i);
								rect1.x += 1;
							}
						}

					}
				}

			}
			try {
				Thread.sleep(80);
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
	}

}

class Rect {
	int x;
	int y;
	static boolean isLeftStop = true;
	static boolean isRightStop = true;
	static boolean isDownStop = true;

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

	public boolean equals(Object obj) {
		if (obj == null)
			return false;
		else {
			if (obj instanceof Rect) {
				Rect rect = (Rect) obj;
				if (rect.y == this.y) {
					return true;
				}
			}
		}
		return false;
	}
}

@SuppressWarnings("rawtypes")
class SortByX implements Comparator {
	public int compare(Object o1, Object o2) {
		Rect s1 = (Rect) o1;
		Rect s2 = (Rect) o2;
		if (s1.x > s2.x)
			return 1;
		return -1;
	}
}

class SortByY implements Comparator {
	public int compare(Object o1, Object o2) {
		Rect s1 = (Rect) o1;
		Rect s2 = (Rect) o2;
		if (s1.y > s2.y)
			return 1;
		return -1;
	}
}