Java超详细分析讲解final关键字的用法

package com.demo.final_;

public class final01 {

     public static void main(String[] args) {

         E e= new E();

         e.n1= 5.66 ;

         //e.n2=6.88;//ERROE

     }

}

//如果要求A类不能被其它类继承

//可以使用final修饰A类

final class A{ }

//class B extends A{}//ERROR

// 2)当不希望父类的某个方法被子类覆盖/重写(override)时,可以用final关键字 修饰。

class C{

     //如果我们要求hi不能被重写

     //使用final修饰

     public void hi(){}

     public final void hi01(){}

}

class D extends C{

     @Override

     public void hi() {

         super .hi();

     }

    /* @Override

     public void hi01() {

         super.hi01();

     }*/ //ERROR

}

//3)当不希望类的的某个属性的值被修改,可以用final修饰

class E{

     public double n1= 1.99 ;

     public final double n2= 2.88 ;

}

//4)当不希望某个局部变量被修改，可以使用final修饰

class F{

     public void cry(){

         final double s1= 0.2 ;

         //此时s1被称为局部常量

         //s1=1.4;//ERROR

         double s2= 0.8 ;

         s2= 5.6 ;

     }

}

package com.demo.final_;

public class final_detials {

     public static void main(String[] args) {

         CC c= new CC();

         FF f= new FF();

     }

}

/*

     > 1) final修饰的属性又叫常量,一般用 XX_XX XX 来命名

> 2)final修饰的属性在定义时,必须赋初值,并且以后不能再修改,赋值可以在如 下位置之一【选择一个位置赋初值即可】：

  ①定义时：如public final double TAX_RATE=0.08；

  ②在构造器中

  ③在代码块中。

  3)如果final修饰的属性是静态的，则初始化的位置只能是

>        ①定义时

> ②在静态代码块不能在构造器中赋值。

>  4)final类不能继承，但是可以实例化对象。

> 5)如果类不是final类，但是含有final方法，则该方法虽然不能重写，但是可 以被继承。

class AA{

}*/

class AA{

     /*

      ①定义时：如public final double TAX_RATE=0.08；②在构造器中

     ③在代码块中。

      */

     public final double TAX_RATE= 0.08 ;

     public final double TAX_RATE2;

     public final double TAX_RATE3;

     //2.在构造器中赋值

     public AA( double TAX_RATE2) {

         this .TAX_RATE2 = TAX_RATE2;

     }

     //在代码快复制

     {

         TAX_RATE3 = 1.88 ;

     }

}

class BB{

     /*

     3)如果final修饰的属性是静态的，则初始化的位置只能是①定义时

> ②在静态代码块不能在构造器中赋值。

      */

     public static final double TAX_RATE= 0.08 ;

     public static final double TAX_RATE2;

     //public static final double TAX_RATE3;

     static {

         TAX_RATE2= 0.66 ;

     }

     //构造器赋值不允许

//    public BB() {

//        TAX_RATE3=2.3;

//    }ERROR

}

//>  4)final类不能继承，但是可以实例化对象。

final class CC{ }

// 5)如果类不是final类，但是含有final方法，则该方法虽然不能重写，但是可 以被继承。

class EE{

     final public void laugh(){

         System.out.println( "大非在笑" );

     }

}

class FF extends EE{ } //遵守继承；

package com.demo.final_;

public class final_detials02 {

     public static void main(String[] args) {

         System.out.println(BBB.n1);

        // 8)包装类(Integer,Double,Float, Boolean等都是final,String也是final类。

         //不能被继承

     }

}

final class AAA{

     /*

     >5)一般来说，如果一个类已经是final类了，就没有必要再将方法修饰成final方法。

>6) final不能修饰构造方法(即构造器)

>7) final 和 static 往往搭配使用，效率更高，底层编译器做了优化处理,

8)包装类(Integer,Double,Float, Boolean等都是final,String也是final类。

      */

     //>5)一般来说，如果一个类已经是final类了，就没有必要再将方法修饰成final方法。

     //public final void cry02(){}//无意义

     public void cry02(){}

}

//   }>7) final 和 static 往往搭配使用，效率更高，底层编译器做了优化处理,

class BBB{

     //不会导致类的加载

     public final static int n1= 999 ;

     static {

         System.out.println( "BBB静态代码块被执行" );

     }

}