面向对象第7天：接口周考

凝925

已于 2022-11-12 16:20:38 修改

阅读量588

点赞数

分类专栏：面向对象文章标签： java 前端算法

于 2022-11-12 14:54:02 首次发布

本文链接：https://blog.csdn.net/m0_61332438/article/details/127820128

版权

面向对象专栏收录该内容

10 篇文章 0 订阅

订阅专栏

潜艇游戏第一天：

创建6个类，创建World类并测试

潜艇游戏第二天：

给6个类添加构造方法，并测试

潜艇游戏第三天：

设计侦察潜艇数组、鱼雷潜艇数组、水雷潜艇数组、水雷数组、炸弹数组，并测试
设计SeaObject超类，设计6个类继承超类
给SeaObject设计两个构造方法，6个类分别调用
将三种潜艇统一造型为SeaObject数组，并测试

建议练习顺序：2、3、(1+4)

潜艇游戏第四天：

在6个派生类中重写move()，并测试
给类中成员添加访问控制修饰符(建议先修改派生类，最后修改超类)
设计Images图片类

潜艇游戏第五天：

设计窗口的宽和高为常量，适当地方做修改
画窗口：--------在World类中共3步，不需要掌握，CV大法即可
- import JFrame+JPanel
- 设计World类继承JPanel----------------这一步大家特别容易忘记
- main中代码CV大法

画对象：---------------------------------要求：看着笔记中的步骤能写出来就OK

1)想画对象需要获取对象的图片，每个对象都能得图片，
  意味着获取图片的行为为共有行为，所以设计在SeaObject超类中，
  每个对象获取图片的代码都是不一样的，所以设计为抽象方法
  ---在SeaObject中设计抽象方法getImage()获取图片
2)在派生类中重写getImage()获取对象所对应的图片
  ---在6个类中重写getImage()
3)因为只有活着的对象才需要画到窗口中，所以需要设计对象的状态(活着还是死了)，
  每个对象都有状态，意味着状态为共有属性，所以设计在SeaObject超类中，
  状态一般都设计为常量，同时再设计state变量表示当前状态
  ---在SeaObject中设计LIVE、DEAD常量，state变量表示当前状态
  在后期的业务中经常需要判断对象的状态，每个对象都得判断，
  意味着判断状态的行为为共有行为，所以设计在SeaObject超类中，
  每个对象判断状态的代码都是一样的，所以设计为普通方法
  ---在SeaObject中设计isLive()、isDead()判断对象的状态
4)数据(状态、图片、x坐标、y坐标)都有了就可以开画了，每个对象都得画，
  意味着画对象的行为为共有行为，所以设计在SeaObject超类中，
  每个对象画的代码都是一样的，所以在设计为普通方法
  ---在SeaObject中设计paintImage()画对象
5)画对象的方法写好了，在窗口World类中调用即可:
  5.1)准备对象
  5.2)重写paint()方法(不要求掌握)----在paint()中调用paintImage()即可

潜艇游戏第六天：------------要求：能够按照步骤写出来就OK

潜艇入场：
- 潜艇对象是由窗口产生的，所以在World类中设计nextSubmarine()生成潜艇对象
- 潜艇入场为定时发生的，所以在run()中调用submarineEnterAction()实现潜艇入场
  - 在submarineEnterAction()中：
    - 每400毫秒，获取潜艇对象obj，submarines扩容，将obj添加到submarines最后一个元素上
    注意：run()中调用submarineEnterAction()后，一定要调用repaint()重画
水雷入场(上半段)：
- 水雷是由水雷潜艇发射出来的，所以在MineSubmarine中设计shootMine()生成水雷对象
- 水雷入场为定时发生的，所以在run()中调用mineEnterAction()实现水雷入场
  - 在mineEnterAction()中：
    - 每1000毫秒，…暂时搁置(周五讲)
海洋对象移动：
- 海洋对象移动为共有行为，所以在SeaObject中设计抽象方法move()移动，在6个类中重写move()移动
- 海洋对象移动为定时发生的，所以在run()中调用moveAction()实现海洋对象移动
  - 在moveAction()中：
    - 遍历所有潜艇，潜艇移动。遍历所有水雷，水雷移动。遍历所有炸弹，炸弹移动。

潜艇游戏第七天：

炸弹入场：
- 炸弹是由战舰发射出来的，所以在Battleship中设计shootBomb()生成炸弹对象
- 炸弹入场为事件触发的，所以在侦听器中重写keyReleased()按键抬起方法，方法中判断：
  - 若抬起的是空格键，则：
    - 获取炸弹对象obj，bombs扩容，将obj装到最后一个元素上
战舰移动：
- 战舰移动为战舰的行为，所以在Battleship中设计moveLeft()左移、moveRight()右移
- 战舰移动为事件触发的，所以在侦听器的重写keyReleased()按键抬起方法中判断：
  - 若抬起的是左箭头，则战舰左移
  - 若抬起的是右箭头，则战舰右移
删除越界的海洋对象：
- 在SeaObject中设计isOutOfBounds()检测潜艇越界，在Bomb和Mine中重写isOutOfBounds()检测炸弹和水雷的越界
- 删除越界海洋对象为定时发生的，所以在run()中调用outOfBoundsAction()删除越界的海洋对象
  - 在outOfBoundsAction()中：
    - 遍历所有潜艇/水雷/炸弹数组，判断若越界了，则：
      - 将越界元素替换为最后一个元素，缩容
设计EnemyScore分的接口，ObserveSubmarine和TorpedoSubmarine实现分的接口

设计EnemyLife命的接口，MineSubmarine实现命的接口

精华笔记：

接口：
- 是一种引用数据类型
- 由interface定义
- 只能包含常量和抽象方法
- 接口不能被实例化(new对象)
- 接口是需要被实现/继承的，实现类/派生类：必须重写所有抽象方法
- 一个类可以实现多个接口，用逗号分隔，若又继承又实现时，应先继承后实现
- 接口可以继承接口

笔记：

接口：

是一种引用数据类型
由interface定义
只能包含常量和抽象方法
接口不能被实例化(new对象)
接口是需要被实现/继承的，实现类/派生类：必须重写所有抽象方法
一个类可以实现多个接口，用逗号分隔，若又继承又实现时，应先继承后实现

接口可以继承接口

public class InterfaceDemo {
    public static void main(String[] args) {
        //Inter5 o = new Inter5(); //编译错误，接口不能被实例化
        Inter5 o1 = new Doo(); //向上造型
        Inter4 o2 = new Doo(); //向上造型
    }
}

//演示接口继承接口
interface Inter4{
    void show();
}
interface Inter5 extends Inter4{
    void test();
}
class Doo implements Inter5{
    public void test(){}
    public void show(){}
}

//演示接口的多实现
interface Inter2{
    void show();
}
interface Inter3{
    void test();
}
abstract class Boo{
    abstract void say();
}
class Coo extends Boo implements Inter2,Inter3{
    public void show(){}
    public void test(){}
    void say(){}
}

//演示接口的实现
interface Inter1{
    void show();
    void test();
}
class Aoo implements Inter1{
    public void show(){} //重写接口中的抽象方法，必须加public
    public void test(){}
}

//演示接口的定义
interface Inter{
    public static final int NUM = 5;
    public abstract void show();
    int COUNT = 6; //默认public static final
    void test(); //默认public abstract
    //int number; //编译错误，常量必须声明同时初始化
    //void say(){} //编译错误，抽象方法不能有方法体
}

补充：

侦听器可以CV的代码如下：

//侦听器对象----不要求掌握
KeyAdapter k = new KeyAdapter() {
    /** 重写keyReleased()按键抬起事件 */   //keyPressed()按下事件
    public void keyReleased(KeyEvent e) { //不要求掌握---当按键抬起时会自动触发
        if(e.getKeyCode()==KeyEvent.VK_SPACE){ //不要求掌握---若抬起的是空格键
        }
        if(e.getKeyCode()==KeyEvent.VK_LEFT){ //不要求掌握---若抬起的是左键头
        }
        if(e.getKeyCode()==KeyEvent.VK_RIGHT){ //不要求掌握---若反起的是右键头
        }
    }
};
this.addKeyListener(k); //不要求掌握---添加侦听器

类间关系：
- 类和类-----------------------------继承
- 接口和接口-----------------------继承
- 类和接口--------------------------实现
设计规则：
- 将所有派生类所共有的属性和行为，抽到超类中--------------------抽共性
- 若派生类的行为/代码都一样，设计为普通方法
  
  若派生类的行为/代码不一样，设计为抽象方法
- 将部分派生类所共有的属性和行为，抽到接口中
  - 接口是对继承的单根性的扩展------------------------------实现多继承
  - 接口相当于制定了个标准、规范，实现了接口，意味着就能干那个事，不实现接口，就干不了那个事----------明天下午才能体会
如何调错：---------------要求：你们在问项目经理之前，一定要先把问题方法锁定好，然后再问项目经理
- 快速锁定问题方法：
  - 将调用方法的代码都注释起来，一个一个的放开运行，放开哪个方法出错，说明问题就在那个方法上
- 打桩：
  - System.out.println(数据); //-----------------不能着急，得慢慢来，调得多了就有经验了

明日单词：

1)hit:撞
2)other:另一个
3)instanceof:实例
4)cut:剪
5)cast:类型
6)go:去

集中问题:
1.接口的好处?------------------明天讲
2.按下左键/右键之后，战舰不动
-----检查你是否写的是if(e.getKeyCode()==KeyCode.VK_LEFT/VK_RIGHT)
3.为什么删不掉对象?
-----------检查你的isOutOfBounds()检测越界方法是否正确
在outOfBoundsAction()中:
-----------一定要先用最后一个元素将越界对象替换掉，然后再缩容
4.看着我的代码或笔记能写出来，自己独立写就写不出来了---------这是正常的
------欠思考、欠练，需要多写、多模仿
------做功能对你们的要求是: 能按照我笔记中的步骤写出来就可以
*/

/*
常见面试题:
1.JDK、JRE、JVM的区别:
1)JDK:java开发工具包，是java的核心，包括:JRE+编译、运行等命令工具
2)JRE:java运行环境，是运行java程序所必须的环境的集合，包括:JVM+java系统类库
3)JVM:java虚拟机，是java实现跨平台的最核心部分，能够运行java语言所开发的程序
2.java的8种基本数据类型是什么?(简述java的8种基本数据类型)
答:8种基本数据类型包括:byte,short,int,long,float,double,boolean,char
1)byte:字节型，用于存储整数的，占用1个字节，范围-128到127
2)short:短整型，用于存储整数的，占用2个字节，范围-32768到32767
3)int:最常用的整型，用于存储整数的，占用4个字节，范围-231到231-1
4)long:长整型，用于存储较大的整数，占用8个字节，范围-263到263-1
5)float:单精度浮点数，用于存储小数的，占用4个字节，不能表示精确的值
6)double:双精度浮点数，最常用的存储小数的类型，占用8个字节，不能表示精确的值
7)boolean:布尔型，存储true或false，占用1个字节
8)char:字符型，采用Unicode字符编码格式，存储单个字符，占用2个字节
3.switch可以作用于哪些数据类型上？
答:byte,short,int,char,String,枚举，其余类型都不允许
4.重写与重载的区别:
1)重写:发生在父子类中，方法名相同，参数列表相同
----用于在子类中修改父类中的方法
2)重载:发生在同一类中，方法名相同，参数列表不同
----方法名相同的完全不同的方法
5.实例变量与静态变量的区别:
----实例变量和静态变量都属于成员变量
1)实例变量:是属于对象的，在创建对象时存储在内存堆中，创建多少个对象，则实例变量
就会在内存堆中存在多少份，需要通过引用变量来访问
2)静态变量:是属于类的，在类被加载时存储在内存方法区中，无论创建多少个对象，静态
变量在内存中都只有一份，常常通过类名来访问
6.java是值传递还是引用传递?
—java中无论是基本类型还是引用类型，都是值传递
1)对于基本类型而言，传递的是具体的值的副本
2)对于引用类型而言，传递的是具体的地址值的副本
注意:网站上说Java有引用传递的文章都是错误的!!!
举例:
int a = 5;
int b = a; //将a的值5赋值给b(传递的是值的副本–5)
Student zs = new Student();
Student zss = zs; //将zs的地址值赋值给zss(传递的是地址值的副本–0x1111)
//zss和zs指向了同一个Student对象
7.抽象类与接口的区别:
1)抽象类:
1.1)由abstract修饰
1.2)可以包含变量、常量、构造方法、普通方法、静态方法、抽象方法
1.3)派生类通过extends来继承
1.4)只能继承一个(体现单一继承)
1.5)抽象类中的成员是任何访问权限都可以(默认为默认权限(同包中的))
2)接口:
2.1)由interface定义
2.2)只能包含常量、抽象方法
2.3)实现类通过implements来实现
2.4)可以实现多个(体现多实现)
2.5)接口中的成员的访问权限只能是public(默认为public权限)
*/