【Java】final & static

final关键字

Java final关键字用于限制用户，能够用于变量，方法以及类当中

final 变量

final关键字与变量一块儿使用，该变量没有值，称为空白final变量或者未初始化final变量。只可以在构造函数中初始化。空白final如果是静态（static）的，则只可以在静态块中初始化。

若是定义一个final变量，该变量的值不可以被改变，将会是一个常量

public class Test {
    final int date = 2020;
    void run(){
        date = 2021;
    }

    public static void main(String[] args){
        Test t = new Test();
        t.run();
    }
}

在IDEA中运行上述代码；

Output：

Error:(6, 9) java: 没法为最终变量date分配值

public class Test {
    final int date;
    Test() {
        date = 2020;
        System.out.println(date);
    }


    public static void main(String[] args){
        Test t = new Test();
    }
}

final 方法

若是定义一个final方法，该方法将不可以被覆写

class Bike{
    final void run(){
        System.out.println("running");
    }
}

class Test extends Bike{
    void run(){
        System.out.println("running safely with 100kmph");
    }

    public static void main(String args[]){t
        Test t= new Test();
        t.run();
    }
}

Output：

Error:(10, 10) java: package1.Test中的run()没法覆盖package1.Bike中的run()被覆盖的方法为final

final 类

若是定义一个final类，那么该类将不可以被继承

final class Bike{ }

class Test extends Bike{
    void run(){
        System.out.println("go go go!");
    }
    public static void main(String args[]){
        Test t= new Test();
        t.run();
    }
}

Output：

Error:(5, 20) java: 没法从最终package1.Bike进行继承

注：final 方法能够被继承可是不能覆写

？什么是空白或未初始化的final变量？

再变量声明时没有进行初始化的final变量

？能够声明构造函数为final吗

不能够，由于构造函数从不继承

static关键字

Java中的static关键字主要用于内存管理，能够将static关键字与变量、方法、块以及嵌套类一块儿使用

static 变量

• static变量可用于引用全部对象的公共属性
• static变量在类加载时仅在类区域中得到一次内存

经过使用静态变量可使得程序的内存使用效率更高

class Student{  
     int id;  
     String name;  
     String college="MIT";  
}

现假设学校里面有500名学生，每次建立对象时，全部实例数据成员都将得到内存。每一名学生都有惟一的id和name，college是同属于一个学校，是指全部对象的共同属性，所以将其设为静态变量，该字段就只获取一次内存。

class Student{  
   int rollno;
   String name;  
   static String college ="MIT";
   
   Student(int r, String n){  
       rollno = r;  
       name = n;  
   }
}

例1：没有静态变量的计数器

class Counter{  
    int count=0;
    Counter(){  
        count++;
        System.out.println(count);  
    }  
    public static void main(String args[]){  
        Counter c1=new Counter();  
        Counter c2=new Counter();  
        Counter c3=new Counter();  
    }  
}

在这个例子中，建立了一个名为count的实例变量，该变量在构造函数中递增。因为实例变量在建立对象时获取内存，全部在每一个对象中count变量的值都为1

例2：静态变量计数器

class Counter2{  
    static int count=0;
    Counter2(){  
        count++;
        System.out.println(count);  
    }  
    public static void main(String args[]){  
        Counter2 c1=new Counter2();  
        Counter2 c2=new Counter2();  
        Counter2 c3=new Counter2();  
    }  
}

在这个例子中，静态变量仅得到一次内存。若是任何对象更改了静态变量的值，都将保存下来

static 方法

• 静态方法属于类而不是类的对象
• 能够直接调用静态方法而不须要建立类的实例
• 静态方法能够访问静态数据成员并更改其值

class Student{
    int rollno;
    String name;
    static String college = "MIT";
    static void change(){
        college = "PKU";
    }
    Student(int r, String n){
        rollno = r;
        name = n;
    }
    void display(){
        System.out.println(rollno + " " + name + " " + college);
    }
}

public class TestStaticMethod{
    public static void main(String args[]){
        Student.change();  
        Student s1 = new Student(001, "Mike");
        Student s2 = new Student(002, "Hulk");
        Student s3 = new Student(003, "Mary");

        s1.display();
        s2.display();
        s3.display();
    }
}

在上面的例子中，能够不实例化就直接调用静态方法change()，而且能够直接经过静态方法访问修改静态变量的值。

限制

• 静态方法不可以使用非静态数据成员或者直接调用非静态方法
• this和super不可以再static context中使用

？为何Java中的main方法是static

由于静态方法不须要建立对象就可以直接被调用，而若是是非静态方法，则JVM首先要建立一个对象，而后调用main方法，这将致使额外的内存分配

static 块

• 用于初始化静态数据成员
• 在类加载时，它在main方法以前执行

class Test{  
    static{
        System.out.println("static block is invoked");
    }  
    public static void main(String args[]){  
        System.out.println("Hello main");  
    }  
}

Output: static block is invoked Hello main

？能够执行没有main方法的程序吗

不能够。从JDK1.7开始，没有main方法就没法执行Java类

参考

https://www.javatpoint.com/final-keyword

https://www.javatpoint.com/static-keyword-in-java