java:final和static初学

package com.jvmfinalstatic;

参考文献：http://lavasoft.blog.51cto.com/62575/18771/
/*本节学习java中的final关键字
 * 1.final 从字面上理解：最后的，无可改变的、也就是有些API中的“终态”；
 * 2.final修饰不同东西的不同效果
 *  2.1修饰类 
 *      final类不能被继承，如果这个类不需要有子类，类也不想再扩展了就可以定义为final的；
 *      final类中成员 域：
 *          其域可以是 final 的也可以 不是final的 根据需求定义即可；
 *      final类中成员 方法：
 *          因此final类的成员方法没有机会被覆盖，默认都是 final 的。
 *      示例代码：示例2.1
 *  2.2修饰成员变量：
 *      final修饰基本数据类型变量(局部变量)：
 *          用final修饰的成员变量表示常量，值一旦给定就无法改变！
 *          final变量定义的时候，可以先声明，而不给初值，这中变量也称为final空白，
 *          无论什么情况，编译器都确保空白final在使用之前必须被初始化.
 *      final修饰引用变量：
 *          则对其初试化之后就不能再指向另一个对象；引用不可以改变，但是它所指向的对象的内容可以改变
 *      final小贴士：
 *          public static final int VALUE_THREE = 39；
 *          VALUE_THREE是一种更加典型的对常量进行定义的方式：定义为public，可以被任何人访问；定义为static，
 *          则强调只有一份；定义为fianl，这说明它是个常量。请注意带有恒定初始值(即，编译期常量)
 *          的final static基本类型全用大写字母命名，并且字母与字母之间用下划线隔开。
 * 
 *  2.3修饰参数：
 *      1.java中允许在参数列表中以声明的方式将参数指明为final，这就意味着无法在方法中更改参数引用所指向的对象；
 *      2.匿名内部类的应用；
 *  2.4修饰方法：
 *      1.不让继承了修改它的含义；即不可以被覆盖
 *      2.效率高点；
 *  2.5final和private
 *      1.类中的private方法隐式地指定为final的，由于无法取用private方法，所以也就无法覆盖它，因此对private方法
 *        添加final修饰符什么作用也不起；
 * 
 * 3.java中的static用法：
 *  3.1static修饰的成员变量和成员方法
 *      它不依赖类特定的实例，被类的所有实例共享。只要这个类被加载，Java虚拟机就能根据类名在运行时数据区的方法区内
 *      定找到他们。因此，static对象可以在它的任何对象创建之前访问，无需引用任何对象。
 *      静态变量：对于静态变量在内存中只有一个拷贝，JVM只为静态分配一次内存，在加载类的过程中完成静态变量的内存分配，
 *      可用类名直接访问。
 *      静态方法：静态方法可以直接通过类名调用，任何的实例也都可以调用，因此静态方法中不能用this和super关键字，不能直
 *      接访问所属类的实例变量和实例方法(就是不带static的成员变量和成员成员方法)，只能访问所属类的静态成员变量和成员
 *      方法。因为实例成员与特定的对象关联！
 *  3.2用public修饰的static成员变量和成员方法本质是全局变量和全局方法，(java中没有全局变量的定义)当声明它类的对象市，
 *      不生成static变量的副本，而是类的所有实例共享同一个static变量。
 *  3.3static变量前可以有private修饰，表示这个变量可以在类的静态代码块中，或者类的其他静态成员方法中使用，但是不能
 *      在其他类中通过类名来直接引用，这一点很重要。
 *  3.4 用static修饰的代码块表示静态代码块，当Java虚拟机（JVM）加载类时，就会执行该代码块
 *  

 * 
 * */
//示例类2.1
final class FinalClass{
    int noFinalField = 2;
    final int finalField = 4;
    public void  show(){
        System.out.println("i was a default final method ,because the class name is modified by final keyword"+" :"+noFinalField);
    }

}
/*class SonFinalClass extends FinalClass{
    // Error:The type SonFinalClass cannot subclass the final class FinalClass
    //remove the final modifier of FinalClass
}*/

//示例类2.2
class FinalField{
    //第一种情况：a 为常量
    private final int a = 10;
    //第二种情况：final空白；
    private final int b ;
    //第三种情况：c: 一个即是static又是fianl的域只占一段不能改变的存储空间,将用大写表示
    public static final int C =20;

    FinalField(int b){
        this.b=b;
        System.out.println("a:"+a+" b:"+b+" c:"+C);
    }
    //第四种情况：
    public void importMethod1(){
        String a = "hello2"; 
        final String b = "hello";
        String c = "hello";
        String d = b + 2; 
        String e = c + 2;
        System.out.println((a == d));//true
        System.out.println((a == e));//flase;
        /*这里面就是final变量和普通变量的区别了，当final变量是基本数据类型以及String类型时，
         * 如果在编译期间 能知道 它的确切值，则编译器会把它当做编译期常量使用。也就是说在用到该final变
         * 量的地方，相当于直接访问的这个常量，不需要在运行时确定。因此在上面的一段代码中，由于变量b
         * 被final修饰，因此会被当做编译器常量，所以在使用到b的地方会直接将变量b替换为它的值;
         * 而对于变量 c 的访问却需要在运行时通过  链接来进行。不过要注意，只有在编译期间能确切知道final
         * 变量值的情况下，编译器才会进行这样的优化.
         * 补注：
         * 而我们知道String类型实现常量池技术，(结合反射一博文) 比如String st1 ="hellojava";
         * String st2 ="hellojava";这是"hellojava"会存在方法区内的常量池中，又因为常量池是共享的
         * ，所以只会存储一份，符号 st1和st2会存贮在栈中，并且俩个符号会指向同一个地址(及“hellojava"在常量池中的地址);
         * */ 
        Integer aa = 10;
        Integer bb = 5;
        Integer cc = 5;
        Integer dd = bb+cc;
        System.out.println(aa==dd);//输出结果为true；
        //Java的数学计算是在内存栈里操作的其实比较的是基本类型（10=5+5），他们的值相同，因此结果为True

    }
    //第五种情况
    public void importMethod2(){
        String a = "hello2"; 
        final String b = getHello();
        String c = "hello";
        String d = b + 2; 
        String e = c + 2;
        System.out.println((a == d));//flase
        //因为对于变量  b 和 c 的访问却需要在运行时通过  链接来进行,编译器就不会进行上述优化
        System.out.println((a == e));//flase;
    }
    public static String getHello() {
        return "hello";
    }
}
//final 参数
class FinalArgument{
    void with(final FinalClass fc){
        //fc = new FinalClass(); 这样是不对的，因为fc是final,
        fc.noFinalField = 100;//其所指向的对象的内容是可以改的，虽然在才并不影响原来的值；   
    }
}

//final方法；
class PrivateMethod{

    public void  show(){
        System.out.println("privateMethod"+" :"+"show()");
    }
    private void f(){
        System.out.println("privateMethod"+" :"+"f()");
    }
}
class PrivateFinalMethod extends PrivateMethod{
    private void f(){
        System.out.println("privateFinalMethod"+" :"+"f()");
    }
}
class PrivateFinalMethod2 extends PrivateFinalMethod{
    public void f(){
        System.out.println("privateFinalMethod"+" :"+"f()");
    }
}


//主函数：
public class FinalModifierStudy {
    public static void showFinalClass(){
        FinalClass fc = new FinalClass();
        //The final field FinalClass.finalField cannot be assigned
        //fc.finalField = 44;

        fc.noFinalField =22;
        fc.show();
        //输出结果：
        //i was a default final method ,because the class name is modified by final keyword :22
    }

    public static void showFinalField(){
        FinalField ff = new FinalField(40);
        ff.importMethod1();
    }

    public static void showFinalMethod(){
        PrivateFinalMethod2 pfm2 = new PrivateFinalMethod2();
        pfm2.f();//就是调用PrivateFinalMethod2中的方法 其不是继承来的也不是覆盖了父类的；
        //采用多态的形式会出错：
        PrivateFinalMethod pfm = new PrivateFinalMethod2();
        //pfm.f();就会出错 因为private f()就相当于隐藏在类中的代码，只不过形式和父类有点像
        //其既不是继承来的也不是覆盖父类的；
    }
    public static void main(String[] args) {
        //showFinalClass();
        showFinalField();
    }

}