final和static

final

看到final要想到（三点，数据，方法，类）：

1. 声明数据
2. 声明方法
3. 声明类

以下是具体说明：

• 声明数据

  声明数据是常量，可以是编译时常量，也可以是运行时被初始化之后不可改变的常量。

  对于基本类型，final使数值不变

  对于引用类型，final可以使引用不变，就是不能引用其他对象，但是本身还是可以修改的，引用不可修改，本身属性值可以修改

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'}

• 声明方法

  方法不能被子类重写，private方法隐式的被指定为final

• 声明类

  类不允许被继承

static

看到static要思考（六点，变量，方法，语句块，内部类，导包，顺序）：

1. 静态变量
2. 静态方法
3. 静态语句块
4. 静态内部类
5. 静态导包
6. 初始化顺序

• 静态变量

  又称类变量，这个变量是属于类的，可以直接通过类名访问，所有实例都共享，内存中只存在一份。

  那什么又是实例变量呢？

  每创建一个对象就会产生一个实例变量，与实例同生共死。

• 静态方法

  类加载就存在，直接通过类名访问，静态方法不能是抽象方法，只能访问所属类的静态字段和静态方法。

  class Solution {
        
      Integer a;		// 实例变量
      static Integer b;		// 静态变量
      
      public static void func(){
        
  // a = 10 不能使用实例变量，只能访问静态变量
          b = 10;
          System.out.println("静态方法，可以直接通过类名调用");
      }
  
      public static void main(String[] args) {
        
          Solution.func();
  
      }
  }
  

• 静态语句块

  特点：在类初始化的时候运行一次

  class Solution {
        
  
      static {
        
          System.out.println("我是静态语句块！");
      }
  
  
      public static void main(String[] args) {
        
          Solution solution = new Solution();
          Solution solution1 = new Solution();
          Solution solution2 = new Solution();
      }
  }
  

  结果：只会输出一句，因为只会执行一次

  我是静态语句块！
  

  只要涉及到使用这个类，静态语句块内的内容就会执行，并且执行一次，后续不会再执行，比如调用个静态方法：

  class Solution {
        
  
      static {
        
          System.out.println("我是静态语句块！");
      }
  
      static void func(){
        
          System.out.println("我是静态方法！");
      }
  
  
      public static void main(String[] args) {
        
          Solution.func();
  // Solution solution = new Solution();
  // Solution solution1 = new Solution();
  // Solution solution2 = new Solution();
      }
  }
  

  输出结果：

  我是静态语句块！
  我是静态方法！
  

  再把下面注释打开，还是这两句，可以自行测试。

• 静态内部类

  静态内部类可以直接new，非静态内部类需要用外部类的实例来创建。

  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();
      }
  }
  

• 静态导包

  使用静态变量和方法的时候就可以不用指明类名字了，但是可读性不高。

  import static com.xxx.ClassName.*
  

• 初始化顺序

  静态变量和静态语句块优先于实例变量和普通语句块（静态优先），同是静态取决于代码顺序。各种变量语句块执行完毕才会执行构造方法。

  存在继承的情况下：

  1. 父类（静态变量，静态语句块）
  2. 子类（静态变量，静态语句块）
  3. 父类（实例变量，普通语句块）
  4. 父类（构造函数）
  5. 子类（实例变量，普通语句块）
  6. 子类（构造函数）

  一句话总结，静态优先，父类优先。