Java中的final关键字

1.不希望类被继承时，用final修饰
2.不希望父类的某个方法被子类重写时，用final修饰
3.不希望类的某个属性的值被修改，用final修饰
4.不希望某个局部变量被修改，用final修饰

package final_pj;

public class Final01 {

	public static void main(String[] args) {
		// TODO 自动生成的方法存根
         E e=new E();
         //e.TAX_RATE=0.09;//不能修改
	}

}
//如果我们要求A类不能被其他类继承
//可以使用final修饰A类
final class A{
	
}
//class B extends A{}

class C{
	//如果我们要求hi不能被子类重写
	//可以使用final修饰
	public final void hi()
	{
		
	}
}

//class D extends C{
//	public void hi() {
//		
//	}
//}

//当不希望类的某个属性的值被修改，可以使用final修饰
class E{
	public final double TAX_RATE =0.08;
}

//当不希望某个局部变量被修改，可以用final修饰
class F{
	public void cry()
	{
		final double NUM=0.01;
		//NUM=0.09;//不能修改
		System.out.println("NUM="+NUM);
	}
}

可以去看看韩顺平老师讲的，讲的很细（上面的代码也是跟着韩老师敲的）

1.final修饰的属性又叫常量，一般用大写命名
2.final修饰的属性在定义时，必须赋初值，并且之后不能修改，赋值的位置：
（1）.定义时
（2）.在构造器中
（3）.在代码中
3.如果final修饰属性是static的，则初始化的位置：
（1）.定义时
（2）.在静态代码块中
（3）.注意，不能在构造器中赋值
4.final类不能被继承，但是可以实例化对象（new）
5.如果不是final类，但是含有final方法，则该方法不能重写，可以被继承

package final_pj;

public class Final02 {

	public static void main(String[] args) {
		// TODO 自动生成的方法存根
           //实例化下面的CC对象
		CC cc=new CC();
		//DD类不是final类，但是含有final方法，则该方法虽然不能重写，但是可以被继承
		EE ee=new EE();
		ee.cal();
	}

}
class AA{
	
	public final double TAX_RATE=1.1;
	public final double TAX_RATE2;
	public final double TAX_RATE3;
	public AA()
	{
		TAX_RATE2=1.1;
	}
	{
		TAX_RATE3=1.1;
	}
}

class BB{
	
	public static final double TAX_RATE=9.99;
	//public static final double TAX_RATE1;
	public static final double TAX_RATE2;
//	public BB()      //类加载会直接导致静态属性和静态代码块的调用
//	{                //如果在构造器里面赋值，有可能类加载了，构造器还没有调用
//		TAX_RATE1=8.8;
//	}
	static {
		TAX_RATE2=3.3;
	}
}

//final类不可以继承，但是可以实例化对象
final class CC{
	
}
//如果类不是final类，但是含有final方法，则该方法虽然不能重写，但是可以被继承
class DD{
	public final void cal()
	{
		System.out.println("cal方法");
	}
}
class EE extends DD{
	
}

6.如果一个类是final类，就不需要将方法修饰成final方法
7.final不能修饰构造器
8.final可以和static搭配使用，不会导致类加载

package final_pj;

public class Final03 {

	public static void main(String[] args) {
		// TODO 自动生成的方法存根
        System.out.println(BBB.num);//不会导致BBB的静态代码块被加载
	}

}
一般来说，如果一个类已经是final类了，就没有必要再将方法修饰成final方法；
//final class AAA{          //该类是final类，就不能被继承，没有子类
//	public final void cry()//如果该方法是final，我们就不希望他被子类重写，可是他已经没有子类了
//	{
//		
//	}
//}

//final 不能修饰构造方法

//final和static往往搭配使用，效率更高，不会导致类加载，底层编译器做了优化处理
class BBB{
	public final static int num=10000;
	static {
		System.out.println("BBB 的静态代码块被执行");
	}
}