小游戏-------------潜艇大战

已于 2022-09-09 12:27:37 修改
阅读量1.4k 收藏 6
点赞数 1
文章标签： java 开发语言
于 2022-09-09 11:34:35 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_62448963/article/details/126777392
版权

<--第一天   -->

潜艇游戏----潜艇大战图片

列表

  1. 创建战舰类、侦察潜艇类、鱼雷潜艇类、水雷潜艇类、水雷类、深水炸弹类，设计类中的成员变量和move()方法

  2. 创建World类，在main中：创建1个战舰对象、至少2个侦察潜艇对象、2个鱼雷潜艇对象、2个水雷潜艇对象、2个水雷对象、2个深水炸弹对象，并给属性赋值，调用方法测试

参考

  1. 创建战舰类、侦察潜艇类、鱼雷潜艇类、水雷潜艇类、水雷类、深水炸弹类，设计类中的成员变量和move()方法

    参考代码：

package day01;
//战舰
public class Battleship {
    int width;
    int height;
    int x;
    int y;
    int speed;
    int life;

    void move(){
        System.out.println("战舰移动");
    }
}
package day01;
//侦察潜艇
public class ObserveSubmarine {
    int width;
    int height;
    int x;
    int y;
    int speed;
    void move(){
        System.out.println("侦察潜艇x向右移动");
    }
}
package day01;
//鱼雷潜艇
public class TorpedoSubmarine {
    int width;
    int height;
    int x;
    int y;
    int speed;
    void move(){
        System.out.println("鱼雷潜艇x向右移动");
    }
}
package day01;
//水雷潜艇
public class MineSubmarine {
    int width;
    int height;
    int x;
    int y;
    int speed;
    void move(){
        System.out.println("水雷潜艇x向右移动");
    }
}
package day01;
//水雷
public class Mine {
    int width;
    int height;
    int x;
    int y;
    int speed;
    void move(){
        System.out.println("水雷y向上移动");
    }
}
package day01;
//深水炸弹
public class Bomb {
    int width;
    int height;
    int x;
    int y;
    int speed;
    void move(){
        System.out.println("深水炸弹y向下移动");
    }
}

2.创建World类，在main中：创建1个战舰对象、至少2个侦察潜艇对象、2个鱼雷潜艇对象、2个水雷潜艇对象、2个水雷对象、2个深水炸弹对象，并给属性赋值，调用方法测试

 参考代码：

package day01;
/** 整个游戏世界 */
public class World {
    public static void main(String[] args) {
        Battleship s = new Battleship();
        s.width = 50;
        s.height = 30;
        s.x = 100;
        s.y = 200;
        s.speed = 20;
        s.life = 5;
        System.out.println(s.width+","+s.height+","+s.x+","+s.y+","+s.speed+","+s.life);
        s.move();

        ObserveSubmarine os1 = new ObserveSubmarine();
        os1.width = 30;
        os1.height = 40;
        os1.x = 200;
        os1.y = 400;
        os1.speed = 3;
        System.out.println(os1.width+","+os1.height+","+os1.x+","+os1.y+","+os1.speed);
        os1.move();

        ObserveSubmarine os2 = new ObserveSubmarine();
        os2.width = 30;
        os2.height = 40;
        os2.x = 100;
        os2.y = 450;
        os2.speed = 3;
        System.out.println(os2.width+","+os2.height+","+os2.x+","+os2.y+","+os2.speed);
        os2.move();

        TorpedoSubmarine ts1 = new TorpedoSubmarine();
        TorpedoSubmarine ts2 = new TorpedoSubmarine();
        MineSubmarine ms1 = new MineSubmarine();
        MineSubmarine ms2 = new MineSubmarine();
        Mine m1 = new Mine();
        Mine m2 = new Mine();
        Bomb b1 = new Bomb();
        Bomb b2 = new Bomb();
    }
}

 <--第二天   -->

列表：

  1. 给战舰类、侦察潜艇类、鱼雷潜艇类、水雷潜艇类、水雷类、深水炸弹类添加构造方法

  2. 在main中：创建1个战舰对象、至少4个侦察潜艇对象、2个鱼雷潜艇对象、2个水雷潜艇对象、2个水雷对象、2个深水炸弹对象，测试

参考：

        1.给战舰类、侦察潜艇类、鱼雷潜艇类、水雷潜艇类、水雷类、深水炸弹类，添加构造方法

参考代码：

package day02;
//战舰
public class Battleship {
    int width;
    int height;
    int x;
    int y;
    int speed;
    int life;
    Battleship(){
        width = 66;
        height = 26;
        x = 270;
        y = 124;
        speed = 2;
        life = 5;
    }

    void move(){
        System.out.println("战舰移动");
    }
}

package day02;
import java.util.Random;
//侦察潜艇
public class ObserveSubmarine {
    int width;
    int height;
    int x;
    int y;
    int speed;
    ObserveSubmarine(){
        width = 63;
        height = 19;
        x = -width;
        Random rand = new Random();
        y = rand.nextInt(479-height-150+1)+150;
        speed = rand.nextInt(3)+1;
    }
    void move(){
        System.out.println("侦察潜艇x向右移动");
    }
}

package day02;
import java.util.Random;
//鱼雷潜艇
public class TorpedoSubmarine {
    int width;
    int height;
    int x;
    int y;
    int speed;
    TorpedoSubmarine(){
        width = 64;
        height = 20;
        x = -width;
        Random rand = new Random();
        y = rand.nextInt(479-height-150+1)+150;
        speed = rand.nextInt(3)+1;
    }
    void move(){
        System.out.println("鱼雷潜艇x向右移动");
    }
}

package day02;
import java.util.Random;
//水雷潜艇
public class MineSubmarine {
    int width;
    int height;
    int x;
    int y;
    int speed;
    MineSubmarine(){
        width = 63;
        height = 19;
        x = -width;
        Random rand = new Random();
        y = rand.nextInt(479-height-150+1)+150;
        speed = rand.nextInt(3)+1;
    }
    void move(){
        System.out.println("水雷潜艇x向右移动");
    }
}

package day02;
//水雷
public class Mine {
    int width;
    int height;
    int x;
    int y;
    int speed;
    Mine(int x,int y){
        width = 11;
        height = 11;
        this.x = x;
        this.y = y;
        speed = 1;
    }
    void move(){
        System.out.println("水雷y向上移动");
    }
}

package day02;
//深水炸弹
public class Bomb {
    int width;
    int height;
    int x;
    int y;
    int speed;
    Bomb(int x,int y){
        width = 9;
        height = 12;
        this.x = x;
        this.y = y;
        speed = 3;
    }

    void move(){
        System.out.println("深水炸弹y向下移动");
    }
}

//注:其余类没有变化，此处省略

2.在main中：创建1个战舰对象、至少4个侦察潜艇对象、2个鱼雷潜艇对象、2个水雷潜艇对象、2个水雷对象、2个深水炸弹对象，测试

package day02;
/** 整个游戏世界 */
public class World {
    public static void main(String[] args) {
        Battleship s = new Battleship();
        ObserveSubmarine os1 = new ObserveSubmarine();
        ObserveSubmarine os2 = new ObserveSubmarine();
        ObserveSubmarine os3 = new ObserveSubmarine();
        ObserveSubmarine os4 = new ObserveSubmarine();
        TorpedoSubmarine ts1 = new TorpedoSubmarine();
        TorpedoSubmarine ts2 = new TorpedoSubmarine();
        MineSubmarine ms1 = new MineSubmarine();
        MineSubmarine ms2 = new MineSubmarine();
        Mine m1 = new Mine(123,345);
        Mine m2 = new Mine(345,234);
        Bomb b1 = new Bomb(200,300);
        Bomb b2 = new Bomb(300,400);
        //最少输出4个对象的数据(一定要包括2个侦察潜艇的数据)
        System.out.println(s.width+","+s.height+","+s.x+","+s.y+","+s.speed+","+s.life);
 System.out.println(os1.width+","+os1.height+","+os1.x+","+os1.y+","+os1.speed);
 System.out.println(os2.width+","+os2.height+","+os2.x+","+os2.y+","+os2.speed);
 System.out.println(os3.width+","+os3.height+","+os3.x+","+os3.y+","+os3.speed);
 System.out.println(os4.width+","+os4.height+","+os4.x+","+os4.y+","+os4.speed);

    }
}

//注:其余类没有变化，此处省略

 <--第三天   -->

列表：

  1. 创建侦察艇数组、鱼雷艇数组、水雷艇数组、水雷数组、深水炸弹数组，并填充数据，遍历数组输出坐标并调用move()方法测试

  2. 创建SeaObject超类，设计6个类继承超类

  3. 在SeaObject中设计两个构造方法，一个是为三种潜艇提供的，一个是为战舰、水雷、深水炸弹提供的，6个类分别调用超类的构造方法

  4. 将侦察艇数组、鱼雷艇数组、水雷艇数组统一组合为SeaObject数组，给数组填充数据，遍历数组输出属性并调用move()方法

参考：

  1. 创建侦察艇数组、鱼雷艇数组、水雷艇数组、水雷数组、深水炸弹数组，并填充数据，遍历数组输出坐标并调用move()方法测试

    参考代码：

package day03;
/** 整个游戏世界 */
public class World {
    public static void main(String[] args) {
        ObserveSubmarine[] oses = new ObserveSubmarine[3];
        TorpedoSubmarine[] tses = new TorpedoSubmarine[2];
        MineSubmarine[] mses = new MineSubmarine[3]; //水雷潜艇数组
        mses[0] = new MineSubmarine();
        mses[1] = new MineSubmarine();
        mses[2] = new MineSubmarine();
        for(int i=0;i<mses.length;i++){ //遍历所有水雷潜艇
            System.out.println(mses[i].x+","+mses[i].y); //输出每个水雷潜艇的x和y坐标
            mses[i].move(); //每个水雷潜艇移动
        }

        Mine[] ms = new Mine[2]; //水雷数组
        ms[0] = new Mine(100,200);
        ms[1] = new Mine(200,400);
        for(int i=0;i<ms.length;i++){
            System.out.println(ms[i].x+","+ms[i].y);
            ms[i].move();
        }
        Bomb[] bs = new Bomb[2];

    }
}

//注:其余类没有变化，此处省略

 2.创建SeaObject超类，设计6个类继承超类

参考代码：

package day03;
import java.util.Random;
//海洋对象
public class SeaObject {
    int width;
    int height;
    int x;
    int y;
    int speed;
    void move(){
        System.out.println("海洋对象移动");
    }
}

package day03;
//战舰
public class Battleship extends SeaObject {
    int life;
    Battleship(){
        width = 66;
        height = 26;
        x = 270;
        y = 124;
        speed = 20;
        life = 5;
    }
}

package day03;
import java.util.Random;
//侦察潜艇
public class ObserveSubmarine extends SeaObject {
    ObserveSubmarine(){
        width = 63;
        height = 19;
        x = -width;
        Random rand = new Random();
        y = rand.nextInt(479-height-150+1)+150;
        speed = rand.nextInt(3)+1;
    }
}

package day03;
import java.util.Random;
//鱼雷潜艇
public class TorpedoSubmarine extends SeaObject {
    TorpedoSubmarine(){
        width = 64;
        height = 20;
        x = -width;
        Random rand = new Random();
        y = rand.nextInt(479-height-150+1)+150;
        speed = rand.nextInt(3)+1;
    }
}

package day03;
import java.util.Random;
//水雷潜艇
public class MineSubmarine extends SeaObject {
    MineSubmarine(){
        width = 63;
        height = 19;
        x = -width;
        Random rand = new Random();
        y = rand.nextInt(479-height-150+1)+150;
        speed = rand.nextInt(3)+1;
    }
}

package day03;
//水雷
public class Mine extends SeaObject {
    Mine(int x,int y){
        width = 11;
        height = 11;
        this.x = x;
        this.y = y;
        speed = 1;
    }
}

package day03;
//深水炸弹
public class Bomb extends SeaObject {
    Bomb(int x,int y){
        width = 9;
        height = 12;
        this.x = x;
        this.y = y;
        speed = 3;
    }
}

//注:其余类没有变化，此处省略

3.在SeaObject中设计两个构造方法，一个是为三种潜艇提供的，一个是为战舰、水雷、深水炸弹提供的，6个类分别调用超类的构造方法

参考代码：

package day03;
import java.util.Random;
//海洋对象
public class SeaObject {
    int width;
    int height;
    int x;
    int y;
    int speed;
    /** 专门给三种潜艇提供的 */
    SeaObject(int width,int height){
        this.width = width;
        this.height = height;
        x = -width;
        Random rand = new Random();
        y = rand.nextInt(479-height-150+1)+150;
        speed = rand.nextInt(3)+1;
    }
    /** 专门给战舰、水雷、深水炸弹提供的 */
    SeaObject(int width,int height,int x,int y,int speed){
        this.width = width;
        this.height = height;
        this.x = x;
        this.y = y;
        this.speed = speed;
    }

    void move(){
        System.out.println("海洋对象移动");
    }
}

package day03;
//侦察潜艇
public class ObserveSubmarine extends SeaObject {
    ObserveSubmarine(){
        super(63,19);
    }
}

package day03;
//鱼雷潜艇
public class TorpedoSubmarine extends SeaObject {
    TorpedoSubmarine(){
        super(64,20);
    }
}

package day03;
//水雷潜艇
public class MineSubmarine extends SeaObject {
    MineSubmarine(){
        super(63,19);
    }
}

package day03;
//战舰
public class Battleship extends SeaObject {
    int life;
    Battleship(){
        super(66,26,270,124,20);
        life = 5;
    }
}

package day03;
//水雷
public class Mine extends SeaObject {
    Mine(int x,int y){
        super(11,11,x,y,1);
    }
}

package day03;
//深水炸弹
public class Bomb extends SeaObject {
    Bomb(int x,int y){
        super(9,12,x,y,3);
    }
}

//注:其余类没有变化，此处省略

4.将侦察艇数组、鱼雷艇数组、水雷艇数组统一组合为SeaObject数组，给数组填充数据，遍历数组输出属性并调用move()方法

参考代码：

package day04;
//整个游戏世界
public class World {
    public static void main(String[] args) {
        SeaObject[] submarines = new SeaObject[5]; //潜艇(侦察潜艇、鱼雷潜艇、水雷潜艇)
        submarines[0] = new ObserveSubmarine();
        submarines[1] = new ObserveSubmarine();
        submarines[2] = new TorpedoSubmarine();
        submarines[3] = new TorpedoSubmarine();
        submarines[4] = new MineSubmarine();
        for(int i=0;i<submarines.length;i++){
            SeaObject s = submarines[i];
            System.out.println(s.x+","+s.y);
            s.move();
        }

        Battleship s = new Battleship();

        Mine[] mines = new Mine[2];
        mines[0] = new Mine(100,200);
        mines[1] = new Mine(200,400);
        for(int i=0;i<mines.length;i++){
            Mine m = mines[i];
            System.out.println(m.x+","+m.y);
            m.move();
        }

        Bomb[] bombs = new Bomb[2];
        bombs[0] = new Bomb(100,200);
        bombs[1] = new Bomb(200,400);
        for(int i=0;i<bombs.length;i++){
            Bomb b = bombs[i];
            System.out.println(b.x+","+b.y);
            b.move();
        }
    }
}

//注:其余类没有变化，此处省略

<--第四天-->

列表：

  1. 在6个类中重写move()移动方法，实现对象的具体移动，并测试

  2. 给所有类中的成员添加访问控制修饰符

  3. 设计Images图片类，设计战舰图片、侦察潜艇图片、鱼雷潜艇图片、水雷潜艇图片、水雷图片、深水炸弹图片、海洋图片、游戏结束图片，并在静态块中赋值，设计main方法测试图片是否读取成功

参考：

  1. 在6个类中重写move()移动方法，实现对象的具体移动，并测试

    参考代码：

package day04;
//战舰
public class Battleship extends SeaObject {
    int life;
    Battleship(){
        super(66,26,270,124,20);
        life = 5;
    }
    void move(){
        //暂时搁置
    }
}

package day04;
//侦察潜艇
public class ObserveSubmarine extends SeaObject {
    ObserveSubmarine(){
        super(63,19);
    }
    void move(){
        x+=speed;
    }
}

package day04;
//鱼雷潜艇
public class TorpedoSubmarine extends SeaObject {
    TorpedoSubmarine(){
        super(64,20);
    }
    void move(){
        x+=speed;
    }
}

package day04;
//水雷潜艇
public class MineSubmarine extends SeaObject {
    MineSubmarine(){
        super(63,19);
    }
    void move(){
        x+=speed;
    }
}

package day04;
//水雷
public class Mine extends SeaObject {
    Mine(int x,int y){
        super(11,11,x,y,1);
    }
    void move(){
        y-=speed;
    }
}

package day04;
//深水炸弹
public class Bomb extends SeaObject {
    Bomb(int x,int y){
        super(9,12,x,y,3);
    }
    void move(){
        y+=speed;
    }
}

package day04;
/** 整个游戏窗口 */
public class World {
    public static void main(String[] args) {
        SeaObject[] submarines = new SeaObject[5]; //潜艇数组
        submarines[0] = new ObserveSubmarine(); //向上造型
        submarines[1] = new ObserveSubmarine();
        submarines[2] = new TorpedoSubmarine();
        submarines[3] = new TorpedoSubmarine();
        submarines[4] = new MineSubmarine();
        for(int i=0;i<submarines.length;i++){ //遍历所有潜艇
            System.out.println("第"+(i+1)+"个潜艇:");
            SeaObject s = submarines[i]; //获取每一个潜艇
            System.out.println("初始的坐标:"+s.x+","+s.y);
            s.move(); //移动
            System.out.println("移动后坐标:"+s.x+","+s.y); //移动后坐标
        }

        Mine[] mines = new Mine[4];
        mines[0] = new Mine(100,200);
        mines[1] = new Mine(110,120);
        mines[2] = new Mine(130,140);
        mines[3] = new Mine(140,150);
        for(int i=0;i<mines.length;i++){ //遍历所有水雷
            System.out.println("第"+(i+1)+"个水雷:");
            Mine m = mines[i];  //获取每一个水雷
            System.out.println("初始的坐标:"+m.x+","+m.y);
            m.move();
            System.out.println("移动后坐标:"+m.x+","+m.y);
        }

        Bomb[] bombs = new Bomb[2];
        bombs[0] = new Bomb(100,200);
        bombs[1] = new Bomb(200,185);
        for(int i=0;i<bombs.length;i++){
            System.out.println("第"+(i+1)+"个深水炸弹:");
            Bomb b = bombs[i];
            System.out.println("初始的坐标:"+b.x+","+b.y);
            b.move();
            System.out.println("移动后坐标:"+b.x+","+b.y);
        }
    }
}

//注:其余类没有变化，此处省略

 2.给所有类中的成员添加访问控制修饰符

参考代码：

package day05;
import java.util.Random;
//海洋对象
public class SeaObject {
    protected int width;
    protected int height;
    protected int x;
    protected int y;
    protected int speed;
    public SeaObject(int width,int height){
        this.width = width;
        this.height = height;
        x = -width;
        Random rand = new Random();
        y = rand.nextInt(479-height-150+1)+150;
        speed = rand.nextInt(3)+1;
    }
    public SeaObject(int width,int height,int x,int y,int speed){
        this.width = width;
        this.height = height;
        this.x = x;
        this.y = y;
        this.speed = speed;
    }

    public void move(){
        System.out.println("海洋对象移动");
    }
}

package day05;
//战舰
public class Battleship extends SeaObject {
    private int life;
    public Battleship(){
        super(66,26,270,124,20);
        life = 5;
    }
    public void move(){
        //暂时搁置
    }
}

package day05;
//侦察潜艇
public class ObserveSubmarine extends SeaObject {
    public ObserveSubmarine(){
        super(63,19);
    }
    public void move(){
        x+=speed;
    }
}

package day05;
//鱼雷潜艇
public class TorpedoSubmarine extends SeaObject {
    public TorpedoSubmarine(){
        super(64,20);
    }
    public void move(){
        x+=speed;
    }
}

package day05;
//水雷潜艇
public class MineSubmarine extends SeaObject {
    public MineSubmarine(){
        super(63,19);
    }
    public void move(){
        x+=speed;
    }
}

package day05;
//水雷
public class Mine extends SeaObject {
    public Mine(int x,int y){
        super(11,11,x,y,1);
    }
    public void move()
最低0.47元/天 解锁文章
懂Java的懒阳阳
关注
  • 1
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
面向对象实战（潜艇大战小游戏）
weixin_68893669的博客
12-07 894
潜艇大战小游戏
基于java+swing的潜艇大战项目游戏(java+swing)
m0_68307698的博客
03-28 1859
基于java+swing的潜艇大战项目游戏(java+swing) 功能简介： Java swing实现的一款小游戏潜艇大战的项目源码 适用 课程设计，大作业，毕业设计，项目练习，学习演示等 boolean isScv = (tile.getType()==gridMapRender.getCurrentType()) &&(tile instanceof Scv); if(isScv){ tile.focus();
基于JavaSwing开发潜艇大战小游戏 课程设计 大作业源码
QQ2892034822的博客
04-03 169
基于JavaSwing开发潜艇大战小游戏： （大作业）基于JavaSwing开发潜艇大战小游戏： （大作业）基于JavaSwing开发潜艇大战小游戏： （大作业）基于JavaSwing开发潜艇大战小游戏： （大作业）基于JavaSwing开发潜艇大战小游戏： （大作业）基于JavaSwing开发潜艇大战小游戏： （大作业）基于JavaSwing开发潜艇大战小游戏： （大作业）基于JavaSwing开发潜艇大战小游戏： （大作业）基于JavaSwing开发潜艇大战小游戏： （大作业）
潜艇大战 C语言实现
08-18
潜艇大战演示程序及源代码_C++小游戏源代码(已验证潜艇大战C语言游戏代码)，案例学习好帮手
VB潜艇射击游戏：潜艇大战.rar
07-10
VB潜艇射击游戏：潜艇大战完整源码，以前很火的单机休闲游戏，现在搞程序开发了，突然有了想写一个潜艇大战的想法，索引就写成这样了，有兴趣的大家一起切磋。
VS C++黑框框小游戏--潜艇大战
08-19
Visual Studio 2013 编程环境下编写的一个C++黑框框小游戏，界面简陋，功能简单，不设多个关卡，有奖励机制，有排行榜。
java小游戏-潜艇大战
05-04
这是一个射击游戏，模仿PC上的“潜艇大战”游戏开发的手机版本。我方控制的军舰可以释放炸弹，攻击海底下有各种各样的敌人潜艇。整个游戏有时间限制，攻击敌人潜艇成功可获得增加时间奖励。
潜艇大战源程序，潜艇游戏VC 源代码.rar
07-09
潜艇大战游戏VC 源代码，不能不说的一款游戏，在90时代风靡全球的小游戏，在Windows中，甚至自带有潜艇大战。其源代码在99年已经公布，纯C 代码编写，通过学习本款代码，让您学会编写潜艇大战游戏是将要的，更重要的...
潜艇大战（包含完整代码）
08-02
java入门级别的小项目
易语言qt源码,易语言潜艇大战
07-16
易语言潜艇大战源码,潜艇大战,显示潜艇,爆炸,发射子弹,投炸弹,移除炸弹,移除全部炸弹,移除全部子弹,移除全部潜艇,移除子弹,加入潜艇,移除潜艇,初始化,水平移动图,垂直移动图
潜艇大战（游戏）
09-10
潜艇大战（游戏）
Java 潜艇大战源码.rar
07-10
Java 潜艇大战源码，手机游戏版本的JAVA潜艇大战，j2me游戏源码。
潜艇大战小游戏（面向对象练习）
03-26
潜艇游戏需求: 1.所参与的角色:战舰、深水炸弹、侦察潜艇、鱼雷潜艇、水雷潜艇、鱼雷、水雷 2.角色间的关系: 1)战舰发射深水炸弹 2)深水炸弹打潜艇(侦察潜艇、鱼雷潜艇、水雷潜艇)，若打中: 2.1)深水炸弹消失、潜艇消失 2.2)若打中的是侦察潜艇，则玩家得10分 若打中的是鱼雷潜艇，则玩家得40分 若打中的是水雷潜艇，则战舰得1条命 3)鱼雷潜艇发射鱼雷，鱼雷打战舰，若打中: 3.1)鱼雷消失 3.2)战舰减1条命(命数为0即游戏结束) 4)水雷潜艇发射水雷，水雷打战舰，若打中: 4.1)水雷消失 4.2)战舰减1条命(命数为0则游戏结束)
java源码包---java 源码 大量 实例
04-18
内容索引:JAVA源码,游戏娱乐,魔方,网页游戏 　Java编写的网页版魔方游戏，编译后生成.class文件，然后用HTML去调用，不过运行时候需要你的浏览器安装有运行Class的插件。Java源代码实现部分，比较有意思，也具参考性...
潜艇大战代码改动版
m0_46273014的博客
10-23 364
【代码】潜艇大战代码改动版。
JAVA潜艇大战小游戏源码
11-14
本游戏为Java awt 和 swing组件模拟的休闲小游戏《潜艇大战》。玩家通过操作军舰向水下的鱼雷扔炸弹水下潜艇向上发射鱼雷，此版本加入了一些UI处理，比较流畅。很不错哦！网络收集到的分享啦！
潜艇大战游戏C语言源代码
03-12
潜艇大战游戏，源代码。有具体注释，很容易看谁能懂。
2017-q3_trip
最新发布
10-01
我还参加了一些水上活动，如潜水和划皮划艇。在普吉岛，我感受到了与大自然的亲密接触和平静。 总的来说，2017年第三季度的旅行是我人生中一段难忘的经历。我通过这次旅行更加了解了泰国的文化和美丽的风景。这次...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值