Java面向对象：final、static final常量、抽象方法、抽象类。

最新推荐文章于 2024-07-12 16:26:30 发布

ineedamibo

最新推荐文章于 2024-07-12 16:26:30 发布

阅读量50

点赞数

分类专栏：重生之我是Java小菜鸟 Java入门文章标签： java

本文链接：https://blog.csdn.net/ineedamibo/article/details/127936958

版权

重生之我是Java小菜鸟同时被 2 个专栏收录

14 篇文章 0 订阅

订阅专栏

Java入门

14 篇文章 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大法
画对象：--------------------------看着笔记的步骤能写出来就彳亍
- 因为只有活着的对象才需要画到窗口中，所以需要设计对象的状态(活着还是死了)，
  
  每个对象都有状态，意味着状态为共有属性，所以设计在SeaObject超类中，
  
  状态一般都设计为常量，同时再设计state变量表示当前状态
  
  —在SeaObject中设计LIVE、DEAD常量，state变量表示当前状态
  
  在后期的业务中经常需要判断对象的状态，每个对象都得判断，
  
  意味着判断状态的行为为共有行为，所以设计在SeaObject超类中，
  
  每个对象判断状态的代码都是一样的，所以设计为普通方法
  
  —在SeaObject中设计isLive()、isDead()判断对象的状态
- 若对象为活着的则可以开画了，想画对象需要获取对象的图片，每个对象都能得图片，
  
  意味着获取图片的行为为共有行为，所以设计在SeaObject超类中，
  
  每个对象获取图片的代码都是不一样的，所以设计为抽象方法
  
  —在SeaObject中设计抽象方法getImage()获取图片
  
  超类中的抽象方法需要在派生类中重写
  
  —在6个类中重写getImage()获取对象所对应的图片
- 数据(状态、图片、x坐标、y坐标)都有了，就可以开画了，每个对象都得画，
  
  意味着画对象的行为为共有行为，所以设计在SeaObject超类中，
  
  每个对象画的代码都是一样的，所以设计为普通方法
  
  —在SeaObject中设计paintImage()画对象
- 画对象的方法写好了，在窗口World类中调用即可：
  - 准备对象
  - 重写paint()方法(不要求掌握)-----在paint()中调用paintImage()即可

上期：

方法的重写(override)：重新写
- 发生在父子类中，方法名相同，参数列表相同
- 重写方法被调用时，看对象的类型--------------------------这是规定
package和import：
访问控制修饰符：-------------保护数据的安全
- public：公开的，任何类
- private：私有的，本类
- protected：受保护的，本类、派生类、同包类--------------很少用
- 默认的：什么也不写，本类、同包类-----------------------------不建议用
static：静态的
- 静态变量：static，类，方法区中，一份，类名点，所有对象共享的数据(图片、音频、视频等)
- 静态方法：static，类，方法区中，一份，类名点，
  
  没有隐式this传递，不能直接访问实例成员
  
  方法的操作对象无关时使用
- 静态块：static，类，在类被加载期间自动执行，只执行一次
  
  加载/初始化静态资源(图片、音频、视频等)

速记：

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

完整笔记：

final：最终的、不可改变的-----------------应用率不高

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

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

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

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{} //正确，不能当老爸，但能当儿子

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; //编译错误，常量必须声明同时初始化
}

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

补充：

设计规则：
- 将派生类所共有的属性和行为，抽到超类中-------------抽共性
- 若派生类的行为/代码都一样，设计为普通方法
  
  若派生类的行为/代码不一样，设计为抽象方法
- …-------------------周三讲
抽象方法/抽象类的疑问：
- 抽象方法存在的意义是什么？
  - 保证当发生向上造型时，通过超类的引用能点出来那个方法--------保证能点出来
- 既然抽象方法的意义是保证能点出来，那为什么不设计为普通方法呢？
  - 设计为普通方法，意味着派生类可以重写也可以不重写，但设计为抽象方法，则可以强制派生类必须重写-------------强制派生类重写，以达到统一的目的
画对象带数：先找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)时会去调用Object中的paintImage()方法，若submarines[i]为侦察潜艇对象，则方法中的this指的就是侦察潜艇，方法中判断侦察潜艇是否活着，若活着则获取侦察潜艇的图片，用画笔画到侦察潜艇的x坐标和y坐标。若submarines[i]为鱼雷潜艇，则…

词汇：

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:重新画