Final and static

final

notice final Think of it （ Three points , data , Method , class ）：

1. Declare data
2. Declaration method
3. Declaration class

The following are the specific instructions ：

• Declare data

  Declare data to be constant , Can be a compile-time constant , It can also be a constant that cannot be changed after the runtime is initialized .

  For basic types ,final Keep the value constant

  For reference types ,final You can make the reference unchanged , You can't reference other objects , But it can be modified , Reference cannot be modified , Its own attribute value can be modified

final Student s = new Student();
s.name = "houge";
s.setName("shuaige");
s.name = "houge";
s.setAge(18);
System.out.println(s.toString());       // Student{name='houge', age='18'}

• Declaration method

  Method cannot be overridden by subclass ,private Method is implicitly specified as final

• Declaration class

  Class is not allowed to be inherited

static

notice static Think about （ 6'o clock , Variable , Method , Sentence block , Inner class , Guide pack , The order ）：

1. Static variables
2. Static methods
3. Static statement block
4. Static inner class
5. Static guide package
6. Initialization sequence

• Static variables

  Also known as class variable , This variable belongs to the class , You can access it directly through the class name , All instances share , There is only one copy in memory .

  What are instance variables ？

  Every time an object is created, an instance variable is generated , Live and die with the instance .

• Static methods

  Class loading exists , Directly through the class name , Static methods cannot be abstract methods , Only the static fields and static methods of the class can be accessed .

  class Solution {
        
      Integer a;		//  Instance variables 
      static Integer b;		//  Static variables 
      
      public static void func(){
        
  // a = 10  Instance variables cannot be used , Only static variables can be accessed 
          b = 10;
          System.out.println(" Static methods , Can be called directly through the class name ");
      }
  
      public static void main(String[] args) {
        
          Solution.func();
  
      }
  }
  

• Static statement block

  characteristic ： Run once during class initialization

  class Solution {
        
  
      static {
        
          System.out.println(" I am a static statement block ！");
      }
  
  
      public static void main(String[] args) {
        
          Solution solution = new Solution();
          Solution solution1 = new Solution();
          Solution solution2 = new Solution();
      }
  }
  

  result ： Only one sentence will be output , Because it will only be executed once

   I am a static statement block ！
  

  Whenever it comes to using this class , The contents of the static statement block will be executed , And execute once , It will not be executed later , For example, call a static method ：

  class Solution {
        
  
      static {
        
          System.out.println(" I am a static statement block ！");
      }
  
      static void func(){
        
          System.out.println(" I'm a static method ！");
      }
  
  
      public static void main(String[] args) {
        
          Solution.func();
  // Solution solution = new Solution();
  // Solution solution1 = new Solution();
  // Solution solution2 = new Solution();
      }
  }
  

  Output results ：

   I am a static statement block ！
   I'm a static method ！
  

  Then open the following notes , Or these two sentences , You can test it yourself .

• Static inner class

  Static inner classes can be used directly new, Non static inner classes need to be created with instances of outer classes .

  class Solution {
        
  
      class InnerClass{
        
  
      }
  
      static class StaticInnerClass{
        
  
      }
  
      public static void main(String[] args) {
        
          Solution solution = new Solution();
          InnerClass innerClass = solution.new InnerClass();
          StaticInnerClass staticInnerClass = new StaticInnerClass();
      }
  }
  

• Static guide package

  When using static variables and methods, you don't need to specify the class name , But the readability is not high .

  import static com.xxx.ClassName.*
  

• Initialization sequence

  Static variables and static statement blocks take precedence over instance variables and normal statement blocks （ Static first ）, Both are static and depend on the code order . The constructor will not be executed until all variable statement blocks are executed .

  Where there is inheritance ：

  1. Parent class （ Static variables , Static statement block ）
  2. Subclass （ Static variables , Static statement block ）
  3. Parent class （ Instance variables , Ordinary statement block ）
  4. Parent class （ Constructors ）
  5. Subclass （ Instance variables , Ordinary statement block ）
  6. Subclass （ Constructors ）

  One sentence summary , Static first , The parent class takes precedence .