Java中Final关键字的使用与注意总结

在java中可以将实例域定义为final。在构建对象是必须初始化这样的值。必须确保在每个构造器执行之后,这个域的值被设置,并且在后面的操作中不再对其修改。使用final声明变量之后,这个值就不能修改,一般final类型的变量都被声明为静态变量,而且是公有类型的,它在内存中被放在一个特有的公共区域。

也就是说,在Java语法中规定,final修饰的成员变量必须有程序员显式地指定初始值。

定义格式为: public static final double pi = 3.1415926;

final修饰符大多应用于基本类型域,或不可变类的域(如果类中的每个方法都不会改变其对象,这种类成为不可变类。比如说Java中的String类就是一个不可变类。)

如果定义了两个相同的变量,都是final类型的,这两个相同的变量名有着不同的值,其实在内存中是开辟了两个内存空间,之前定义的变量的值会被后来定义的变量的值覆盖掉。原理是变量名指向后来定义的变量值的内存空间,之前定义的变量值会被Java虚拟机根据某种特定的算法在特定的时间处理掉。

在下面的代码中详细的介绍了final类型的变量如何进行定义和初始化:

public class FinalVariableText {

	
	 //定义成员变量是指定默认值,合法
	 final int a = 6;
	 //下面变量将在构造器或初始化块中分配初始值
	 final String str;
	 final int c ;
	 final static double d;
	 //既没有指定默认值,也没有在初始化块、构造器中指定初始值
	 //下面定义的ch实例变量是不合法的
	 //final char ch;
	 
	 {
		 //在初始化块中只懂初始值,合法
		 str ="hello" ;
		 //定义a实例变量已经有初始值了,不能为a重新赋值。下面的语句是不正确的
		 //a = 9;
	 }
	
	 //静态初始化块
	 static {
		 // d是静态成员变量,必须在静态初始化块中为其指定初始值
		 d = 5.6;
		 
	 }
	//构造器,可对 没有设置初始值的成员变量设置初始值
	 //构造器必须与类名相同,这一点注意!
	 public FinalVariableText(){
		 //如果在初始化块中对str赋初值,在构造器中在为str重新赋值,是不合法的,程序会抛出错误。
		 c = 5;
	 }
	 
	 public void changeFinal() {
		 //普通方法不能为final修饰的成员变量赋值
		 //d = 1.3;
		 //也不能在普通方法中为没有设置初始值的final类型的变量赋初值
		 //ch = 'ch';
		 
	 }
	
	public static void main(String[] args) {
      
		FinalVariableText ff = new FinalVariableText();
		System.out.println(ff.a);
		System.out.println(ff.c);
		System.out.println(ff.str);
		System.out.println(ff.d);
		
	}
结果:
6
5
hello
5.6

注意:

如果打算在构造器、初始化块中对final类型的成员变量进行初始化,则不要在初始化之前访问成员变量的值,否则会引发程序报错。

final也存在局部变量的情况

系统不会对局部变量进行初始化,局部变量必须由程序员显式的进行初始化,因此使用final修饰局部变量的时候,既可以在定义是设定默认值,也可以不指定默认值。如果在定义是没有进行设定默认值,则可以在后面的代码中对该final变量赋初值,但只能一次,不可以重复赋值。当然如果在定义变量的时候就已经指定默认值,在后面的代码中就没有必要也不允许对该变量在进行赋值操作。

public void text(final int a) {
		//不能对fianl修饰的形参进行赋值操作
		//a = 5; 该语句是不合法的
	}
	public static void main(String[] args) {
        //定义final局部变量时,指定初始值,则该变量再无法进行赋值了
		final String str = "str";
		//下面的语句会报错,不合法
		//str = "Java";
		//定义final变量没有指定默认值,则可以被赋值一次
		final int d;
		d = 5;
		//再对d进行新的赋值,不合法
		// d = 8;
		
	}

Final修饰基本类型变量和引用类型的变量的区别

Final修饰基本类型变量上面已经讲述的很清楚了,那引用类型的变量会有什么不同呢?对于引用类型的变量而言,它仅仅是保存了一个引用关系,final只保证这个引用类型变量所引用的地址不会改变,即一直引用同一个对象,但这个对象完全可以发生改变。下面通过代码来验证一下:

class Person1{
	
	private int age;
	//有一个参数的构造函数
	public 	Person1(int age) {
		this.age = age;	
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
}

public class FinalReferenceText {

	public static void main(String[] args) {
      
        final int [] arr = {5,6,12,9};
        System.out.println(Arrays.toString(arr));
        Arrays.sort(arr);
        System.out.println(Arrays.toString(arr));
        arr[2] = -8;
        System.out.println(Arrays.toString(arr));
        //下面对arr重新赋值,非法
        //arr = null;
        //final 修饰Person变量,p是一个引用变量
       final Person1 p = new Person1(45);
        //改变Person对象的实例变量,合法
        p.setAge(55);
        System.out.println(p.getAge());
        //下面对p重新赋值,非法
        //p = null;
	}

}
结果:
[5, 6, 12, 9]
[5, 6, 9, 12]
[5, 6, -8, 12]
55

final方法

Final修饰的方法不可被重写,如果处于某种原因,不希望子类重写父类的某个方法,则可以使用final关键字修饰该方法。

如果父类中的方法的是公有的,则子类中不能有一个一样方法名,一样参数的方法,但如果父类中的方法是私有的,那么子类中完全可以写一个一样的方法。

对于private类型的方法,由于其只能在当前类中可见,其子类无法访问到该方法,所以子类无法重写该方法,那么,如果子类中存在一个与父类private方法有相同方法名,一样的参数列表,相同的返回值的方法,也不是方法的重写,只是重新定义了一个新的方法。因此,final修饰一个private方法,依然可以在其子类中定义和父类private类型一样的方法,不会有程序错误。

public class PrivateFinalText{
   
  //如果将访问修饰符改成public,则其子类中的方法定义在程序编译时会报错
  private final void text();

}

class Sub extends PrivateFinalText{
   //下面的方法完全没有问题
   public void text();
}

以上是我目前对Java中final关键字的总结,稍后会有补充!!!

收藏 (0)
评论列表
正在载入评论列表...
我是有底线的