Java关键字final、static总结与对比

package FinalDemo;

final class Father{

}
class Son extends Father{   //编译报错，不能继承final修饰的类

}

public class Test1 { 
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"); 
} 
} 
public class Test2 extends Test1 { 
    
public void f1(){     
    System.out.println("Test1父类方法f1被覆盖!"); 
} 
public static void main(String[] args) { 
    Test2 t=new Test2(); 
    t.f1();    
    t.f2(); //调用从父类继承过来的final方法 
    t.f3(); //调用从父类继承过来的方法 
    //t.f4(); //调用失败，无法从父类继承获得 
} 
}

class AA{
    int i=1;
}
public class EmbellishVariable {
    public final int a=1;
    public final int b; 
    public int c;

    public EmbellishVariable() {  //构造方法
       b=2;  //在构造方法中将成员变量b进行初始化
    }

    public void method(){
       // final修饰基本数据类型的变量
       a=2; //编译失败，数值一旦在初始化之后便不能更改

       // final修饰引用类型的变量
       final AA a = new AA();
       a=new AA(); //编译失败，被final修饰的引用变量一旦初始化赋值之后指向的对象不可变

       System.out.println( ++a.i ); //输出值为2，说明内容可变

       final StringBuffer buffer = new StringBuffer("final指向对象不可变");
       buffer.append("，内容可变");
       System.out.println( buffer ); //输出final指向对象不可变，内容可变
    }
}

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

public class StaticTest {
    public static void main(String[] args) {
        MyStatic.output();
    }
}
class MyStatic{
    public static void output(){
        System.out.println("output");
    }
}

public enum WeekDayEnum {
    SATURDAY(6, "周六"),
    SUNDAY(7, "周日");
 
    private int code;
    private String desc;
 
    WeekDayEnum(int code, String desc) {
        this.code = code;
        this.desc = desc;
    }
 
    private static final Map<Integer, WeekDayEnum> WEEK_ENUM_MAP = new HashMap<Integer, WeekDayEnum>();
 
    // 对map进行初始化
    static {
        for (WeekDayEnum weekDay : WeekDayEnum.values()) {
            WEEK_ENUM_MAP.put(weekDay.getCode(), weekDay);
        }
    }
 
    public static WeekDayEnum findByCode(int code) {
        return WEEK_ENUM_MAP.get(code);
    }
 
    public int getCode() {return code;}
 
    public String getDesc() {return desc;}
}　

// 当 Singleton 类加载时，静态内部类 SingletonHolder 没有被加载进内存
public class Singleton {
    
   // 声明为 private 避免调用默认构造方法创建对象
    private Singleton() {
    }
    
   // 声明为 private 表明静态内部该类只能在该 Singleton 类中被访问
    private static class SingletonHolder {
        private static final Singleton INSTANCE = new Singleton();
    }

    /**
    * 只有当调用 getUniqueInstance()方法，SingletonHolder 才会被加载
    * 此时初始化 INSTANCE 实例，并且 JVM 能确保 INSTANCE 只被实例化一次。
    * 这种方式不仅具有延迟初始化的好处，而且由 JVM 提供了对线程安全的支持。
    */
    public static Singleton getUniqueInstance() {
        return SingletonHolder.INSTANCE;
    }
}

//  Math. --- 将Math中的所有静态资源导入，这时候可以直接使用里面的静态方法，而不用通过类名进行调用
//  如果只想导入单一某个静态方法，只需要将换成对应的方法名即可
 
import static java.lang.Math.;
//  换成import static java.lang.Math.max;具有一样的效果
 
public class Demo {
	public static void main(String[] args) {
 
		int max = max(1,2);
		System.out.println(max);
	}
}

class StaticFinal{
    public final double fin = Math.random(); //生成随机数
    public static double sta = Math.random(); //生成随机数
    int i=1;
}

public class Demo {

    static int s1 = 0;
    final int f2 = 2;

    public static void main(String[] args) {

        StaticFinal demo1 = new StaticFinal();
        StaticFinal demo2 = new StaticFinal();
		
		System.out.println(demo1.fin == demo2.fin );//打印false
		System.out.println(demo1.sta == demo2.sta );//打印true

        System.out.println("sta+1= "+ ++demo2.sta); //static修饰的变量可以重新赋值
//      System.out.println( ++demo2.fin); //编译失败，static修饰的变量不可修改


        final StaticFinal demo3= new StaticFinal();
        System.out.println( ++demo3.i ); //输出值为2，final引用类型的内容可变


        Demo.s1(); //static修饰的方法可以直接通过类名调用

        Demo demo = new Demo();
        demo.f2(); //final修饰的方法得先创建对象后调用
        // demo.f2(f2); //编译失败，无法确定f2

      }
    
    public static void s1(){
        // this.output(); //编译失败，无法确定this
        // H5GoodsController.output(); //静态上下文中不能引用非静态方法
        H5GoodsController.staticput(); //编译成功

        s1++; //static修饰的变量可以重新赋值
        System.out.println("s1:"+s1); //输出s1:1
    }

    public final void f2() {
        this.output(); //编译成功
        this.s1(); //编译成功,输出s1:2，但不应该通过类实例访问静态成员，应该通过类名访问

        // f2 = 222; //编译失败，final变量不可修改
        System.out.println("f2:"+f2); //输出f2:2
    }

    public void output() {
        System.out.println("output");
    }
    public static void staticput() {
        System.out.println("static output");
    }
}

public class TestStaticFinal { 
        private static final String strStaticFinalVar = "aaa"; 
        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("-------------值处理前----------\r\n"); 
                System.out.println("strStaticFinalVar=" + strStaticFinalVar + "\r\n"); 
                System.out.println("strStaticVar=" + strStaticVar + "\r\n"); 
                System.out.println("strFinalVar=" + strFinalVar + "\r\n"); 
                System.out.println("intStaticFinalVar=" + intStaticFinalVar + "\r\n"); 
                System.out.println("integerStaticFinalVar=" + integerStaticFinalVar + "\r\n"); 
                System.out.println("alStaticFinalVar=" + alStaticFinalVar + "\r\n"); 


                //strStaticFinalVar="哈哈哈哈";        //错误，final表示终态,不可以改变变量本身. 
                strStaticVar = "哈哈哈哈";                //正确，static表示类变量,值可以改变. 
                //strFinalVar="呵呵呵呵";                    //错误, final表示终态，在定义的时候就要初值（哪怕给个null），一旦给定后就不可再更改。 
                //intStaticFinalVar=2;                        //错误, final表示终态，在定义的时候就要初值（哪怕给个null），一旦给定后就不可再更改。 
                //integerStaticFinalVar=new Integer(8);            //错误, final表示终态，在定义的时候就要初值（哪怕给个null），一旦给定后就不可再更改。 
                alStaticFinalVar.add("aaa");        //正确，容器变量本身没有变化，但存放内容发生了变化。这个规则是非常常用的，有很多用途。 
                alStaticFinalVar.add("bbb");        //正确，容器变量本身没有变化，但存放内容发生了变化。这个规则是非常常用的，有很多用途。 

                System.out.println("-------------值处理后----------\r\n"); 
                System.out.println("strStaticFinalVar=" + strStaticFinalVar + "\r\n"); 
                System.out.println("strStaticVar=" + strStaticVar + "\r\n"); 
                System.out.println("strFinalVar=" + strFinalVar + "\r\n"); 
                System.out.println("intStaticFinalVar=" + intStaticFinalVar + "\r\n"); 
                System.out.println("integerStaticFinalVar=" + integerStaticFinalVar + "\r\n"); 
                System.out.println("alStaticFinalVar=" + alStaticFinalVar + "\r\n"); 
        } 

        public static void main(String args[]) { 
                new TestStaticFinal().test(); 
        } 
}
 
运行结果如下：
-------------值处理前----------
strStaticFinalVar=aaa
strStaticVar=null
strFinalVar=null
intStaticFinalVar=0
integerStaticFinalVar=8
alStaticFinalVar=[]
-------------值处理后----------
strStaticFinalVar=aaa
strStaticVar=哈哈哈哈
strFinalVar=null
intStaticFinalVar=0
integerStaticFinalVar=8
alStaticFinalVar=[aaa, bbb]

Process finished with exit code 0