面向对象第五天

小姜认真点
98 阅读5分钟

面向对象第五天：

精华笔记：

  1. final：最终的、不可改变的--------------------单独应用率低
    • 修饰变量：变量不能被改变
    • 修饰方法：方法不能被重写
    • 修饰类：类不能被继承
  2. static final常量：-------------应用率高
    • 必须声明同时初始化
    • 常常由类名点来访问，不能被改变
    • 建议：常量名所有字母都大写，多个单词用下划线(_)分隔
    • 编译器在编译时会将常量直接替换为具体的数，效率高
    • 何时用：程序运行过程中数据永远不变，并且经常使用
  3. 抽象方法：
    • 由abstract修饰
    • 只有方法的定义，没有具体的实现(连{}都没有)
  4. 抽象类：
    • 由abstract修饰
    • 包含抽象方法的类必须是抽象类
    • 抽象类不能被实例化(new对象)
    • 抽象类是需要被继承的，派生类：
      • 重写所有抽象方法------------------------变不完整为完整
      • 也设计为抽象类---------------------------一般不这么做
    • 抽象类的意义：
      • 封装共有的属性和行为------------------代码复用
      • 为所有派生类提供统一的类型---------向上造型(代码复用)
      • 可以包含抽象方法，为所有派生类提供统一的入口(能点出来)，同时达到强制重写的目的

笔记：

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

    • 修饰变量：变量不能被改变

      class Aoo{
    final int num = 5;
    void show(){
        //num = 55; //编译错误，final的变量不能被改变
    }
}

    • 修饰方法：方法不能被重写

      class Boo{
    final void show(){}
    void test(){}
}
class Coo extends Boo{
    //void show(){} //编译错误，final的方法不能被重写
    void test(){}
}

    • 修饰类：类不能被继承

      final class Doo{}
//class Eoo extends Doo{} //编译错误，final的类不能被继承
class Foo{}
final class Goo extends Foo{} //正确，不能当老爸，但能当儿子

  2. static final常量：-------------应用率高

    • 必须声明同时初始化

    • 常常由类名点来访问，不能被改变

    • 建议：常量名所有字母都大写，多个单词用下划线(_)分隔

    • 编译器在编译时会将常量直接替换为具体的数，效率高

    • 何时用：程序运行过程中数据永远不变，并且经常使用

      public class StaticFinalDemo {
    public static void main(String[] args) {
        System.out.println(Hoo.PI); //常常由类名点来访问
        //Hoo.PI = 3.1415926; //编译错误，常量不能被改变
		
        //1)加载Ioo.class到方法区中
        //2)静态变量num一并存储到方法区中
        //3)到方法区中获取num的值并输出
        System.out.println(Ioo.num);

        //编译器在编译时会将常量直接替换为具体的数，效率高
        //相当于System.out.println(5);
        System.out.println(Ioo.COUNT);
    }
}

class Ioo{
    public static int num = 5; //静态变量
    public static final int COUNT = 5; //常量
}

class Hoo{
    public static final double PI = 3.1415926;
    //public static final int NUM; //编译错误，常量必须声明同时初始化
}

  3. 抽象方法：

    • 由abstract修饰
    • 只有方法的定义，没有具体的实现(连{}都没有)

  4. 抽象类：

    • 由abstract修饰
    • 包含抽象方法的类必须是抽象类
    • 抽象类不能被实例化(new对象)
    • 抽象类是需要被继承的，派生类：
      • 重写所有抽象方法------------------------变不完整为完整
      • 也设计为抽象类---------------------------一般不这么做
    • 抽象类的意义：
      • 封装共有的属性和行为------------------代码复用
      • 为所有派生类提供统一的类型---------向上造型(代码复用)
      • 可以包含抽象方法，为所有派生类提供统一的入口(能点出来)，同时达到强制重写的目的

补充：

  1. 设计规则：

    • 将派生类所共有的属性和行为，抽到超类中----------------抽共性

    • 若派生类的行为/代码都一样，设计为普通方法

      若派生类的行为/代码都不一样，设计为抽象方法

    • ...

  2. 抽象方法/抽象类的疑问：

  • 抽象方法的意义是什么？
    • 保证当发生向上造型时，通过超类的引用能点出那个方法来------保证能点出来
  • 既然抽象方法的意义是保证能点出来，那为什么不设计为普通方法呢?
    • 设计为普通方法，意味着派生类可以重写也可以不重写，但设计为抽象方法，则可以强制派生类必须重写------强制派生类重写，以达到统一的目的

  1. 不包含抽象方法的类也可以是抽象类(一般很少这么做而已)

    abstract和final不能同时修饰一个类

  2. 画对象带数：先找main--------------------非常重要

    • 创建(new)World对象时，就会分配World类中的实例变量(ship,submarines,mines,bombs)，对象的数据(width,height,x,y,speed)就都在构造方法中赋好值了
    • frame.setVisible(true);时自动调用paint()方法，在paint()中：当第1次用到Images时，就会将Images.class加载到方法区中，同时将那一堆静态图片分配到方法区中，同时自动执行静态块给图片赋值，取出sea这张图片画到0,0的位置上。
    • ship.paintImage(g)时会去调用SeaObject中的paintImage()方法，方法中的this指的就是战舰ship，方法中先判断战舰是否是活着的，若活着的则获取战舰的图片，用画笔画到战舰的x/y坐标上。
    • submarines[i].paintImage(g)时会用调用SeaObject中的paintImage()方法，若submarines[i]为侦察潜艇对象，则方法中的this指的就是侦察潜艇，方法中判断侦察潜艇是否活着，若活着则获取侦察潜艇的图片，用画笔画到侦察潜艇的x/y坐标上。若submarines[i]是鱼雷潜艇.......

  3. 明日单词：

    1)inner:内部的
2)outer:外部的
3)baby:孩子
4)create:创建
5)anonymous/anon:匿名
6)shoot:射击
7)next:下
8)one:一个
9)action:行动
10)enter:进入
11)timer:定时器
12)interval:间隔
13)schedule:日程表
14)task:任务
15)repaint:重新画
avatar
文章
阅读
粉丝