JSD-2204-面向对象-静态-访问修饰符-潜艇游戏--Day11

最新推荐文章于 2024-08-09 09:53:08 发布
最新推荐文章于 2024-08-09 09:53:08 发布
阅读量304 收藏
点赞数
文章标签： 游戏 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/TheNewSystrm/article/details/124806503
版权

1. 面向对象

1.1 package和import：

  • package：声明包
    • 作用：为了避免类的命名冲突
    • 同包中的类不能同名，但不同包中的类可以同名
    • 类的全称：包名.类名，包名常常有层次结构
    • 建议：包名所有字母都小写
  • import：导入类
    • 同包中的类可以直接访问，但不能包中的类不能直接访问，若想访问：
      • 先import导入类再访问类------建议
      • 类的全称----------------------------太繁琐，不建议

1.2.访问控制修饰符：-----------保护数据的安全

  • public：公开的，任何类
  • private：私有的，本类
  • protected：受保护的，本类、派生类、同包类
  • 默认的：什么也不写，本类、同包类--------------------------------不建议
  • 注意：
  •  1. 类的访问权限只能是public或默认的
  •  2. 类中成员的访问权限如上4种都可以
   package ooday05;
   //访问控制修饰符的演示
   public class Aoo {
       public int a;    //任何类
       protected int b; //本类、派生类、同包类
       int c;           //本类、同包类
       private int d;   //本类
   
       void show(){
           a = 1;
           b = 2;
           c = 3;
           d = 4;
       }
   }
   
   class Boo{ //---------------------演示private
       void show(){
           Aoo o = new Aoo();
           o.a = 1;
           o.b = 2;
           o.c = 3;
           //o.d = 4; //编译错误
       }
   }
   
   package ooday05_vis;
   import ooday05.Aoo;
   public class Coo { //--------------演示同包的
       void show(){
           Aoo o = new Aoo();
           o.a = 1;
           //o.b = 2; //编译错误
           //o.c = 3; //编译错误
           //o.d = 4; //编译错误
       }
   }
   
   class Doo extends Aoo{ //跨包继承------演示protected
       void show(){
           a = 1;
           b = 2;
           //c = 3; //编译错误
           //d = 4; //编译错误
       }
   }

1.3final：最终的、不可改变的----------单独应用几率低

  • 修饰变量：变量不能被改变 
     class Eoo{
         final int num = 5;
         void show(){
             //num = 55; //编译错误，final的变量不能被改变
         }
     }
  •  修饰方法：方法不能被重写
     //演示final修饰方法
     class Foo {
         final void show(){}
         void test(){}
     }
     class Goo extends Foo{
         //void show(){} //编译错误，final的方法不能被重写
         void test(){}
     }
  • 修饰类：类不能被继承
     //演示final修饰类
     final class Hoo{}
     //class Ioo extends Hoo{} //编译错误，final的类不能被继承
     class Joo{}
     final class Koo extends Joo{} //正确，不能当老爸，但能当儿子

1.4static：静态的

  • 静态变量：
    • 由static修饰
    • 属于类，存储在方法区中，只有一份
    • 常常通过类名点来访问
    • 何时用：所有对象所共享的数据(图片、音频、视频等)
     class Loo{
         int a; //实例变量
         static int b; //静态变量
         Loo(){
             a++;
             b++;
         }
         void show(){
             System.out.println("a="+a+"，b="+b);
         }
     }
     
     public class StaticDemo {
         public static void main(String[] args) {
             Loo o1 = new Loo();
             o1.show();
             Loo o2 = new Loo();
             o2.show();
             Loo o3 = new Loo();
             o3.show();
             System.out.println(Loo.b); //常常通过类名点来访问
         }
     }
  •  静态方法：
    • 由static修饰
    • 属于类，存储在方法区中，只有一份
    • 常常通过类名点来访问
    • 静态方法中没有隐式this传递，所以不能直接访问实例成员，只能直接访问静态成员
    • 何时用：方法的操作与对象无关(不需要操作对象的数据)
     class Moo{
         int a; //实例变量(对象点来访问)
         static int b; //静态变量(类名点来访问)
     
         void show(){ //有隐式this
             System.out.println(this.a);
             System.out.println(Moo.b);
         }
         static void test(){ //没有隐式this
             //静态方法没有隐式this传递
             //没有this就意味着没有对象
             //而实例变量a必须由对象点来访问
             //所以如下语句发生编译错误
             //System.out.println(a); //编译错误
             System.out.println(Moo.b);
         }
     }
     
     //演示静态方法何时用
     class Noo{
         int a; //实例变量(描述对象的属性)
         //在show()中访问对象的属性a了，说明show()与对象有关，不能设计为静态方法
         void show(){
             System.out.println(a);
         }
         //在plus()中并没有访问对象的属性，说明plus()与对象无关，可以设计为静态方法
         static int plus(int num1,int num2){
             int num = num1+num2;
             return num;
         }
     }
     
     public class StaticDemo {
         public static void main(String[] args) {
             Moo.test(); //常常通过类名点来访问
         }
     }

1.5静态代码块：

  • 由static修饰
  • 属于类，在类被加载期间自动执行，一个类只被加载一次，所以静态块只执行一次
  • 何时用：初始化/加载静态资源(图片、音频、视频等)
     //演示静态块
     class Poo{
         static{
             System.out.println("静态块");
         }
         Poo(){
             System.out.println("构造方法");
         }
     }
     
     public class StaticDemo {
         public static void main(String[] args) {
             //1)加载Poo.class到方法区中，同时自动执行静态块
             //2)new Poo()时，自动调用构造方法
             Poo o4 = new Poo();
             //1)new Poo()时，自动调用构造方法
             Poo o5 = new Poo();
             //1)new Poo()时，自动调用构造方法
             Poo o6 = new Poo();
         }
     }

2. 潜艇游戏第五天：

  1. 给类中成员添加访问控制修饰符
  2. 设计Images图片类

2.1代码project目录

2.1.1Battleship类

package cn.tedu.submarine;

import java.util.Objects;

/**
 * 战舰
 */
public class Battleship extends SeaObject{
    /**
     * 命
     */
    private int life;


    public Battleship() {
        super(66,26,270,124,5);
        this.life = 5;
    }


    @Override
    public void move() {

    }


    /**
     * 发射炸弹的方法
     */
    public void shootBomb(){

    }


}

2.1.2Bomb类

package cn.tedu.submarine;

import java.util.Objects;

/**
 * 炸弹
 */
public class Bomb extends SeaObject{

    public Bomb(int x , int y) {
        super(9,12,x,y,3);
    }


    /**
     * 炸弹移动的方法
     */
    @Override
    public void move() {
        y += speed;
    }


}

2.1.3Images类（今天新增）

package cn.tedu.submarine;

import javax.swing.ImageIcon;


public class Images {
    /**
     * 背景图
     */
    public static ImageIcon sea;
    /**
     * 战舰图
     */
    public static ImageIcon battleship;
    /**
     * 炸弹图片
     */
    public static ImageIcon bomb;
    /**
     * 游戏结束
     */
    public static ImageIcon gameover;
    /**
     * 水雷图片
     */
    public static ImageIcon mine;
    /**
     * 水雷潜艇
     */
    public static ImageIcon minesubm;
    /**
     * 侦察潜艇
     */
    public static ImageIcon obsersubm;
    /**
     * 鱼类潜艇
     */
    public static ImageIcon torpesubm;

    /**
     * 初始化图片
     */
    static {
        battleship = new ImageIcon("img/battleship.png");
        sea = new ImageIcon("img/sea.png");
        bomb = new ImageIcon("img/bomb.png");
        gameover = new ImageIcon("img/gameover.png");
        mine = new ImageIcon("img/mine.png");
        minesubm = new ImageIcon("img/minesubm.png");
        obsersubm = new ImageIcon("img/obsersubm.png");
        torpesubm = new ImageIcon("../mysubmarine/img/torpesubm.png");
    }

    /**
     * 测试图片
     * @param args
     */
    public static void main(String[] args) {
        //返回8表示成功了
        System.out.println(battleship.getImageLoadStatus());
    }

}

2.1.4Mine类

package cn.tedu.submarine;

import java.util.Objects;

/**
 * 水雷
 */
public class Mine extends SeaObject{

    public Mine(int x , int y) {
        super(11,11,x,y,1);
    }


    /**
     * 水雷移动的方法
     */
    @Override
    public void move() {
        y-=speed;
    }


}

2.1.5MineSubMarine类

package cn.tedu.submarine;

import java.util.Objects;
import java.util.Random;

/**
 * 水雷潜艇
 */
public class MineSubmarine extends SeaObject{


    public MineSubmarine() {
        super(63,19);
    }



    @Override
    public void move() {
        x+=speed;
    }

}

2.1.6ObserverSubMarine类

package cn.tedu.submarine;

import java.util.Objects;
import java.util.Random;

/**
 * 侦察潜艇
 */
public class ObserverSubmarine extends SeaObject{


    public ObserverSubmarine() {
        super(63,19);
    }



    @Override
    public void move() {
        x+=speed;
    }
}

2.1.7SeaObject类

package cn.tedu.submarine;

import java.util.Random;

/**
 * 海洋对象
 */
public abstract class SeaObject {
    /**
     * 成员变量一般都要private的
     * 此处设计为protected
     * 因为还没有讲到getter/setter
     */
    /**
     * 宽
     */
    protected int width;
    /**
     * 高
     */
    protected int height;
    /**
     * x轴
     */
    protected int x;
    /**
     * y轴
     */
    protected int y;
    /**
     * 速度
     */
    protected int speed;


    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 SeaObject(int width,int height){
        this.width = width;
        this.height = height;
        Random rand = new Random();
        x = -width;
        y = rand.nextInt(479-height-150+1 ) +150;
        this.speed = rand.nextInt(3)+1;
    }

    /**
     * 移动的方法
     */
    public abstract void move();
}

2.1.8TorpedoSubmarine类

package cn.tedu.submarine;

import java.util.Objects;
import java.util.Random;

/**
 * 鱼类潜艇
 */
public class TorpedoSubmarine extends SeaObject{


    public TorpedoSubmarine() {
        super(64,20);
    }


    /**
     * 鱼类潜艇移动的方法
     */
    @Override
    public void move() {
        x+=speed;
    }

}

2.1.9World（测试类）

package cn.tedu.submarine;

import javax.swing.*;

/**
 * 整个游戏世界
 */
public class World extends JPanel {
    public static void main(String[] args) {
        JFrame frame = new JFrame();
        World world = new World();
        world.setFocusable(true);
        frame.add(world);
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        frame.setSize(641+16,479+39);
        frame.setLocationRelativeTo(null);
        frame.setVisible(true);
        /*
        ObserverSubmarine os = new ObserverSubmarine();
        System.out.println("原始数据---- x:"+os.x+",y:"+os.y+",speed:"+os.speed);
        os.move();
        System.out.println("移动后数据---- x:"+os.x+",y:"+os.y+",speed:"+os.speed);

        TorpedoSubmarine ts = new TorpedoSubmarine();
        System.out.println("原始数据---- x:"+ts.x+",y:"+ts.y+",speed:"+ts.speed);
        ts.move();
        System.out.println("移动后数据---- x:"+ts.x+",y:"+ts.y+",speed:"+ts.speed);

        MineSubmarine ms = new MineSubmarine();
        System.out.println("原始数据---- x:"+ms.x+",y:"+ms.y+",speed:"+ms.speed);
        ms.move();
        System.out.println("移动后数据---- x:"+ms.x+",y:"+ms.y+",speed:"+ms.speed);

        Bomb b = new Bomb(150,300);
        System.out.println("原始数据---- x:"+b.x+",y:"+b.y+",speed:"+b.speed);
        b.move();
        System.out.println("移动后数据---- x:"+b.x+",y:"+b.y+",speed:"+b.speed);

        Mine m = new Mine(100,120);
        System.out.println("原始数据---- x:"+m.x+",y:"+m.y+",speed:"+m.speed);
        m.move();
        System.out.println("移动后数据---- x:"+m.x+",y:"+m.y+",speed:"+m.speed);




//        Battleship s = new Battleship();
//        System.out.println(s.x+","+s.y+","+s.speed);
//        s.move();
//        SeaObject[] subMarines = new SeaObject[5];
//        subMarines[0] = new ObserverSubmarine();
//        subMarines[1] = new MineSubmarine();
//        subMarines[2] = new TorpedoSubmarine();
//        subMarines[3] = new ObserverSubmarine();
//        subMarines[4] = new TorpedoSubmarine();
//
//        for (int i = 0; i < subMarines.length; i++) {//遍历所有的潜艇
//            SeaObject so = subMarines[i];
//            System.out.println(so.x+","+so.y+","+so.speed);
//            subMarines[i].move();
//        }
//
//        ObserverSubmarine[] oses = new ObserverSubmarine[3];
//        oses[0] = new ObserverSubmarine();
//        oses[1] = new ObserverSubmarine();
//        oses[2] = new ObserverSubmarine();
//        for (int i = 0; i < oses.length; i++) {
//            System.out.println(oses[i].x+","+oses[i].y+","+oses[i].speed);//输出每个侦察挺的x和y坐标
//            oses[i].move();
//        }
//        Bomb[] bs = new Bomb[3];
//        bs[0] = new Bomb(100,522);
//        bs[1] = new Bomb(145,243);
//        bs[2] = new Bomb(113,443);
//        for (int i = 0; i < bs.length; i++) {
//            Bomb b = bs[i];
//            System.out.println(b.x+","+b.y+","+b.speed);
//            bs[i].move();
//            //炸弹移动
//            //炸弹打潜艇
//        }
//
//        Mine[] ms = new Mine[2];
//        ms[0] = new Mine(241,22);
//        ms[1] = new Mine(341,112);
//        for (int i = 0; i < ms.length; i++) {
//            Mine m = ms[i];
//            System.out.println(m.x+","+m.y+","+m.speed);
//            ms[i].move();
//        }


         */
    }
}

3.补充

3.1顺序问题：如果有的话

   - package在最上面
   - import在package的下面
   - class在import的下面

3.2成员变量分为如下两种：-  下午画内存图来详细讲解

   - 实例变量：没有static修饰，属于对象的，存储在堆中，有几个对象就有几份，

     ​                   通过引用名/对象打点来访问 

   - 静态变量：由static修饰，属于类的，存储在方法区中，只有一份

     ​                    通过类名打点来访问

3.3内存管理：由JVM来管理

   - 堆：new出来的对象(包括实例变量、数组元素)
   - 栈：局部变量(包括方法的参数)
   - 方法区：.class字节码文件(包括静态变量、所有方法)

3.4给成员变量赋值规则：

   - 静态变量，一般在静态块中初始化
   - 实例变量，一般在构造方法中初始化

3.5明日单词：

   1)graphics:图像/画笔
   2)PI:圆周率
   3)count:数量
   4)abstract:抽象的
   5)live:活着的
   6)dead:死了的
   7)state:状态
   8)is:是
   9)paint:画
程序猿 Monkey
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
潜艇大战代码改动版
m0_46273014的博客
10-23 389
【代码】潜艇大战代码改动版。
学习笔记——java潜艇游戏项目
qq_44975497的博客
03-08 3412
游戏中的对象： 一个战舰： 多个侦查潜艇： 多个鱼雷潜艇： 多个水雷潜艇： 多个水雷： 多个炸弹： 多个鱼雷：
初学Java第九天
m0_65804507的博客
04-13 541
笔记 1. 引用类型数组： - 给引用类型数组的元素赋值时，必须得new个对象 - 若想访问对象的数据/调用方法，需要通过数组元素去打点 ```java 1)Student[] stus = new Student[3]; stus[0] = new Student("zhangsan",25,"LF"); stus[1] = new Student("lisi",24,"JMS"); stus[2] = new Student("wangwu",...
潜艇大战小游戏（面向对象练习）
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则游戏结束)
潜艇小游戏
L12131415L的博客
02-26 3191
潜艇小游戏
schemaorg-jsd:使用Schema.org词汇表对JSON-LD文件进行JSON Schema验证
05-08
它返回一个Promise对象，因此您可以使用await或使用标准的Promise原型方法。 阅读在TypeDoc评论./src/index.ts进一步的细节。 const { sdoValidate } = require ( 'schemaorg-jsd' ) async function run ( ) { //...
ui5-lib-visualization:基于C3.jsD3.js的SAPUI5和OpenUI5的可视化控制库
05-12
自定义OpenUI5数据授权库 该库提供一个OpenUI5 API，用作基于D3的图表库。 与sap.viz图表控件相比，它提供了更详细和更具吸引力的API设计，该控件在与数据绑定结合的XML视图中特别和谐地交互。...
jsd-advanced-js：JavaScript，高级
02-17
在“jsd-advanced-js”这个主题中，我们将深入探讨JavaScript的高级特性，包括但不限于异步编程、模块化、面向对象编程、闭包、作用域链以及性能优化等关键概念。 1. **异步编程**： JavaScript是单线程的，但通过...
联合训练jsd-alpha
02-17
【联合训练JSD-Alpha】是一种机器学习方法，主要用于数据分布不对称或存在多个相关但不完全重叠的特征空间的场景。在这种情况下，传统的单模型训练可能无法捕捉到所有领域的知识，而联合训练（Co-Training）通过构建...
判断数组中最大值,并将最大值放在数组中最后一个元素的下一个位置上
m0_67115379的博客
03-16 897
package cn.tedu.submarine; import java.util.Arrays; public class MaxArrays { public static void main(String[] args) { int [] arr = new int[10];//创建一个有10个元素的数组arr for (int i = 0; i < arr.length; i++) { arr [i] = (int)(M.
JSD-2204-面向对象-成员内部类-匿名内部类-潜艇游戏--Day13
TheNewSystrm的博客
05-18 285
面向对象-成员内部类-匿名内部类-潜艇游戏
初学Java第十二天
m0_65804507的博客
04-18 135
笔记： 1. 数组： - 复制： - System.arraycopy(a,1,b,0,4); ```java int[] a = {10,20,30,40,50}; int[] b = new int[6]; //0,0,0,0,0,0 //a:源数组 //1:源数组的起始下标 //b:目标数组 //0:目标数组的起始下标 //4:要复制的元素个数 Syst...
【潜艇游戏开发】最全的源代码
居然天上楼的博客
09-24 1875
5.2)重写paint()方法---在paint()中调用paintImage()即可---------不要求掌握。- 删除越界的海洋对象是定时发生的，所以在run()中调用outOfBoundsAction()删除越界的海洋对象。3. 画对象：---------------------------------要求：看着笔记中的步骤能写出来就OK。- 炸弹与潜艇的碰撞为定时发生的，所以在run()中调用bombBangAction()实现炸弹与潜艇碰撞。
JSD-2204-面向对象-潜艇游戏--Day08
TheNewSystrm的博客
05-11 524
面向对象-潜艇游戏
JSD-2204-面向对象-多态-潜艇游戏--Day15
TheNewSystrm的博客
05-20 398
面向对象-多态-潜艇游戏
JSD-2204-面向对象-接口-潜艇游戏--Day14
TheNewSystrm的博客
05-19 471
面向对象-接口-潜艇游戏
Unity近似的Transform实现
薛文旺
08-08 231
Unity近似的Transform实现。
Unity自带的UGUI ScrollView刷新不及时问题
最新发布
weixin_43932372的博客
08-09 74
如上所示，当我想刷新Unity中的一个ScrollView的列表后，将这个列表瞬间移至底部。但是上述这三行代码会出现一个问题：存在ScrollView列表中的东西还未刷新完，就执行了移至底部的方法，导致最终的效果与预期不符。那怎么让它在刷新完成之后再进行后续的操作？
捷晟达JSDTARZ-1001 Pt100温度信号隔离变送器
"捷晟达科技的Pt100铂热电阻温度隔离变送器用于将热电阻信号转换成标准模拟量，适用于多种热电阻类型，如Pt100、Pt1000等，广泛应用于工业自动化控制系统中的温度测量和隔离。产品具备高隔离电压和抗电磁干扰能力，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值