Java中的final、static、abstract关键字

1. final：最终的、不能改变的

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

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

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

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

• 修饰类：类不能被继承

  final class Hoo{}
  //class Ioo extends Hoo{} // 编译错误，final的类不能被继承
  class Joo{}
  final class Koo extends Joo{} // 正确，不能当老爸，但能当儿子
  

2. static：静态的

• 静态变量：

  • 由static修饰

  • 属于类，存储在方法区中，一份

  • 常常通过类名点来访问

  • 何时用：所有对象所共享的数据(图片、音频、视频等)

    // 演示静态变量
    class Loo{
        int a;
        static int b;
        Loo(){
            a++;
            b++;
        }
        void show(){
            System.out.println("a="+a+",b="+b);
        }
    }
    
    public class StaticDemo {
        public static void main(String[] args) {
            Loo o1 = new Loo();
            o1.show();
            Loo o2 = new Loo();
            o2.show();
            Loo o3 = new Loo();
            o3.show();
            System.out.println(Loo.b); // 常常通过类名点来访问
        }
    }
    

• 静态方法：

  • 由static修饰

  • 属于类，存储在方法区中，一份

  • 常常通过类名点来访问

  • 静态方法中没有隐式this传递，所以只能直接访问静态成员，而不能直接访问实例成员

  • 何时用：方法的操作与对象无关----方法中不需要访问对象的属性或行为

    // 演示静态方法
    class Moo{
        int a; // 实例变量(对象来访问)
        static int b; // 静态变量(类名来访问)
        void show(){ // 有隐式this
            System.out.println(this.a);
            System.out.println(Moo.b);
        }
        static void test(){ //没有隐式this
            // 静态方法中没有隐式this传递
            // 没有this就意味着没有对象
            // 而实例成员a必须通过对象来访问
            // 所以如下语句会发生编译错误
            // System.out.println(a); // 编译错误
            System.out.println(Moo.b);
        }
    }
    // 演示静态方法的应用场景
    class Noo{
        int a; // 实例变量---描述对象的属性
        //show()方法中需要访问对象的属性a，说明show()的操作与对象有关---不能静态方法
        void show(){
            System.out.println(a);
        }
        // plus()方法中不需要访问对象的属性和行为，说明plus()的操作与对象无关-可以静态方法
        static void plus(int num1,int num2){
            int num=num1+num2;
            System.out.println(num);
        }
    }
    public class StaticDemo {
        public static void main(String[] args) {
            Noo.plus(5,7); // 常常通过类名点来访问
        }
    }
    

• 静态块：

  • 由static修饰

  • 属于类，在类被加载时自动执行，因为一个类只被加载一次，所以静态块也只执行一次

  • 何时用：加载/初始化静态资源(图片、音频、视频等)

    //演示静态块
    class Poo{
        static{
            System.out.println("静态块");
        }
        Poo(){
            System.out.println("构造方法");
        }
    }
    public class StaticDemo {
        // 运行后发现静态块先执行且只执行一次，而构造方法执行了两次
        public static void main(String[] args) {
            Poo o4 = new Poo();
            Poo o5 = new Poo();
        }
    }
    

static final常量：

• 必须声明同时初始化
• 由类名打点来访问，不能被改变
• 建议：常量所有字母都大写，多个单词用_分隔
• 编译器在编译时会将常量直接替换为具体的数，效率高
• 何时用：数据永远不变，并且经常使用

3. abstract：抽象的

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