CGB2202面向对象第7天

面向对象第七天：

潜艇游戏第一天：

1. 设计6个类，设计World类并测试

潜艇游戏第二天：

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

潜艇游戏第三天：

1. 设计侦察潜艇数组、鱼雷潜艇数组、水雷潜艇数组、水雷数组、深水炸弹数组，并测试
2. 设计SeaObject超类，设计6个类继承超类
3. 给SeaObject设计了两个构造方法，6个类分别调用

潜艇游戏第四天：

1. 将侦察潜艇数组、鱼雷潜艇数组、水雷潜艇数组统一组合为SeaObject数组，并测试
2. 在6个类中重写move()移动，并测试
3. 画窗口

潜艇游戏第五天：

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

潜艇游戏第六天：

1. 设计窗口的宽和高为常量，适当地方做修改
2. 画海洋图、画对象:
   • 想画对象需要去获取对象的图片，每个对象都能获取图片，
     意味着获取图片行为为共有行为，所以设计在SeaObject类中，
     每个对象获取图片的行为都是不一样的，所以设计为抽象方法
     ----在SeaObject中设计抽象方法getImage()获取图片
   • 在6个派生类中重写getImage()获取对象的图片
     ----重写getImage()获取图片
   • 因为只有活着的对象才需要画到窗口中，所以需要设计对象的状态，
     每个对象都有状态，意味着状态为共有属性，所以设计在SeaObject中，
     状态一般都设计为常量，同时设计state变量表示当前状态
     ----在SeaObject中设计状态常量LIVE、DEAD，state变量表示当前状态
     后期的业务中还需要判断对象的状态，每个对象都能判断状态，
     意味着判断状态的行为为共有行为，所以设计在SeaObject中，
     每个对象判断状态的行为都是一样的，所以设计为普通方法
     ----在SeaObject中设计isLive()、isDead()判断对象的状态
   • 数据都有了就可以开画了，每个对象都能画，
     意味着画对象的行为为共有的行为，所以设计在SeaObject中，
     每个对象画对象的行为都是一样的，所以设计为普通方法
     ----在SeaObject中设计paintImage()画图片---------具体怎么画，不要求掌握
   • 画对象的行为做好了，在窗口World中调用即可：
     • 准备对象
     • 重写paint()方法------调用paintImage()方法

潜艇游戏第七天：

1. 潜艇入场：

   • 潜艇是由窗口产生的，所以在窗口World类中设计nextSubmarine()生成潜艇对象
   • 潜艇入场为定时发生的，所以在run中调用submarineEnterAction()实现潜艇入场
     在submarineEnterAction()中:
     每400毫秒，获取潜艇对象obj，submarines扩容，将obj添加到submarines最后一个元素上

     在run()中调用submarineEnterAction()之后，一定得调用repaint()方法来重画

2. 水雷入场：-------------今天只做一部分(剩下部分周五做)

   • 水雷是由水雷潜艇发射出来的，所以在MineSubmarine中设计shootMine()生成水雷对象
   • 水雷入场为定时发生的，所以在run中调用MineEnterAction()实现水雷入场
     在MineEnterAction()中：
     每1000毫秒…--------------周五讲

3. 海洋对象移动(不包括战舰)：

   • 对象移动为所有对象共有的行为，所以在超类SeaObject中设计抽象move()来实现移动，6个派生类中重写
   • 海洋对象移动为定时发生的，所以在run中调用moveAction()实现海洋对象移动
     在moveAction()中：
     遍历所有潜艇让潜艇动，遍历所有水雷让水雷动，遍历所有深水炸弹让深水炸弹动

回顾：

1. static final常量：
   必须声明同时初始化，由类名点来访问，不能改变，大写，多个单词用_分隔
   编译器在编译时会将常量直接替换为具体的值，效率高
   数据永远不变，并且经常使用
2. 抽象方法：
   abstract修饰，只有方法的定义，没有具体的实现(连{}都没有)
3. 抽象类：
   abstract修饰，包含抽象方法的类必须是抽象类，不能被实例化
   抽象类需要被继承，派生类：重写所有抽象方法(变不完整为完整)
   意义：代码复用、向上造型、
   可以包含抽象方法，为所有派生类提供统一的入口(能点出来)，强制重写

笔记：

1. 成员内部类：应用率低-------------------了解即可
   • 类中套类，外面的称为外部类，里面的称为内部类
   • 内部类通常只服务于外部类，对外不具备可见性
   • 内部类对象通常在外部类中创建
   • 内部类中可以直接访问外部类的成员(包括私有的)
     内部类中有个隐式的引用指向了创建它的外部类对象：外部类名.this----API时会用

   public class InnerClassDemo {
       public static void main(String[] args) {
           Mama m = new Mama();
           //Baby b = new Baby(); //编译错误，内部类对外不具备可见性
       }
   }
   
   class Mama{ //外部类
       private String name;
       void create(){
           Baby b = new Baby(); //正确，内部类对象通常在外部类中创建
       }
       class Baby{ //内部类
           void showName(){
               System.out.println(name); //省略写法
               System.out.println(Mama.this.name); //完整写法
               //System.out.println(this.name); //编译错误，this指代当前Baby对象
           }
       }
   }
   

2. 匿名内部类：-----------------------大大简化代码
   • 若想创建一个类(派生类)的对象，并且对象只被创建一次，可以做成匿名内部类
   • 在匿名内部类中默认外面的变量为final的----这是规定，记住就行了-----API时会用
   • 面试题：问：内部类有独立的.class吗？ 答：有

   public class NstInnerClassDemo {
       public static void main(String[] args) {
           //1)创建了Aoo的一个派生类，但是没有名字
           //2)为该派生类创建了一个对象，名为o1
           //3)大括号中的为派生类的类体
           Aoo o1 = new Aoo(){
           };
   
           //1)创建了Aoo的一个派生类，但是没有名字
           //2)为该派生类创建了一个对象，名为o2
           //3)大括号中的为派生类的类体
           Aoo o2 = new Aoo(){
           };
   
           int num = 5;
           num = 55;
           //1)创建了Boo的一个派生类，但是没有名字
           //2)为该派生类创建了一个对象，名为o3
           //3)大括号中的为派生类的类体
           Boo o3 = new Boo(){
               void show(){
                   System.out.println("showshow");
                   //在匿名内部类中会默认外面的变量为final的----API时会用
                   //num = 55; //编译错误
               }
           };
           o3.show();
   
       }
   }
   
   abstract class Boo{
       abstract void show();
   }
   
   abstract class Aoo{
   }
   

精华笔记:

1. 成员内部类：应用率低-------------------了解即可
   • 类中套类，外面的称为外部类，里面的称为内部类
   • 内部类通常只服务于外部类，对外不具备可见性
   • 内部类对象通常在外部类中创建
   • 内部类中可以直接访问外部类的成员(包括私有的)
     内部类中有个隐式的引用指向了创建它的外部类对象：外部类名.this----API时会用
2. 匿名内部类：-----------------------大大简化代码
   • 若想创建一个类(派生类)的对象，并且对象只被创建一次，可以做成匿名内部类
   • 在匿名内部类中默认外面的变量为final的----这是规定，记住就行了-----API时会用
   • 面试题：问：内部类有独立的.class吗？ 答：有

补充：

1. 隐式的引用：
   • this：指代当前对象
   • super：指代当前对象的超类对象
   • 外部类名.this：指代当前对象的外部类对象
2. 做功能的套路：
   • 先写行为/方法：
     • 若为某对象所特有的行为，则将方法设计在特定的类中
     • 若为所有对象所共有的行为，则将方法设计在超类中
   • 窗口调用：
     • 若为定时发生的，则在定时器中调用
     • 若为事件触发的，则在侦听器中调用------------明天上午讲
3. 明日单词：

   1)interface:接口
   2)implements:实现
   3)enemy:敌人
   4)nuclear:核武器
   5)left:左
   6)right:右
   7)out of bounds:超出界限
   8)Key:键盘
   9)Adapter:适配器
   10)release:松开/弹起
   11)code:编码
   12)space:空白
   13)listener:监听