public ,private ,protected 及不写时的区别? final、finally和finalize的区别是什么？

最新推荐文章于 2023-04-25 13:51:54 发布
最新推荐文章于 2023-04-25 13:51:54 发布
阅读量248 收藏
点赞数
分类专栏： java 文章标签： 虚拟机 编程 F# 数据结构 Blog

一、java 作用域public ,private ,protected 及不写时的区别
在说明这四个关键字之前，我想就class之间的关系做一个简单的定义，对于继承自己的class，base class可以认为他们都是自己的子女，而对于和自己一个目录下的classes，认为都是自己的朋友。

1、public：public表明该数据成员、成员函数是对所有用户开放的，所有用户都可以直接进行调用

2、private ：private 表示私有，私有的意思就是除了class自己之外，任何人都不可以直接使用，私有财产神圣不可侵犯嘛，即便是子女，朋友，都不可以使用。

3、protected ：protected 对于子女、朋友来说，就是public的，可以自由使用，没有任何限制，而对于其他的外部class，protected 就变成private 。

作用域 当前类 同一package 子孙类 其他package

public √ √ √ √

protected √ √ √ ×

friendly √ √ × ×

private √ × × ×

不写时默认为friendly


二、final、finally和finalize的区别是什么？
final、finally和finalize虽然长得像孪生三兄弟一样，但是它们的含义和用法却是大相径庭。这一次我们就一起来回顾一下这方面的知识。

我们首先来说说final。它可以用于以下四个地方：

  1. 定义变量，包括静态的和非静态的。
  2. 定义方法的参数。
  3. 定义方法。
  4. 定义类。


我们依次来回顾一下每种情况下final的作用。首先来看第一种情况，如果final修饰的是一个基本类型，就表示这个变量被赋予的值是不可变的，即它是个常量；如果final修饰的是一个对象，就表示这个变量被赋予的引用是不可变的，这里需要提醒大家注意的是，不可改变的只是这个变量所保存的引用，并不是这个引用所指向的对象。在第二种情况下，final的含义与第一种情况相同。实际上对于前两种情况，有一种更贴切的表述final的含义的描述，那就是，如果一个变量或方法参数被final修饰，就表示它只能被赋值一次，但是JAVA虚拟机为变量设定的默认值不记作一次赋值。

被final修饰的变量必须被初始化。初始化的方式有以下几种：

  1. 在定义的时候初始化。
  2. 在初始化块中初始化。
  3. 在类的构造器中初始化。
  4. 静态变量也可以在静态初始化块中初始化。


通过下面的代码可以验证以上的观点：

Java代码 复制代码
  1. public class FinalTest{
  2. //在定义时初始化
  3. public final int A= 10 ;
  5. public final int B;
  6. //在初始化块中初始化
  7. {
  8. B= 20 ;
  9. }
  11. //静态常量，在定义时初始化
  12. public static final int STATIC_C= 30 ;
  14. public static final int STATIC_D;
  15. //静态常量，在静态初始化块中初始化
  16. static {
  17. STATIC_D= 40 ;
  18. }
  20. public final int E;
  22. public static int STATIC_F;
  24. //在构造器中初始化
  25. public FinalTest(){
  26. E= 50 ;
  27. //静态变量也可以在构造器中初始化
  28. STATIC_F= 60 ;
  30. //给final的变量第二次赋值时，编译会报错
  31. //A=99;
  32. //STATIC_C=99;
  33. }
  35. //静态变量不能在初始化块中初始化
  36. //publicstaticfinalintSTATIC_G;
  37. //{
  38. //STATIC_G=70;
  39. //}
  41. //final变量未被初始化，编译时就会报错
  42. //publicfinalintH;
  44. //静态final变量未被初始化，编译时就会报错
  45. //publicstaticfinalintSTATIC_I;
  46. } 
public class FinalTest {
	// 在定义时初始化
	public final int A = 10;

	public final int B;
	// 在初始化块中初始化
	{
		B = 20;
	}

	// 静态常量，在定义时初始化
	public static final int STATIC_C = 30;

	public static final int STATIC_D;
	// 静态常量，在静态初始化块中初始化
	static {
		STATIC_D = 40;
	}

	public final int E;

	public static int STATIC_F;

	// 在构造器中初始化
	public FinalTest() {
		E = 50;
		// 静态变量也可以在构造器中初始化
		STATIC_F = 60;

		// 给final的变量第二次赋值时，编译会报错
		// A = 99;
		// STATIC_C = 99;
	}

	// 静态变量不能在初始化块中初始化
	// public static final int STATIC_G;
	// {
	// STATIC_G = 70;
	// }

	// final变量未被初始化，编译时就会报错
	// public final int H;

	// 静态final变量未被初始化，编译时就会报错
	// public static final int STATIC_I;
}


我们运行上面的代码之后出了可以发现final变量（常量）和静态final变量（静态常量）未被初始化时，编译会报错；另外还可以发现，静态final变量可以在构造器中初始化，却不可以在初始化块中初始化。

用final修饰的变量（常量）比非final的变量（普通变量）拥有更高的效率，因此我们在实际编程中应该尽可能多的用常量来代替普通变量，这也是一个很好的编程习惯。

当final用来定义一个方法时，会有什么效果呢？正如大家所知，它表示这个方法不可以被子类重写，但是它这不影响它被子类继承。我们写段代码来验证一下：

Java代码 复制代码
  1. class ParentClass{
  2. public final void TestFinal(){
  3. System.out.println( "父类--这是一个final方法" );
  4. }
  5. }
  7. public class SubClass extends ParentClass{
  8. /**
  9. *子类无法重写（override）父类的final方法，否则编译时会报错
  10. */
  11. //publicvoidTestFinal(){
  12. //System.out.println("子类--重写final方法");
  13. //}
  15. public static void main(String[]args){
  16. SubClasssc= new SubClass();
  17. sc.TestFinal();
  18. }
  19. } 
class ParentClass {
	public final void TestFinal() {
		System.out.println("父类--这是一个final方法");
	}
}

public class SubClass extends ParentClass {
	/**
	 * 子类无法重写（override）父类的final方法，否则编译时会报错
	 */
	// public void TestFinal() {
	// System.out.println("子类--重写final方法");
	// }
	
	public static void main(String[] args) {
		SubClass sc = new SubClass();
		sc.TestFinal();
	}
}


这里需要特殊说明的是，具有private访问权限的方法也可以增加final修饰，但是由于子类无法继承private方法，因此也无法重写它。编译器在处理private方法时，是按照final方法来对待的，这样可以提高该方法被调用时的效率。不过子类仍然可以定义同父类中的private方法具有同样结构的方法，但是这并不会产生重写的效果，而且它们之间也不存在必然联系。

最后我们再来回顾一下final用于类的情况。这个大家应该也很熟悉了，因为我们最常用的String类就是final的。由于final类不允许被继承，编译器在处理时把它的所有方法都当作final的，因此final类比普通类拥有更高的效率。final的类的所有方法都不能被重写，但这并不表示final的类的属性（变量）值也是不可改变的，要想做到final类的属性值不可改变，必须给它增加final修饰，请看下面的例子：

Java代码 复制代码
  1. public final class FinalTest{
  3. int i= 10 ;
  5. public static void main(String[]args){
  6. FinalTestft= new FinalTest();
  7. ft.i= 99 ;
  8. System.out.println(ft.i);
  9. }
  10. } 
public final class FinalTest {

	int i = 10;

	public static void main(String[] args) {
		FinalTest ft = new FinalTest();
		ft.i = 99;
		System.out.println(ft.i);
	}
}


运行上面的代码试试看，结果是99，而不是初始化时的10。

接下来我们一起回顾一下finally的用法。这个就比较简单了，它只能用在try/catch语句中，并且附带着一个语句块，表示这段语句最终总是被执行。请看下面的代码：

Java代码 复制代码
  1. public final class FinallyTest{
  2. public static void main(String[]args){
  3. try {
  4. throw new NullPointerException();
  5. } catch (NullPointerExceptione){
  6. System.out.println( "程序抛出了异常" );
  7. } finally {
  8. System.out.println( "执行了finally语句块" );
  9. }
  10. }
  11. } 
public final class FinallyTest {
	public static void main(String[] args) {
		try {
			throw new NullPointerException();
		} catch (NullPointerException e) {
			System.out.println("程序抛出了异常");
		} finally {
			System.out.println("执行了finally语句块");
		}
	}
}


运行结果说明了finally的作用：

  1. 程序抛出了异常
  2. 执行了finally语句块


请大家注意，捕获程序抛出的异常之后，既不加处理，也不继续向上抛出异常，并不是良好的编程习惯，它掩盖了程序执行中发生的错误，这里只是方便演示，请不要学习。

那么，有没有一种情况使finally语句块得不到执行呢？大家可能想到了return、continue、break这三个可以打乱代码顺序执行语句的规律。那我们就来试试看，这三个语句是否能影响finally语句块的执行：

Java代码 复制代码
  1. public final class FinallyTest{
  3. //测试return语句
  4. public ReturnClasstestReturn(){
  5. try {
  6. return new ReturnClass();
  7. } catch (Exceptione){
  8. e.printStackTrace();
  9. } finally {
  10. System.out.println( "执行了finally语句" );
  11. }
  12. return null ;
  13. }
  15. //测试continue语句
  16. public void testContinue(){
  17. for ( int i= 0 ;i< 3 ;i++){
  18. try {
  19. System.out.println(i);
  20. if (i== 1 ){
  21. continue ;
  22. }
  23. } catch (Exceptione){
  24. e.printStackTrace();
  25. } finally {
  26. System.out.println( "执行了finally语句" );
  27. }
  28. }
  29. }
  31. //测试break语句
  32. public void testBreak(){
  33. for ( int i= 0 ;i< 3 ;i++){
  34. try {
  35. System.out.println(i);
  36. if (i== 1 ){
  37. break ;
  38. }
  39. } catch (Exceptione){
  40. e.printStackTrace();
  41. } finally {
  42. System.out.println( "执行了finally语句" );
  43. }
  44. }
  45. }
  47. public static void main(String[]args){
  48. FinallyTestft= new FinallyTest();
  49. //测试return语句
  50. ft.testReturn();
  51. System.out.println();
  52. //测试continue语句
  53. ft.testContinue();
  54. System.out.println();
  55. //测试break语句
  56. ft.testBreak();
  57. }
  58. }
  60. class ReturnClass{
  61. public ReturnClass(){
  62. System.out.println( "执行了return语句" );
  63. }
  64. } 
public final class FinallyTest {

	// 测试return语句
	public ReturnClass testReturn() {
		try {
			return new ReturnClass();
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			System.out.println("执行了finally语句");
		}
		return null;
	}

	// 测试continue语句
	public void testContinue() {
		for (int i = 0; i < 3; i++) {
			try {
				System.out.println(i);
				if (i == 1) {
					continue;
				}
			} catch (Exception e) {
				e.printStackTrace();
			} finally {
				System.out.println("执行了finally语句");
			}
		}
	}

	// 测试break语句
	public void testBreak() {
		for (int i = 0; i < 3; i++) {
			try {
				System.out.println(i);
				if (i == 1) {
					break;
				}
			} catch (Exception e) {
				e.printStackTrace();
			} finally {
				System.out.println("执行了finally语句");
			}
		}
	}

	public static void main(String[] args) {
		FinallyTest ft = new FinallyTest();
		// 测试return语句
		ft.testReturn();
		System.out.println();
		// 测试continue语句
		ft.testContinue();
		System.out.println();
		// 测试break语句
		ft.testBreak();
	}
}

class ReturnClass {
	public ReturnClass() {
		System.out.println("执行了return语句");
	}
}


上面这段代码的运行结果如下：

  1. 执行了return语句
  2. 执行了finally语句
  4. 0
  5. 执行了finally语句
  6. 1
  7. 执行了finally语句
  8. 2
  9. 执行了finally语句
  11. 0
  12. 执行了finally语句
  13. 1
  14. 执行了finally语句


很明显，return、continue和break都没能阻止finally语句块的执行。从输出的结果来看，return语句似乎在finally语句块之前执行了，事实真的如此吗？我们来想想看，return语句的作用是什么呢？是退出当前的方法，并将值或对象返回。如果finally语句块是在return语句之后执行的，那么return语句被执行后就已经退出当前方法了，finally语句块又如何能被执行呢？因此，正确的执行顺序应该是这样的：编译器在编译return new ReturnClass();时，将它分成了两个步骤，new ReturnClass()和return，前一个创建对象的语句是在finally语句块之前被执行的，而后一个return语句是在finally语句块之后执行的，也就是说finally语句块是在程序退出方法之前被执行的。同样，finally语句块是在循环被跳过（continue）和中断（break）之前被执行的。

最后，我们再来看看finalize，它是一个方法，属于java.lang.Object类，它的定义如下：

Java代码 复制代码
  1. protected void finalize() throws Throwable{} 
protected void finalize() throws Throwable { }


众所周知，finalize()方法是GC（garbage collector）运行机制的一部分，关于GC的知识我们将在后续的章节中来回顾。

在此我们只说说finalize()方法的作用是什么呢？

finalize()方法是在GC清理它所从属的对象时被调用的，如果执行它的过程中抛出了无法捕获的异常（uncaught exception），GC将终止对改对象的清理，并且该异常会被忽略；直到下一次GC开始清理这个对象时，它的finalize()会被再次调用。

请看下面的示例：

Java代码 复制代码
  1. public final class FinallyTest{
  2. //重写finalize()方法
  3. protected void finalize() throws Throwable{
  4. System.out.println( "执行了finalize()方法" );
  5. }
  7. public static void main(String[]args){
  8. FinallyTestft= new FinallyTest();
  9. ft= null ;
  10. System.gc();
  11. }
  12. } 
public final class FinallyTest {
	// 重写finalize()方法
	protected void finalize() throws Throwable {
		System.out.println("执行了finalize()方法");
	}

	public static void main(String[] args) {
		FinallyTest ft = new FinallyTest();
		ft = null;
		System.gc();
	}
}


运行结果如下：

  • 执行了finalize()方法


程序调用了java.lang.System类的gc()方法，引起GC的执行，GC在清理ft对象时调用了它的finalize()方法，因此才有了上面的输出结果。调用System.gc()等同于调用下面这行代码：

Java代码 复制代码
  1. Runtime.getRuntime().gc(); 
Runtime.getRuntime().gc();


调用它们的作用只是建议垃圾收集器（GC）启动，清理无用的对象释放内存空间，但是GC的启动并不是一定的，这由JAVA虚拟机来决定。直到JAVA虚拟机停止运行，有些对象的finalize()可能都没有被运行过，那么怎样保证所有对象的这个方法在JAVA虚拟机停止运行之前一定被调用呢？答案是我们可以调用System类的另一个方法：

Java代码 复制代码
  1. public static void runFinalizersOnExit( boolean value){
  2. //othercode
  3. } 
public static void runFinalizersOnExit(boolean value) {
	//other code
}


给这个方法传入true就可以保证对象的finalize()方法在JAVA虚拟机停止运行前一定被运行了，不过遗憾的是这个方法是不安全的，它会导致有用的对象finalize()被误调用，因此已经不被赞成使用了。

由于finalize()属于Object类，因此所有类都有这个方法，Object的任意子类都可以重写（override）该方法，在其中释放系统资源或者做其它的清理工作，如关闭输入输出流。

通过以上知识的回顾，我想大家对于final、finally、finalize的用法区别已经很清楚了
转自：
http://yangmingjiayou.iteye.com/blog/151865
http://www.iteye.com/topic/213051

iteye_18021
关注
专栏目录
final, finally, finalize的区别
软件之家的博客
05-10 250
final,修饰符（关键字）如果一个类被声明为final，意味着它不能再派生出新的子类，不能作为父类被继承。因此一个类不能既被声明为 abstract的，又被声明为final的。将变量或方法声明为final，可以保证它们在使用中不被改变。被声明为final的变量必须在声明时给定初值，而在以后的引用中只能读取，不可修改。被声明为final的方法也同样只能使用，不能重载finally,在异常处理时提供 finally 块来执行任何清除操作。如果抛出一个异常，那么相匹配的 catch 子句就会执行，然后控制就会进
【深入理解Java原理】final 、finally finalize 有什么不同？
王小明的专栏
05-08 257
final 、finally finalize 有什么不同？ final 可以用来修饰类、方法、变量。 final 修饰的 class 代表不可以继承扩展，final 修饰的方法标识不能被重写（override）,final 修饰的方法表示不可以修改。 finally 则是 Java 保证重点代码一定要被执行的一种机制，我们可以使用try-finally或者try-catch-finally来进行类似关闭JDBC连接、保证 unlock锁等动作 finalize 则是基础类 java.lang.Object
JAVA面试题解惑系列（四）——final、finally和finalize的区别
weixin_33898233的博客
07-08 258
final、finally和finalize的区别是什么？ 这是一道再经典不过的面试题了，我们在各个公司的面试题中几乎都能看到它的身影。final、finally和finalize虽然长得像孪生三兄弟一样，但是它们的含义和用法却是大相径庭。这一次我们就一起来回顾一下这方面的知识。 final关键字 我们首先来说说final。它可以用于以下四个地方： 定义变量，包括静态...
final,finally,finalize的区别
随我的博客
06-05 5816
final,finally,finalize的区别 1.简单区别： final用于声明属性，方法和类，分别表示属性不可交变，方法不可覆盖，类不可继承。 finally是异常处理语句结构的一部分，表示总是执行。 finalize是Object类的一个方法，在垃圾收集器执行的时候会调用被回收对象的此方法，供垃圾收集时的其他资源回收，例如关闭文件等。 中等区别： final：java中的关...
谈谈final, finally, finalize的区别
热门推荐
NiluChen的专栏
10-08 2万+
一。final 如果一个类被声明为final，意味着它不能再派生出新的子类，不能作为父类被继承。因此一个类不能既被声明为 abstract的，又被声明为final的。将变量或方法声明为final，可以保证它们在使用中不被改变。被声明为final的变量必须在new一个对象时初始化（即只能在声明变量或构造器或代码块内初始化），而在以后的引用中只能读取，不可修改。被声明为final的方法也同样只能使用
final、finally 和 finalize的区别
weixin_42022756的博客
07-23 1929
final用于声明属性，方法和类，分别表示属性不可交变，方法不可覆盖，类不可继承。 finally是异常处理语句结构的一部分，表示总是执行。 finalize是Object类的一个方法，在垃圾收集器执行的时候会调用被回收对象的此方法，供垃圾收集时的其他资源回收，例如关闭文件等。
final、finally与finalize三者的区别
weixin_44064852的博客
11-14 1036
1.简单区别： final用于声明属性，方法和类，分别表示属性不可交变，方法不可覆盖，类不可继承。 finally是异常处理语句结构的一部分，表示总是执行。 finalize是Object类的一个方法，在垃圾收集器执行的时候会调用被回收对象的此方法，供垃圾收集时的其他资源回收，例如关闭文件等。 2.中等区别： 虽然这个单词在Java中都存在，但是并没太多关联： final：java中的关键字，修饰符。A).如果一个类被声明为final，就意味着它不能再派生出新的子类，不能作为父类被继承。因此，一
面试 ｜final、finally 和 finalize 的区别？
星空下的程序猿
06-15 389
首先它们之间的关系就像雷锋和雷峰塔的关系一样，压根没关系。之所以经常放在一起被问道是因为它们长的有点像，所以下面会分别进行分析。 1 final关键字 使用：final是Java里50个关键字的一个，final关键字可以用来修饰类、成员方法和成员变量。 final修饰类表示类不可被继承，如String类； final class A{} // 编译器报错 class B extends A{} ...
Java关键字之final、finally、finalize
最新发布
catfishlyf的博客
04-25 1162
属性局部变量staticfinal是唯一一个既可修饰属性又可以修饰局部变量的修饰符运行结果。
Final,Finally, Finalize的区别
Lv_vI的博客
05-11 702
(1)final：修饰符。 A).如果一个类被声明为final，就意味着它不能再派生出新的子类，不能作为父类被继承。 B).如果将变量或者方法声明为final，可以保证它们在使用中不被改变。 C).被声明final的方法只能使用，不能重写。 (2)finally：异常处理机制的一部分 A).finally结构使代码总会执行，而不管是否有异常。 B).使用finally常用于释放资源。 (3)finalize：Java中垃圾回收器执行的方法。 A).它是一个方法，属于java.lang.Object类。 B)
final,finally,finalize的区别?
fengzijia的专栏
08-11 268
final—修饰符（关键字）如果一个类被声明为final，意味着它不能再派生出新的子类，不能作为父类被继承。因此一个类不能既被声明为 abstract的，又被声明为final的。将变量或方法声明为final，可以保证它们在使用中不被改变。被声明为final的变量必须在声明时给定初值，而在以后的引用中只能读取，不可修改。被声明为final的方法也同样只能使用，不能重载。 finally—再异常处理
final finally finalize 区别及用法
weixin_30781107的博客
03-23 147
final 1，final修饰的class，代表不可以继承扩展。 2、final的方法也是不可以重写的。 3、final修饰的变量是不可以修改的。这里所谓的不可修改对于基本类型来来，的确是不可以修改。而对于引用类型来说，只能说不能重新赋值。也就是不能改变引用地址。但是作为引用类型，它内部所包含的内容如果不是final则可以随意修改 finally 提到finally，那么try-catc...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值