Java基础 - 坦克大战（第四章，线程基础）

已于 2022-01-29 15:11:48 修改
阅读量439 收藏 3
点赞数
分类专栏： 笔记 成长阶段 游戏项目 文章标签： java 开发语言 后端
于 2022-01-16 10:00:03 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_39123467/article/details/122519716
版权
笔记 同时被 3 个专栏收录
324 篇文章 9 订阅
订阅专栏
成长阶段
272 篇文章 4 订阅
订阅专栏
游戏项目
14 篇文章 4 订阅
订阅专栏

文章目录

线程终止

基本说明

  1. 当线程完成任务后，会自动退出。

  2. 还可以通过使用变量来控制run方法退出的方式停止线程，即通知方式

案例

  • 启动一个线程t，要求在main线程中去停止线程t，请编程实现。
package com.tao.exit_;

/**
 * Create By 刘鸿涛
 * 2022/1/15 5:16
 */
public class Homework03 {
    public static void main(String[] args) throws InterruptedException {
        Test test = new Test();
        test.start();

        //让main跑起来
//        Homework03 homework03 = new Homework03();
//        homework03.start();
//        int count = 0;
//        while(true){
//            System.out.println("main线程执行中....." + (++count));
//
//            try{
//                Thread.sleep(500);
//            }catch(InterruptedException e){
//                e.printStackTrace();
//            }
//            if(count == 20){
//                test.setCheck(false);
//                System.out.println("AThread线程死亡...");
//            }
//        }
        System.out.println("主线程休眠10秒");
        Thread.sleep(10000);
        test.setCheck(false);
        System.out.println("AThread线程死亡");
    }
}
class Test extends Thread{
    int count = 0;
    //设置一个控制变量
    private boolean check = true;

    public void setCheck(boolean check) {
        this.check = check;
    }

    @Override
    public void run(){

        while(check){
            try{
                Thread.sleep(500);
            }catch(InterruptedException e){
              e.printStackTrace();
            }
            System.out.println("AThread线程执行中..." + (++count));
        }
    }
}

线程常用方法1

  1. setName //设置线程名称，使之与参数 name 相同
  2. getName //返回该线程的名称
  3. start //使该线程开始执行；Java虚拟机底层调用该线程的 start（）方法
  4. run //调用线程对象 run 方法
  5. setPriority //更改线程的优先级
  6. getPriority //获取线程的优先级
  7. sleep //在指定的毫秒数内让当前正在执行的线程休眠（暂停执行）
  8. interrupt //中断线程

细节

  1. start 底层会创建新的线程，调用run，run就是一个简单的方法调用，不会启动新线程
  2. 线程优先级的范围
  3. interrupt，中断线程，但并没有真正的结束线程。所以一般用于中断正在休眠线程
  4. sleep：线程的静态方法，使当前线程休眠
package com.tao.exit_;

/**
 * Create By 刘鸿涛
 * 2022/1/15 7:51
 */
public class threadmethod {
    public static void main(String[] args) throws InterruptedException {
        Test02 test02 = new Test02();
        test02.start();
        test02.setPriority(1);  //更改线程优先级为1
        for (int i = 0; i < 5;) {
            Thread.sleep(1000);
            System.out.println("提醒" + (++i) + "秒");
        }


        System.out.println(test02.getName() + "线程优先级 = " + test02.getPriority());   //1
        test02.interrupt(); //唤醒线程

    }
}
class Test02 extends Thread{
    @Override
    public void run(){
        while(true){
            for (int i = 0; i < 20; ) {
                System.out.println("涛涛在吃第" + (++i) + "包子");
            }
            try{
                System.out.println(Thread.currentThread().getName() + "休眠中...");
                Thread.sleep(10000);
            }catch(InterruptedException e){
                System.out.println(Thread.currentThread().getName() + "的休眠被中断了！（interrupt）");
//                e.printStackTrace();
            }
        }
    }
}

线程常用方法2

礼让（yield）

yield：线程的礼让。让出cpu，让其他线程执行，但礼让的时间不确定，所以也不一定礼让成功

                test02.yield(); //礼让，不一定成功，如果线程够用就不会成功，如果线程繁忙就会礼让成功

而yield（）线程礼让，是根据线程繁忙程度来判断是否需要礼让，比如我们网上售票系统，剩下最后一张票的时候，如果没有礼让机制，那最后一张票很可能同时被多个人购买

插队（join）

join：线程的插队。插队的线程一旦插队成功，则肯定先执行完插入的一个线程所有的任务

package com.tao.exit_;

/**
 * Create By 刘鸿涛
 * 2022/1/15 7:51
 */
public class threadmethod {
    public static void main(String[] args) throws InterruptedException {
        Test02 test02 = new Test02();
        test02.start();
//        test02.setPriority(1);  //更改线程优先级为1
        for (int i = 0; i < 10;) {

            Thread.sleep(1000);
            System.out.println("提醒" + (++i) + "秒" + Thread.currentThread().getName());
            if (i == 5){
                test02.join();
            }
        }

    }
}
class Test02 extends Thread{
    int i = 0;
    @Override
    public void run(){
        while(true){
                System.out.println("涛涛在吃第" + (++i) + "包子" + Thread.currentThread().getName());
            try{
//                System.out.println(Thread.currentThread().getName() + "休眠中...");
                Thread.sleep(1000);
            }catch(InterruptedException e){
                e.printStackTrace();
            }

            if (i == 10){
                break;
            }
        }
    }
}

案例

  • 创建一个子进程，每隔1s 输出 hello，输出20次， 主线程每隔1秒，输出hi，输出20次，要求：两个线程同时执行，当主线程输出5次后，就让子线程运行完毕，主线程再继续，

线程常用方法3

用户线程和守护线程

用户线程

  • 也叫做工作线程，当线程的任务执行完或通知方式结束

守护线程

  • 一般是为工作线程服务的，当所有的用户线程结束，守护线程自动结束

常见的守护线程（垃圾回收机制）

案例
package com.tao.method;

/**
 * Create By 刘鸿涛
 * 2022/1/16 6:21
 */
public class ThreadMethod03 {
    public static void main(String[] args) throws InterruptedException {
        A a = new A();

        //目的，当main线程退出后，子线程也退出
        a.setDaemon(true);  //设置线程守护，此线程结束后，守护线程同时结束

        a.start();  //开始执行子线程

        for (int i = 1; i < 11; i++) {
            System.out.println(Thread.currentThread().getName() + "宝强在外地工作..." + i);
            Thread.sleep(1000);
        }
        Thread.sleep(3000);
        System.out.println("宝强到家了..");
    }
}
class A extends Thread{
    @Override
    public void run(){
        while(true){
            System.out.println("马蓉和宋喆在愉快的聊天...");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

线程的生命周期（重点）

请添加图片描述

JDK中用Thread.State枚举表示了线程的几种状态

线程状态，线程可以处于以下状态之一；

1.NEW

尚未启动的线程处于以下状态之一；

2.RUNNABLE（Ready - Running）

在JAVA虚拟机中执行的线程处于此状态

3.BLOCKED

被阻塞等待监视器锁定的线程处于此状态

4.WAITIN

正在等待另一个线程执行特定动作的线程处于此状态

5.TIMED WAITING

正在等待另一个线程执行动作达到指定等待时间的线程处于此状态

6.TERMINATED

已退出的线程处于此状态

案例演示

package com.tao.state_;

/**
 * Create By 刘鸿涛
 * 2022/1/16 7:27
 */
public class ThreadState_ {
    public static void main(String[] args) throws InterruptedException {
        T t = new T();
        System.out.println(t.getName() + "状态" + t.getState());
        t.start();

        while (Thread.State.TERMINATED != t.getState()){
            System.out.println(t.getName() + " 状态 " + t.getState());
            Thread.sleep(500);
        }
        System.out.println(t.getName() + " 状态 " + t.getState());
    }
}

class T extends Thread {
    @Override
    public void run(){
        for (int i = 0; i < 10; i++) {
            System.out.println("hi " + i);
            try {
                Thread.sleep(1000);
            }catch(InterruptedException e){
                e.printStackTrace();
            }
        }
    }
}

Thread-0状态NEW
Thread-0 状态 RUNNABLE
hi 0
Thread-0 状态 TIMED_WAITING
hi 1
Thread-0 状态 TIMED_WAITING
Thread-0 状态 TIMED_WAITING
hi 2
Thread-0 状态 TIMED_WAITING
Thread-0 状态 TIMED_WAITING
hi 3
Thread-0 状态 RUNNABLE
Thread-0 状态 TIMED_WAITING
hi 4
Thread-0 状态 RUNNABLE
Thread-0 状态 TIMED_WAITING
Thread-0 状态 RUNNABLE
hi 5
Thread-0 状态 TIMED_WAITING
hi 6
Thread-0 状态 RUNNABLE
Thread-0 状态 TIMED_WAITING
hi 7
Thread-0 状态 TIMED_WAITING
Thread-0 状态 TIMED_WAITING
hi 8
Thread-0 状态 TIMED_WAITING
Thread-0 状态 TIMED_WAITING
hi 9
Thread-0 状态 TIMED_WAITING
Thread-0 状态 TIMED_WAITING
Thread-0 状态 TERMINATED

Process finished with exit code 0

Synchronized（底层较为复杂）

请添加图片描述

线程同步机制

  1. 在多线程编程，一些敏感数据不允许被多个线程同时访问，此时就使用同步访问技术，保证数据在任何同一时刻，最多有一个线程访问，以保证数据的完整性

  2. 也可以这样理解：线程同步，即当有一个线程在对内存进行操作时，其他线程都不可以对这个内存地址进行操作，直到该线程完成操作，其他线程才能对该内存地址进行操作

同步具体方法

  1. 同步代码块
synchronized(对象){ //得到对象的锁，才能操作同步代码
	//需要被同步代码；
}
  1. synchronized还可以放在方法声明中，表示整个方法 - 为同步方法
public synchronized void m(String name){
	//需要被同步的代码
}
  1. 如何理解

就好像某个小伙伴上厕所前先把门关上（上锁），完事后再出来（解锁），那么其他小伙伴就可在使用厕所了，如图：

  1. 使用synchronized解决售票问题
package com.tao.ticket;

/**
 * Create By 刘鸿涛
 * 2022/1/15 4:45
 */
public class SellTicket {
    public static void main(String[] args) {
        //继承Thread
//        SellTicket01 sellTicket01 = new SellTicket01();
//        SellTicket01 sellTicket02 = new SellTicket01();
//        SellTicket01 sellTicket03 = new SellTicket01();
//        sellTicket01.start();   //启动售票线程
//        sellTicket02.start();   //启动售票线程
//        sellTicket03.start();   //启动售票线程

        //实现Runnable接口
//        SellTicket02 sellTicket02 = new SellTicket02();
//        SellTicket02 sellTicket021 = new SellTicket02();
//        SellTicket02 sellTicket022 = new SellTicket02();
//        Thread thread = new Thread(sellTicket02);
//        Thread thread1 = new Thread(sellTicket021);
//        Thread thread2 = new Thread(sellTicket022);
//        thread.start();
//        thread1.start();
//        thread2.start();

//        SellTicket02 sellTicket02 = new SellTicket02();
//        new Thread(sellTicket02).start();
//        new Thread(sellTicket02).start();
//        new Thread(sellTicket02).start();

        //sell()方法
        SellTicket03 sellTicket03 = new SellTicket03();
        new Thread(sellTicket03).start();
        new Thread(sellTicket03).start();
        new Thread(sellTicket03).start();
//        new Thread(sellTicket031).start();          //error,超卖，原因不明
//        new Thread(sellTicket032).start();        //error，超卖，原因不明
    }
}

class SellTicket01 extends Thread {
    private static int ticketNum = 100; //

    @Override
    public void run() {
        while (true) {
            if (ticketNum <= 0) {
                System.out.println("售票结束");
                break;
            }
            try {
                Thread.sleep(50);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("窗口 " + Thread.currentThread().getName() + "卖出了一张票" + "\n剩余票数：" + (--ticketNum));
        }
    }
}

//实现接口方式，使用synchronized实现线程同步
class SellTicket02 implements Runnable {
    private static int ticketNum = 100; //

    @Override
    public synchronized void run() { //同步方法，在同一时刻，只能有一个线程来执行run方法
        while (true) {
            if (ticketNum <= 0) {
                System.out.println("售票结束");
                break;
            }
            try {
                Thread.sleep(50);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("窗口 " + Thread.currentThread().getName() + "卖出了一张票" + "\n剩余票数：" + (--ticketNum));
        }
    }
}

class SellTicket03 implements Runnable {
    private static int ticketNum = 100; //
    private boolean loop = true;
    public synchronized void sell() {
        if (ticketNum <= 0) {
            System.out.println("售票结束");
            loop = false;
            return;
        }
        try {
            Thread.sleep(50);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("窗口 " + Thread.currentThread().getName() + "卖出了一张票" + "\n剩余票数：" + (--ticketNum));
    }

    @Override
    public void run() { //同步方法，在同一时刻，只能有一个线程来执行run方法
        while (loop) {
            sell();
        }
    }
}

互斥锁

基本介绍

  1. Java语言中，引入了对象互斥锁的概念，来保证共享数据操作的完整性。
  2. 每个对象都对应一个可称为“互斥锁”的标记，这个标记用来保证在任一时刻，只能有一个线程访问该对象。
  3. 关键字synchronized 来与对象的互斥锁联系。当某个对象用synchronized修饰时，表明该对象在任一时刻只能由一个线程访问
  4. 同步的局限性：导致程序的执行效率要降低
  5. 同步方法（非静态的）的锁可以使this，也可以是其他对象（要求是同一个对象）
  6. 同步方法（静态的）的锁为当前类本身

同步代码块

class SellTicket03 implements Runnable {
    private static int ticketNum = 100; //
    private boolean loop = true;

    Object object = new Object();

    //同步方法（静态的）的锁为当前类本身
    //1. public synchronized static void m1(){}  锁是加在SellTicket03.class里
    public synchronized static void m1(){

    }

    //举例
    public static void m2(){
        synchronized (SellTicket03.class) {     //静态方法为，类本身
            System.out.println("m2");
        }
    }
    public /*synchronized*/ void sell() {

        //1.public synchronized void sell(){}
        //2.这时锁在 this对象
        //3.也可以在代码块上写 synchronize ，同步代码块，互斥锁在this对象
    //同步代码块
        synchronized (/*this*/ object) {
            if (ticketNum <= 0) {
                System.out.println("售票结束");
                loop = false;
                return;
            }
            try {
                Thread.sleep(50);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("窗口 " + Thread.currentThread().getName() + "卖出了一张票" + "\n剩余票数：" + (--ticketNum));
        }
    }

    @Override
    public void run() { //同步方法，在同一时刻，只能有一个线程来执行run方法
        while (loop) {
            sell();
        }
    }
}

注意事项和细节(注意this)

  1. 同步方法如果没有使用static修饰：默认锁对象为this
  2. 如果方法使用static修饰，默认锁对象：当前类.class
  3. 实现的落地步骤：
  • 需要先分析上锁的代码
  • 选择同步代码块或同步方法
  • 要求多个线程的锁对象为同一个即可！(同一个对象)

线程的死锁

基本介绍

  • 多个线程都占用了对方的锁资源，但不肯想让，导致了死锁，在编程是一定要避免死锁的发生

应用案例

  • 妈妈：你先完成作业，才让你玩手机
  • 小明：你先让我玩手机，我才完成作业
package com.tao.syn;

/**
 * Create By 刘鸿涛
 * 2022/1/16 9:28
 */
public class DeadLock_ {
    public static void main(String[] args) {
        //模拟死锁现象
        DeadLockDemo A = new DeadLockDemo(true);
        DeadLockDemo B = new DeadLockDemo(false);
        A.start();
        B.start();

    }
}

//线程
class DeadLockDemo extends Thread {
    static Object o1 = new Object();    //保证多线程，共享一个对象，这里使用static
    static Object o2 = new Object();
    boolean flag;

    public DeadLockDemo(boolean flag){
        this.flag = flag;
    }

    public void run(){

        //下面业务逻辑的分析
        //1.如果flag为 T，线程A 就会先得到/持有 o1 对象锁，然后尝试去获取 o2 对象的锁
        //2.如果线程A 得不到 o2 对象锁，就会Blocked
        //3.如果flag为 F，线程B 就会先得到/持有 o2 对象锁，然后尝试去获取o1 对象的锁
        //4.如果线程B 得不到 o1 对象锁，就会Blocked
        if(flag){
            synchronized (o1){
                System.out.println(Thread.currentThread().getName() + "A线程进入1");
                synchronized (o2){
                    System.out.println(Thread.currentThread().getName() + "进入2");
                }
            }
        }else{
            synchronized (o2){
                System.out.println(Thread.currentThread().getName() + "B线程进入2");
                synchronized (o1){
                    System.out.println(Thread.currentThread().getName() + "进入1");
                }
            }
        }
    }
}
  • 卡死

请添加图片描述

释放锁

下面操作会释放锁

  1. 当前线程的同步方法、同步代码块执行结束
  • 案例：上厕所，完事出来
  1. 当前线程在同步代码块，同步方法中遇到break，return
  • 案例：没有正常的完事，经理叫他修改bug，不得已出来
  1. 当前线程在同步代码块、同步方法中出现了未处理的Error或Exception，导致异常结束
  • 案例：没有正常的完事，发现忘带纸，不得已出来
  1. 当前线程在同步代码块、同步方法中执行了线程对象的wait（）方法，当前程序暂停，并释放锁。
  • 案例：没有正常完事，觉得需要酝酿下，所以出来等会再进去

下面操作不会释放锁

  1. 线程执行同步代码块或同步方法时，程序调用Thread.sleep()、Thread.yield()方法暂停当前线程的执行，不会释放锁
  • 案例：上厕所，太困了，在坑位上迷了一会
  1. 线程执行同步代码块时，其他线程调用了该线程的suspend（）方法将该线程挂起，该线程不会释放锁。

提示：应尽量避免使用suspend（）和resume（）来控制线程，这两个方法不再推荐使用

课后作业（1）

1.在main方法中启动两个线程
2. 第一个线程循环随机打印100以内的整数
3. 直到第2个线程从键盘读取了“Q”命令

package com.tao.homeowrk;

import java.util.Scanner;

/**
 * Create By 刘鸿涛
 * 2022/1/17 2:50
 */
public class Homework01 {
    public static void main(String[] args) {
        A a = new A();          //A线程启动,需要对象名
        a.start();
        new B(a).start();        //B线程启动，匿名对象

    }
}

class A extends Thread {

    private boolean loop = true;

    public void setLoop(boolean loop) {
        this.loop = loop;
    }

    @Override
    public void run() {
        while (loop) {
            System.out.println("A线程" + (int) (Math.random() * 100 + 1));
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

    }
}

class B extends Thread {
        private Scanner sc = new Scanner(System.in);
    private A a;

    public B(A a) {
        this.a = a;
    }

    @SuppressWarnings({"all"})
    @Override
    public void run() {
        while (true) {
            System.out.println("B线程" + "请输入字母");
            char input = sc.next().toUpperCase().charAt(0);
            if (input == 'Q') {
                a.setLoop(false);
                System.out.println("A线程终止");
            }
        }
    }
}
//    @Override
//    public void keyTyped(KeyEvent e) {
//
//    }
//
//    @SuppressWarnings({"all"})
//    @Override
//    public void keyPressed(KeyEvent e) {
//        if (e.getKeyCode() == KeyEvent.VK_Q) {
//            a.setLoop(false);
//            System.out.println("A线程终止");
//        }
//    }
//
//    @Override
//    public void keyReleased(KeyEvent e) {
//
//    }

课后作业2

  1. 有两个用户分别从同一个卡上取钱（总额：10000）
  2. 每次都取1000，当余额不足时，就不能取款了
  3. 不能出现超取现象 => 线程同步问题。
package com.tao.homeowrk;

/**
 * Create By 刘鸿涛
 * 2022/1/17 3:47
 */
public class Homework02 {
    public static void main(String[] args) {
        C c = new C();

        Thread thread = new Thread(c);
        Thread thread1 = new Thread(c);
        thread.setName("t1");
        thread1.setName("t2");
        thread.start();
        thread1.start();

    }
}

class C implements Runnable {
    private int total = 10000;

    @Override
    public void run() {
        while (true) {
            //1.这是使用了 synchronized 实现了线程同步
            //2.当多个线程执行到这里时，就会去争夺 this对象锁
            //3.哪个线程争夺到（获取）this对象锁，就执行synchronized代码块
            //4.争夺不到this对象锁，就blocked，准备继续争夺
            synchronized (this) {       //thjs对象锁，是非公平锁
                if (total <= 999) {
                    System.out.println("余额不足");
                    break;
                }
                System.out.println(Thread.currentThread().getName() + "取了1000块，\n还剩下" + (total -= 1000));
            }
            try {
                Thread.sleep(500);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

        }

    }
}
鬼鬼骑士
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
【JAVA】-- 专题训练之坦克大战游戏（四）（实现思路+每步代码）
张修宇的博客
06-19 816
paint（）方法增加 二、复活敌方坦克 当敌方坦克数量没有时，重新生成十辆坦克paint（）方法 ，子弹循环增加 三、增加坦克血量 游戏中，己方坦克不能被一颗子弹解决，需要增加血条，增加游戏体验感。创建血条内部类，先画一个中空的方框，然后通过计算剩余血量填充方框。 draw方法增加 子弹类增加/修改 hitTank方法修改增加己方坦克判断条件，血量小于0则死亡。 主类增加 draw方法增加 四、增加血包功能 当己方坦克掉血后，可以通过捡取血包恢复血量。先创建一
java之坦克大战
weixin_42063820的博客
06-20 678
1.初始化坦克的模型： （两个矩形，一个正方形，一个圆形，一条直线） 并且坦克有设计的行为： 核心代码： 2.当击中敌方坦克的时候，敌方坦克消失，并有一个爆炸效果 界面看到的动态效果，其实是不断的重绘界面所展示的，所以先让这个窗口实现Runnable接口，然后当程序启动的时候，隔着一定时间不断的重绘界面 当击中敌军的时候，敌军消失，并产生爆炸效果： 先记录爆炸的位置，然后给爆炸的这个类一个生命周期，不同时间阶段展示不同图片，因为主窗口是不断的重绘，时间间隙不大的情况下，这就展示出了爆炸效果。 使用一
java多线程实现坦克大战游戏带声音图片
09-15
Java是一门面向对象编程语言，不仅吸收了C++语言的各种优点，还摒弃了C++里难以理解的多继承、指针等概念，因此Java语言具有功能强大和简单易用两个特征。
java+多线程+界面编程+事件监听+坦克大战Java源码.
07-08
java+多线程+界面编程+事件监听+坦克大战Java源码.
java坦克大战源码，深入理解java多线程，和线程的生命周期
lb87626的博客
05-09 571
这是很多年前写的，坦克大战，对理解java有很好的帮助，尤其是多线程。每一个线程都是一个生命，包括坦克的出生到被打死，还有炮弹的。源码在后面有公布。 这个是个单机版游戏，可以进行存档，记录分数等基本功能。 初始化界面 游戏进行中 粉色坦克是敌军坦克，黄色坦克是自己，每打掉一个坦克分数会加1，打完所有敌军坦克后进入下一局，打更多的坦克。 按下键盘上W S A D键分别表示上下左右运动键，K键表示发射炮弹。 话说我为了截这个坦克被打掉的图费了老大的力气。 打掉敌军4个坦克 代码太多，这里只贴部分代码了，
Java大作业-坦克世界大战
06-23
《Java大作业-坦克世界大战》是一款基于Java编程语言开发的简单游戏，它展示了Java在图形用户界面（GUI）和游戏开发方面的应用。这个项目旨在帮助学习者掌握Java编程的基本概念，包括对象导向编程、事件处理、图形...
Java 第16章 坦克大战1 思路整理
最新发布
12-24
在本章中，我们将深入探讨Java编程语言在...通过这个章节的学习，你将能够掌握使用Java编程语言创建坦克大战游戏的基本技术和思维方式，这将对你的Java编程能力有极大的提升，并为将来开发更复杂的游戏打下坚实的基础。
Java版坦克大战源码
09-13
2. **图形用户界面(GUI)**：Java坦克大战通常使用Java Swing或JavaFX库来创建游戏界面。这些库提供了丰富的组件（如JPanel、JButton等）用于构建游戏画面和交互元素。你需要理解如何布局组件、响应用户事件，并绘制...
体验我们的第一个项目-坦克大战
11-16
【坦克大战】是一款经典的JAVA游戏编程入门项目，旨在帮助初学者快速掌握JAVA编程基础和基本的游戏编程概念。通过参与这个游戏的开发，学习者可以克服对编程的恐惧，提高编程兴趣。 【基础知识】： 1. **JAVA编程...
java实现坦克大战游戏
12-03
《Java实现坦克大战游戏》 在软件开发领域，Java作为一种多平台、面向对象的编程语言，因其强大的功能和跨平台特性而备受青睐。本项目是一个基于Java实现的坦克大战游戏，它不仅展示了Java语言的强大能力，还融入了...
JAVA（坦克大战，多线程管理）.rar
01-28
JAVA（坦克大战，多线程管理）.rar
java+多线程+界面编程+事件监听+坦克大战源码整理
08-21
java+多线程+界面编程+事件监听+坦克大战源码整理
Java基础 - 坦克大战（第三章，线程基础与线程使用）
qq_39123467的博客
01-15 464
想让敌方坦克动起来并没有那么容易，这就要看你是想学知识，还是想抄代码
全面战争JAVA_Java__线程---基础知识全面实战---坦克大战系列为例
weixin_36240219的博客
02-18 280
1 packageTankGame5;23 import java.awt.*;4 importjava.awt.event.ActionEvent;5 importjava.awt.event.ActionListener;6 importjava.awt.event.KeyEvent;7 importjava.awt.event.KeyListener;8 importjava.io.Buff...
用 Java 实现坦克大战，这个有点强了!
JavaMBa的博客
05-26 1360
在Java开发中，坦克大战项目和23种设计模式无疑是经典中的经典，就算是开发5年甚至是10年以上的开发者，都不敢说自己真真实实掌握了23种设计模式，希望大家能够好好学习，并且能够掌握这些细节性的东西。 坦克大战项目 坦克大战项目通过一个联机对战游戏的手把手，一行一行的开发过程，让你精准的理解和运用JavaSE，DesignPatterns , TCP/IP, 多线程, NIO等基础知识。真正理解项目的开发过程，并体会项目开发的难点和痛点。 请记住，只有做项目，才是对所学的真正检验。 坦...
JAVA笔记（二十三）：坦克大战【二】（线程---子弹发射 / 敌人坦克自发移动 / 坦克与子弹消失、Vector集合---多线程对象存储、图片导入与绘制）
欢迎~
07-26 530
线程 - 应用到坦克大战 一、坦克大战3.0版本 1、增强功能 用户按下J键，我方坦克发射一颗子弹 2、思路 3、实现代码 Shot类 ① 发射相当于一个子功能，且需要不断发射，所以当作一个线程 --> 实现Runnable ② 在run方法中是实现子弹移动–>需要子弹方向direct ③ 且需要不停地自动移动–>while(true)控制 -->在碰壁时退出循环 ④ 必须休眠，不然会导致还没有重绘，子弹就碰壁销毁 //把发射作为一个线程 public class Shot
java坦克大战练习。java基础项目。巩固java基础部分。
igg08的博客
07-28 225
java坦克大战小游戏。java初学者练手项目
坦克大战
ding7530的博客
09-01 98
　　emmm，又无聊写了一点坦克大战（未完成），写着写着我发现可能得需要用多线程，不然不能一边移动一边发射子弹，也可能是我没想到好办法 = =，然后关于机器人，我有点想正好试试机器学习算法来训练机器人，但目前还不知道该从何入手，比如，该获得什么样的数据集来训练，我还没想好。效果： 　　与之前贪吃蛇一样，我都用`SetPos()`来指定光标在控制台的位置，我不用`system('cl...
坦克大战（基于java线程）
Noob的博客
11-19 2908
坦克大战（基于java线程）坦克大战是继五子棋后的新项目，基于java的图形化界面以及多线程来实现，主要是锻炼javaSE的基本能力
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

鬼鬼骑士

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值