前言：
我们上一篇讲到了this，super和代码块，这一篇我们聊一下static final，文章中每一条概念都会配上演示代码和代码截图还有结果，希望能给兄弟们带来帮助！
一.介绍
static修饰的成员变量和成员方法独立于该类的任何对象。也就是说，它不依赖类特定的实例，被类的所有实例共享。
只要这个类被加载，Java虚拟机就能根据类名在运行时数据区的方法区内定找到他们。因此，static对象可以在它的任何对象创建之前访问，无需引用任何对象。
final是java中的一个关键字，可以用来修饰变量、方法和类。用关键词final修饰的域成为最终域。用关键词final修饰的变量一旦赋值，就不能改变，也称为修饰的标识为常量。如果一个类的域被关键字final所修饰，它的取值在程序的整个执行过程中将不会改变。
假如说整个类都是final，就表明自己不希望从这个类继承，或者不答应其他任何人采取这种操作。换言之，出于这样或那样的原因，我们的类肯定不需要进行任何改变；或者出于安全方面的理由，我们不希望进行子类化（子类处理）。
除此以外，我们或许还考虑到执行效率的问题，并想确保涉及这个类各对象的所有行动都要尽可能地有效。
二.知识点介绍
1、static
2、final
3、static和final一起使用
三.节点详解
1、static
1.1、修饰成员变量
在我们平时的使用当中，static最常用的功能就是修饰类的属性和方法，让他们成为类的成员属性和方法，我们通常将用static修饰的成员称为类成员或者静态成员，这句话挺起来都点奇怪，其实这是相对于对象的属性和方法来说的。
代码演示:
package com.Test;
public class Person {
String name;
int age;
/*自定义的toString()方法不能够传入参数，并且必须返回一个字符串。定义的toString可以返回我们任何需要的值*/
public String toString() {
return "Name:" + name +
", Age:" + age;
}
public static void main(String[] args) {
//对象一
Person p1 = new Person();
p1.name = "磊哥";
p1.age = 25;
//对象二
Person p2 = new Person();
p2.name = "java历险记";
p2.age = 4;
System.out.println(p1);
System.out.println(p2);
}
}
1.2、修饰成员方法
static的另一个作用，就是修饰成员方法。相比于修饰成员属性，修饰成员方法对于数据的存储上面并没有多大的变化，因为我们从上面可以看出，方法本来就是存放在类的定义当中的。static修饰成员方法最大的作用，就是可以使用"类名.方法名"的方式操作方法，避免了先要new出对象的繁琐和资源消耗，我们可能会经常在帮助类中看到它的使用：
代码演示：
package com.Test;
public class Person {
public static void print(Object o){
System.out.println(o);
}
public static void main(String[] args) {
Person.print("磊哥的java历险记");
}
}
1.3、静态块
在说明static关键字的第三个用法时，我们有必要重新梳理一下一个对象的初始化过程。以下面的代码为例：
代码演示：
package com.Test;
public class Person {
}
class Book{
public Book(String msg) {
System.out.println(msg);
}
}
class PersonTwo {
Book book1 = new Book("book1成员变量初始化");
static Book book2 = new Book("static成员book2成员变量初始化");
public PersonTwo(String msg) {
System.out.println(msg);
}
Book book3 = new Book("book3成员变量初始化");
static Book book4 = new Book("static成员book4成员变量初始化");
public static void main(String[] args) {
PersonTwo p1 = new PersonTwo("p1初始化");
}
}
1.4、静态导包
相比于上面的三种用途，第四种用途可能了解的人就比较少了，但是实际上它很简单，而且在调用类方法时会更方便。以上面的“PrintHelper”的例子为例，做一下稍微的变化，即可使用静态导包带给我们的方便：
代码演示：
/*
PrintHelper.java文件
*/
package com.Test;
public class PrintHelper {
public static void print(Object o){
System.out.println(o);
}
}
package com.Test;
import static com.Test.PrintHelper.print;
public class Main {
public static void main(String[] args) {
print("磊哥的java历险记");
}
}
2、final
在java中，final的含义在不同的场景下有细微的差别，但总体上来说，它指的是“这是不可变的”。下面，我们来讲final的四种主要用法。
2.1、修饰数据
在编写程序时，我们经常需要说明一个数据是不可变的，我们成为常量。在java中，用final关键字修饰的变量，只能进行一次赋值操作，并且在生存期内不可以改变它的值。更重要的是，final会告诉编译器，这个数据是不会修改的，那么编译器就可能会在编译时期就对该数据进行替换甚至执行计算，这样可以对我们的程序起到一点优化。不过在针对基本类型和引用类型时，final关键字的效果存在细微差别。举个例子：
代码演示：
package com.Test;
public class PrintHelper {
static class Value {
int v;
public Value(int v) {
this.v = v;
}
}
public static class FinalTest {
final int f1 = 1;
final int f2;
public FinalTest() {
f2 = 2;
}
public static void main(String[] args) {
final int value1 = 1;
// value1 = 4;
final double value2;
value2 = 2.0;
final Value value3 = new Value(1);
value3.v = 4;
}
}
}
2.2、修饰方法参数
前面我们可以看到，如果变量是我们自己创建的，那么使用final修饰表示我们只会给它赋值一次且不会改变变量的值。那么如果变量是作为参数传入的，我们怎么保证它的值不会改变呢？这就用到了final的第二种用法，即在我们编写方法时，可以在参数前面添加final关键字，它表示在整个方法中，我们不会（实际上是不能）改变参数的值：
代码演示：
package com.Test;
public class Main {
public void finalFunc(final int i, final PrintHelper p) {
// i = 5; 不能改变i的值
// v = new Value(); 不能改变v的值
p.name = "磊哥的java历险记"; // 可以改变引用对象的值
}
}
class Test4 {
public static void main(String[] args) {
new Test4().f1(2);
}
public void f1(final int i) {
//i++; //i是final类型的,值不允许改变的.
System.out.print(i);
}
}
2.3、修饰方法
第三种方式，即用final关键字修饰方法，它表示该方法不能被覆盖。这种使用方式主要是从设计的角度考虑，即明确告诉其他可能会继承该类的程序员，不希望他们去覆盖这个方法。这种方式我们很容易理解，然而，关于private和final关键字还有一点联系，这就是类中所有的private方法都隐式地指定为是final的，由于无法在类外使用private方法，所以也就无法覆盖它。
代码演示：
class A{
public
final void a(){
}
}
class A1 extends A{
public final void a(){//不可以
}
}
代码演示：
package com.Test;
public class Test {
public static void main(String[] args) {
//TODO 自动生成方法存根
}
public void f1() {
System.out.println("f1");
}
//无法被子类覆盖的方法
public final void f2() {
System.out.println("f2");
}
public void f3() {
System.out.println("f3");
}
private void f4() {
System.out.println("f4");
}
}
//继承Test
class Test2 extends Test {
public void f1(){
System.out.println("Test父类方法f1被覆盖!");
}
/*public void f2(){
System.out.println("Test父类方法不能被f2被覆盖!");
}*/
public void f3(){
System.out.println("Test父类方法f3被覆盖!");
}
public static void main(String[] args) {
Test2 t=new Test2();
t.f1();
//调用从父类继承过来的final方法
t.f2();
//调用从父类继承过来的方法
t.f3();
//调用失败，无法从父类继承获得
//t.f4();
}
}
2.4、修饰类
了解了final关键字的其他用法，我们很容易可以想到使用final关键字修饰类的作用，那就是用final修饰的类是无法被继承的。
final class A{
}
3、static和final一起使用
（1）static final用来修饰成员变量和成员方法，可以理解为“全局变量”
（2）对于变量，表示一旦给值就不可修改，并且通过类名可以访问。
（3）对于方法，表示不可覆盖，并且可以通过类名直接访问。
注意：
对于被static和final修饰过的实例常量，实例本身不能再改变了，但对于一些容器类型（比如，ArrayList、HashMap）的实例变量，不可以改变容器变量本身，但可以修改容器中存放的对象。
代码演示：
package com.Test;
import java.util.ArrayList;
public class Test {
private static final String strStaticFinalVar = "磊哥的java历险记";
private static String strStaticVar = null;
private final String strFinalVar = null;
private static final int intStaticFinalVar = 0;
private static final Integer integerStaticFinalVar = new Integer(8);
private static final ArrayList<String> alStaticFinalVar = new ArrayList<String>();
private void test() {
System.out.println("-------------值处理前----------");
System.out.println("strStaticFinalVar=" + strStaticFinalVar + "");
System.out.println("strStaticVar=" + strStaticVar + "");
System.out.println("strFinalVar=" + strFinalVar + "");
System.out.println("intStaticFinalVar=" + intStaticFinalVar + "");
System.out.println("integerStaticFinalVar=" + integerStaticFinalVar + "");
System.out.println("alStaticFinalVar=" + alStaticFinalVar + "");
//错误，final表示终态,不可以改变变量本身.
//strStaticFinalVar="哈哈哈哈";
//正确，static表示类变量,值可以改变
strStaticVar = "_51博客";
//错误, final表示终态，在定义的时候就要初值（哪怕给个null），一旦给定后就不可再更改。
//strFinalVar="呵呵呵呵";
//错误, final表示终态，在定义的时候就要初值（哪怕给个null），一旦给定后就不可再更改。
//intStaticFinalVar=2;
//integerStaticFinalVar=new
//错误, final表示终态，在定义的时候就要初值（哪怕给个null），一旦给定后就不可再更改。
//Integer(8);
//正确，容器变量本身没有变化，但存放内容发生了变化。这个规则是非常常用的，有很多用途。
alStaticFinalVar.add("aaa");
//正确，容器变量本身没有变化，但存放内容发生了变化。这个规则是非常常用的，有很多用途。
alStaticFinalVar.add("bbb");
System.out.println("-------------值处理后----------");
System.out.println("strStaticFinalVar=" + strStaticFinalVar + "");
System.out.println("strStaticVar=" + strStaticVar + "");
System.out.println("strFinalVar=" + strFinalVar + "");
System.out.println("intStaticFinalVar=" + intStaticFinalVar + "");
System.out.println("integerStaticFinalVar=" + integerStaticFinalVar + "");
System.out.println("alStaticFinalVar=" + alStaticFinalVar + "");
}
public static void main(String args[])
{
new Test().test();
}
}
结语：
只有向前不断行走，才能有始有终。当你想要放弃的时候，就想想一开始你是怎样的拼尽全力；当你想要逃避的时候，就回头看看当初那个坚定执着的你。
我从不知道顺其自然有多自然，但我知道现实有多现实。
感谢兄弟们的持续关注！
