Java零基础学习013-面向对象第七天

面向对象第七天:

潜艇游戏第一天:

  1. 设计了6个类,创建World类并测试

潜艇游戏第二天:

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

潜艇游戏第三天:

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

潜艇游戏第四天:

  1. 将侦察潜艇数组、鱼雷潜艇数组、水雷潜艇数组统一组合为SeaObject数组,并测试
  2. 在6个派生类中重写move()移动,并测试(单元测试)
  3. 画窗口:在World类中,3步--------不要求掌握
    • imoprt JFrame+JPanel
    • 设计World类继承JPanel-------------这步特别容易忘记
    • main中那8句话------CV大法

潜艇游戏第五天:

  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装到最后一个元素上

      在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); //Mama.this指代当前对象的外部类对象
                //System.out.println(this.name); //编译错误,this指代当前Baby对象
            }
        }
    }
    
  2. 匿名内部类:重点-----------------大大简化代码

    • 若想创建一个类(派生类)的对象,并且对象只被创建一次,可以做成匿名内部类
    • 匿名内部类中不能修饰外面局部变量的值,因为在此处该变量会默认为final的
    public class AnonInnerClassDemo {
        public static void main(String[] args) {
            //new Aoo(); //创建Aoo对象
            //new Aoo(){}; //创建Aoo的派生类的对象
    
            //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(){ //重写Boo类的抽象方法
                    System.out.println("showshow");
                    //num = 66; //编译错误,在此处会默认num为final的---API时会用
                }
            };
            o3.show();
        }
    }
    
    abstract class Boo{
        abstract void show();
    }
    
    abstract class Aoo{
    }
    

精华笔记:

  1. 成员内部类:应用率低,了解

    • 类中套类,外面的称为外部类,里面的称为内部类

    • 内部类通常只服务于外部类,对外不具备可见性

    • 内部类对象通常在外部类中创建

    • 内部类中可以直接访问外部类的成员(包括私有的)

      内部类中有个隐式的引用指向了创建它的外部类对象—外部类名.this------API时会用

  2. 匿名内部类:重点-----------------大大简化代码

    • 若想创建一个类(派生类)的对象,并且对象只被创建一次,可以做成匿名内部类
    • 匿名内部类中不能修饰外面局部变量的值,因为在此处该变量会默认为final的

补充:

  1. 隐式的引用:
    • this:指代当前对象
    • super:指代当前对象的超类对象
    • 外部类名.this:指代当前对象的外部类对象
  2. 小面试题:
    • 问:内部类有独立的.class吗?
    • 答:有
  3. 做功能的套路:
    • 先写行为/方法:
      • 若为对象所特有的行为,就将方法设计在特定的类中
      • 若为所有对象所共有的行为,就将方法设计在超类中
    • 窗口调用:
      • 若为定时发生的,就在定时器中调用
      • 若为事件触发的,就在侦听器中调用---------------明天讲
  4. 如何调错:
    • 打桩:
      • System.out.println(数据);

你可能感兴趣的:(Java零基础进阶,java,intellij-idea,学习)