Java基础—static和final

static

1. 在学习很多Java知识的时候我都会第一时间去弄懂，它的单词是什么意思

static ： 静态的，静止的

2. static 是Java运用中很基础的修饰符了。

---

1. 修饰成员方法，成员变量

1）被static修饰的成员属于类，不属于单个这个类的对象，被类中所有对象共享。可以并且建议通过 类名. 调用。被static修饰的成员变量叫静态变量，静态变量存储在Java内存区域的方法区中。
2）如果你的方法执行不依赖于类中的各个变量和方法时，请将其设计为静态（这将使得占用的内存更小）
3）静态方法可以直接调用同类中的静态变量。但不可以直接调用非静态变量。不过可以通过在方法中创建对象的形式，对象.非静态变量去调用。

/**
 * @Project: 
 * @Author: Mr_yao
 * @Date: 
 * @Desc:
 */
public class Test {

    private String hello = "你好";

    private static String hi = "嗨";

    public static void getTest() {
        
        System.out.println( hi ); //直接调用静态成员
        
        Test test = new Test();
        System.out.println(test.hello); //间接调用非静态成员
        
    }

}

调用格式为

类名.静态方法名 类名.静态变量

---

2. 修饰内部类
   static 修饰类只能修饰内部类，称静态内部类。
   静态内部类和非静态内部类最大的区别是
   非静态内部类在编译完成后会隐形的保存着一个引用，这个引用指向的是创建它的外部类。但是静态内部类是没有的。没有这个引用就意味着：
   1）它的创建不需要依赖外部类的创建
   2）它只能访问外部类的静态成员变量和静态方法。

/**
 * @Project: 
 * @Author: Mr_yao
 * @Date: 
 * @Desc:
 */
public class Outer {

    private static String hello = "您好";

    private String hi = "嗨";

    private static void getTest(){
        System.out.println("访问到了外部类的静态方法");
    }
    private static class Inner{
        public void test(){
            System.out.println(hello); //访问到了外部类的静态成员变量
            getTest(); //访问到了外部类的静态方法
            Outer.getTest(); //也可以通过 类名.静态方法访问
        }
    }

    public static void main(String[] args) {
        Outer.Inner test02 = new Inner(); //静态内部类的创建方式，是不是很有趣
        test02.test();
    }
}

---

3. 修饰代码块
   静态代码块定义在类中方法外。静态代码块在非静态代码块之前执行
   静态代码块 -> 非静态代码块 -> 构造方法
   该类不管创建多少次对象，静态代码块只执行一次。

/**
 * @Project: 
 * @Author: Mr_yao
 * @Date: 
 * @Desc:
 */
public class Block {

    private Block(){
        System.out.println("执行Block的构造方法");
    }

    {
        System.out.println("执行Block的非静态代码块");
    }

    static {
        System.out.println("执行Block的静态代码块");
    }

 public void test(){
        {
            System.out.println("非静态方法中的非静态代码块");
        }
    }
    public static void main(String[] args) {
        Block block = new Block();
        Block block1 = new Block();
        Block block2 = new Block();
    }
}

执行结果如下：

执行Block的静态代码块
执行Block的非静态代码块
执行Block的构造方法
执行Block的非静态代码块
执行Block的构造方法
执行Block的非静态代码块
执行Block的构造方法

1）先执行了静态代码块，再执行了非静态代码块，然后执行了构造方法。
2）且静态代码块只会执行一次，不管后续生成多少个对象都不会再次执行。
3）在非静态方法中可以使用非静态代码块，可是静态代码块不可以。

再看一个代码实例

/**
 * @Project: 
 * @Author: Mr_yao
 * @Date: 
 * @Desc:
 */
public class Block {

    private Block(){
        System.out.println("执行Block的构造方法");
    }

    {
        System.out.println("执行Block的非静态代码块");
    }

    static {
        System.out.println("执行Block的静态代码块");
    }

    public static void staticTest(){
        System.out.println("执行静态方法");
    }

    public static void main(String[] args) {
        Block.staticTest(); //调用静态方法
    }
}

大家猜猜执行结果会是什么

执行Block的静态代码块
执行静态方法

再调用静态方法的时候，会主动先执行Block的静态代码块。

所以，一般情况下有些代码比如一些项目中最常用的变量或对象必须在项目启动的时候就执行的时候，需要使用静态代码块
如果我们想要设计不需要创建对象就可以调用类中的方法，可以用静态方法。
两者的区别：静态代码块是自动执行的，而静态方法是被调用才执行的。

---

4. 静态导入包（用来导入类中的静态资源） jdk1.5之后的特性
   import static 可以用来导入类中的静态资源，并且不需要使用类名调用静态资源，直接使用即可。

import static java.lang.System.out;
import static java.lang.Integer.*;

/**
 * @Project: 
 * @Author: Mr_yao
 * @Date: 
 * @Desc:
 */
public class ImportTest {
    public static void main(String[] args) {
        out.println( "111111" ); //直接调用out
        out.println( MAX_VALUE ); //直接调用 Integer中的静态资源 MAX_VALUE
    }
}

---

final

final : 最终的，最后的

它的最重要的性质之一就是不可被覆盖。
它主要用在三个地方：变量，方法，类

---

1. 修饰变量
   final修饰的变量，如果变量是基本数据类型，那么该变量的值一旦在初始化之后不能被改变。
   如果变量是引用类型，那么该变量初始化之后不可以再让其指向其他对象。

---

2. 修饰方法
   使用final修饰方法的原因有两个
   1）不可覆盖。以防任何继承类修改。
   2）效率。在早期的Java实现版本中，会将final方法转为内嵌调用。但是如果方法过于庞大，可能并看不出来内嵌调用带来的性能提示。（现在的Java版本已经不需要使用final进行这些优化了）
   类中所有的private方法都被隐形的指定为final

---

3. 修饰类
   当用一个final修饰类时，表明这个类不能被继承，且它的所有方法都被隐形的指定为final方法