精华内容
下载资源
问答
  • 在Java中关于final关键字的说法,正确的有()。 A)如果修饰变量,则一旦赋了值,就等同一个常量 B)如果修饰类,则该类只能被一个子类继承 C)如果修饰方法,则该方法不能子类被覆盖 D)如果修饰方法,则该...

    在Java中,关于final关键字的说法,正确的有()。 
    A)如果修饰变量,则一旦赋了值,就等同一个常量
    B)如果修饰类,则该类只能被一个子类继承
    C)如果修饰方法,则该方法不能在子类中被覆盖
    D)如果修饰方法,则该方法所在的类不能被继承

     

    这道题选C.

    final修饰类中的方法

    作用:可以被继承,但继承后不能被重写。排除D
    final修饰类
    作用:类不可以被继承。排除B

    而引用类型变量里面放的是个地址,所以用final修饰引用类型变量指的是它里面的地址不能变,并不是说这个地址所指向的对象或数组的内容不可以变,这个一定要注意。
    例如:类中有一个属性是final Person p=new Person("name"); 那么你不能对p进行重新赋值,但是可以改变p里面属性的值,p.setName('newName');排除A

    展开全文
  • final修改类时:该类成为最终类,无法被继承。简称为“断子绝孙类”。 final修饰方法时:这个方法将成为最终方法,无法被子类重写。但是,该方法仍然可以被继承。 final修饰变量时: 1、如果修饰的是基本类型,说明...

    final修改时:该类成为最终类,无法被继承。简称为“断子绝孙类”。

    final修饰方法时:这个方法将成为最终方法,无法被子类重写。但是,该方法仍然可以被继承。

    final修饰变量时:
    1、如果修饰的是基本类型,说明这个变量的所代表数值永不能变(不能重新赋值)
    2、如果修饰的是引用类型引用类型,该变量的引用不能变,但引用所代表的对象内容是可变的
    在这里插入图片描述
    final不能修饰抽象类因为抽象类需要被继承才有作用,而final修饰的类不能被继承
    在这里插入图片描述
    final不能用来修饰构造器:因为构造方法既不能被继承,也不能被重写,用final修饰毫无意义
    在这里插入图片描述
    final修饰的成员变量必须在声明的时候初始化或者在构造器中初始化,否则就会报编译错误。
    在这里插入图片描述
    final修饰的局部变量必须声明时赋值,如果不赋值,虽然声明是不会出错,但调用时会编译出错
    在这里插入图片描述
    final关键字的好处

    1. final关键字提高了性能。JVM和Java应用都会缓存final变量。
    2. final变量可以安全的在多线程环境下进行共享,而不需要额外的同步开销。
    3. 使用final关键字,JVM会对方法、变量及类进行优化。

    创建不可变类要使用final关键字。不可变类是指它的对象一旦被创建了就不能被更改了。String是不可变类的代表。不可变类有很多好处,譬如它们的对象是只读的,可以在多线程环境下安全的共享,不用额外的同步开销等等。

    展开全文
  • 对于final修饰的变量,引用不可以变,对象不可以变,也就是final修饰的变量一开始就要进行赋值初始化,注意:静态final成员变量不可以再构造函数被初始化;final修饰的类,这个类不允许其被继承,类的所有方法不...

    final主要是用来声明属性(属性不可变)、方法(方法不可覆盖)和类(类不可以继承),对于final修饰的变量,引用不可以变,对象不可以变,也就是final修饰的变量一开始就要进行赋值初始化,注意:静态final成员变量不可以再构造函数中被初始化;final修饰的类,这个类不允许其被继承,类中的所有方法不能被重写,但是并不意味这final修饰的类中的成员变量不可变,除非final修饰的类中的成员变量使用final进行了修饰;

    注意:一个类不能既被修饰为abstract又被修饰为final


    finally作为异常的一部分,修饰的代码段一定会被执行,常用来进行释放资源。


    finalize是属于Object类的一个方法,在垃圾回收器执行时会调用被回收对象的额finalize()方法,可以覆盖此方法来实现对其他资源的释放,比如关闭文件,一旦垃圾回收器准备好释放对象占用的空间,将首先调用finalize()方法,并且在下一次垃圾回收动作发生时,才会正真回收对象占用的内存。


    常见的一般比较基本的类型为防止扩展类无意间破坏原来方法的实现的类型都应该使用final来进行修饰,比如String、StringBuffer都是的

    展开全文
  • Java中final

    2017-03-04 10:27:11
    这几天,网上找了一些关于final的知识,当然并不全面,有的一时也没有很好的理解,先收集起来,理理思路,把不懂的画出来,以便更好地学习…… Java中final关键字通常的指的是“这是无法改变的”。它可能被做...

    这几天,在网上找了一些关于final的知识,当然并不全面,有的一时也没有很好的理解,先收集起来,理理思路,把不懂的画出来,以便更好地学习……

    Java中的final关键字通常的指的是“这是无法改变的”。它可能被做为三种的修饰词.------数据(基本类型,对象或者数组),方法(类方法、实例方法),类。

    <1>final应用于类

    如果类被声明为final,则表示类不能被继承,也就是说不能有子类。因为不能有子类,所以final类不能被声明为abstract抽象类。所以final关键字和abstract关键字不能同时使用。

    一个final类中的所有方法都隐式地指定为final

    <2>final应用于类方法

    使用final使用的原因有两个:
    一. 把方法锁定,使得在子类(导出类)中不能修改它的含义。
    二.效率,一个final方法被调用时会转为内嵌调用,不会使用常规的压栈方式,使得运行效率较高,尤其是在方法体较简单的 情 况下,但也并不绝对。(与C++中的inline关键字类似)


    类的方法分为“类方法”(类中static方法)和“实例方法”(类中非static方法)。不管是类方法还是实例方法,只要被声明为final,就表示不能被子类“覆盖”或“隐藏”,也就是不能在子类中声明为“一模一样”的方法。

    特别的:类中的所有private方法都隐式地指定为是final,所以在继承关系中不存在覆盖问题。

    <3>final应用于类属性

    类中的属性,也分为“类属性”(静态属性)和“实例属性”(非静态属性)。不管是静态属性还是非静态属性,只要被声明为final,则属性的值只能被指定一次(也就是说初始化后就不能再给属性赋值),而且必须进行“显示初始化”。

    对于类的静态属性,可以完成显示初始化的地方有两个:一个是在声明静态属性的时候就进行初始化;另一个,也可以在“静态初始化块”中进行初始化。

    对于类的非静态属性,可以完成显示初始化的地方有三个:一个是在声明属性的时候就进行初始化;另一个,也可以在“初始化块”中进行初始化;还可以在构造方法中进行初始化。

    需要注意的是,在“静态初始化块”中不能访问“实例属性”,那当然就不能完成“实例属性”的“显示初始化”任务了;在“初始化块”中能访问“类属性”,但是不能完成“类属性”的“显示初始化”任务,类属性的显示初始化应该在“静态初始化块”中。

    如果final属性在声明的时候没有进行初始化,我们管这种final叫做“空白final”。但必须确保空白final在使用前被初始化,一般在构造方法完成。

    注:在类中,如果类的属性(包括类属性和实例属性)没有被final所修饰,那么即使我们没有进行“显示初始化”,那么编译器也会给他们进行默认初始化。而对于final属性我们必须进行“显示初始化”。

    <4>final应用于方法参数或变量

    final也可以修饰方法参数或变量。

    final变量可以在声明的时候不进行“显示初始化”,(而且只要不对它进行使用,就不会报编译错误,但是既然不使用,这个变量也就没什么用,显然是多余的),只要在使用之前进行初始化就行了,这个特性和普通的变量是一样的。

    方法参数被声明为final,表示它是只读的。

    注意:方法中的变量可以声明为final,但是不能声明为static,不管这个方法是静态的还是非静态的


    在谈final之前我们现看一个最简单的程序:

    Class Main{

    public String a=Test.aa;


    public String b=Test.bb;


    public static void main(String args[]){      ....

    }

    }

    Class Test{

    public final static String aa="HelloA";


    public final static String bb=new String("HelloB");


    }

    大家肯定要问了,Main中的a 和 b 到底有什么区别?


    我们先什么都不说,看一下反编译的结果。


    zheng@zheng-laptop:~/workspace/Test/src$ javap -c Main 
    Compiled from "Main.java"
    public class Main extends java.lang.Object{
    public java.lang.String MainA;
    public java.lang.String MainB;
    public Main();
    Code:
    0: aload_0
    1: invokespecial #1; //Method java/lang/Object."<init>":()V
    4: aload_0
    5: ldc #2; //String HelloA
    7: putfield #3; //Field MainA:Ljava/lang/String;
    10: aload_0
    11: getstatic #4; //Field Test.bb:Ljava/lang/String;
    14: putfield #5; //Field MainB:Ljava/lang/String;
    17: return
    public static void main(java.lang.String[]);
    Code:
    0: return
    }


    在第5行java进行了一次值赋值,所以就直接霸HelloA给Main.a了。 而在第11行,java则是传给b一个Object,也就是将Test.bb给了Main.b;

    这是为什么了,C++中说 const其中一个功能就是为了加快编译速度,的确值赋值加快了编译的速度(java应该也是这么做的)

    final放在什么内存中等把JVM搞懂了,再来补上!


    但是这可能会引发一个问题,如果修改aa的值,并且就编译Test.java,Main中的a还是原来的”HelloA“,没有改变,因为final在这种情况下是直接赋值的。

    对与java中的final变量,java编译器是进行了优化的。每个使用了final类型变量的地方都不会通过连接而进行访问。比如说Test类中使用了Data类中一个final的int数字fNumber=77,这时候,java编译器会将77这个常数编译到Test类的指令码或者常量池中。这样,每次Test类用到fNumber的时候,不会通过引用连接到Data类中进行读取,而是直接使用自己保存在类文件中的副本。
    用程序说话:
    Test.java:

    public class Test{
    public static void main(String[] args){
    System.out.println(Data.fNumber);
    }
    }


    Data.java:

    public class Data{
    public static final int fNumber=77; 
    }

    执行命令和结果:

    Microsoft Windows XP [版本 5.1.2600]
    (C) 版权所有 1985-2001 Microsoft Corp.

    C:\Documents and Settings\zangmeng>cd ..

    C:\Documents and Settings>cd ..

    C:\>javac Test.java

    C:\>Java Test
    77

    C:\>


    这时候,我们更改Data.java的内容:
    public class Data{
    public static final int fNumber=777; 
    }

    然后执行如下命令:

    C:\>javac Data.java

    C:\>java Test
    77

    C:\>

    这里我们看到,虽然Data.java中的fNumber已经更改为777,而且已经重新编译了,但是因为编译器把fNumber的副本保存Test类中,所以在重新编译Test类的前,Test类一直把fNumber认为是77而不是777。下面我们变异Test.java,再执行,看看结果。

    C:\>javac Test.java

    C:\>java Test
    777

    C:\>
    这时候,我们看到,重新编译的Test类将新的777数值封装到了自己类中。

    整个过程如下:
    Microsoft Windows XP [版本 5.1.2600]
    (C) 版权所有 1985-2001 Microsoft Corp.

    C:\Documents and Settings\zangmeng>cd ..

    C:\Documents and Settings>cd ..

    C:\>javac Test.java

    C:\>java Test
    77
    //在这里改变了Data.java的内容
    C:\>javac Data.java

    C:\>java Test
    77

    C:\>javac Test.java

    C:\>java Test
    777

    C:\>


    这个是java编译器的优化,具体的,大家可以继续参考http://www.blogjava.net/aoxj/archive/2009/11/10/165536.html

    另外java的final还有inline的功能,这个和C++有异曲同工之妙。简单的来说就是内联函数就是指函数在被调用的地方直接展开,编译器在调用时不用像一般函数那样,参数压栈,返回时参数出栈以及资源释放等,这样提高了程序执行速度。

    但 是网上有人说这样并没有加快速度,这是为什么呢?还不太清楚!!



    final使得被修饰的变量"不变",但是由于对象型变量的本质是“引用”,使得“不变”也有了两种含义:引用本身的不变,和引用指向的对象不变。

    引用本身的不变:
    final StringBuffer a=new StringBuffer("immutable");
    final StringBuffer b=new StringBuffer("not immutable");
    a=b;//编译期错误

    引用指向的对象不变:
    final StringBuffer a=new StringBuffer("immutable");
    a.append(" broken!"); //编译通过

    可见,final只对引用的“值”(也即它所指向的那个对象的内存地址)有效,它迫使引用只能指向初始指向的那个对象,改变它的指向会导致编译期错误。至于它所指向的对象的变化,final是不负责的。这很类似==操作符:==操作符只负责引用的“值”相等,至于这个地址所指向的对象内容是否相等,==操作符是不管的。

    Java的局部内部类以及final类型的参数和变量

    本文是Thinking In Java中其中一段的阅读总结。如果定义一个匿名内部类,并且希望它使用一个在其外部定的对象,那么编译器会要求其参数引用是final 的。经研究,Java虚拟机的实现方式是,编译器会探测局部内部类中是否有直接使用外部定义变量的情况,如果有访问就会定义一个同类型的变量,然后在构造方法中用外部变量给自己定义的变量赋值。

    Thinking In Java里面的说法(唯一正确的说法): 如果定义一个匿名内部类,并且希望它使用一个在其外部定的对象,那么编译器会要求其参数引用是final 的。

    public class Tester {

    public static void main(String[] args) {

    A a = new A();

    C c = new C();

    c.shoutc(a.shout(5));

    } }

    class A {

    public void shouta() {

    System.out.println("Hello A");

    }

    public A shout(final int arg) {

    class B extends A {

    public void shouta() {

    System.out.println("Hello B" + arg);

    } }

    return new B();

    } }

    class C {

    void shoutc(A a) {

    a.shouta();

    } } 

    c.shoutc(a.shout(5)),在a.shout(5)得到返回值后,a的shout()方法栈被清空了,即arg不存在了,而c.shoutc()却又调用了a.shouta()去执行System.out.println("Hello B" + arg)。

    再来看Java虚拟机是怎么实现这个诡异的访问的:有人认为这种访问之所以能完成,是因为arg是final的,由于变量的生命周期,事实是这样的吗?方法栈都不存在了,变量即使存在,怎么可能还被访问到?试想下:一个方法能访问另一个方法的定义的final局部变量吗(不通过返回值)?

    研究一下这个诡异的访问执行的原理,用反射探测一下局部内部类 。编译器会探测局部内部类中是否有直接使用外部定义变量的情况,如果有访问就会定义一个同类型的变量,然后在构造方法中用外部变量给自己定义的变量赋值,而后局部内部类所使用的变量都是自己定义的变量,所以就可以访问了。见下:

    class A$1$B {

    A$1$B(A, int);

    private final int var$arg;

    private final A this$0;


    A$1$B类型的对象会使用定义的var$arg变量,而不是shout()方法中的final int arg变量,当然就可以访问了。

    那么为什么外部变量要是final的呢?即使外部变量不是final,编译器也可以如此处理:自己定义一个同类型的变量,然后在构造方法中赋值就行了。原因就是为了让我们能够挺合逻辑的直接使用外部变量,而且看起来是在始终使用 外部的arg变量(而不是赋值以后的自己的字段)。

    考虑出现这种情况:在局部内部类中使用外部变量arg,如果编译器允许arg不是final的,那么就可以对这个变量作变值操作(例如arg++),根据前面的分析,变值操作改变的是var$arg,而外部的变量arg并没有变,仍然是5(var$arg才是6)。因此为了避免这样如此不合逻辑的事情发生:你用了外部变量,又改变了变量的值,但那个变量却没有变化,自然的arg就被强行规定必须是final所修饰的,以确保让两个值永远一样,或所指向的对象永远一样(后者可能更重要)。

    还有一点需要注意的是内部类与方法不是同时执行的,比如实现ActionListener,只有当事件发生的时候才会执行,而这时方法已经结束了。

    也有人这样说
    匿名内部类要访问局部变量,但是函数的局部变量在执行完后会立即退出,销毁掉所有临时变量。而产生的匿名内部类可能会保留。在java中方法不是对象,不存储状态,这时候匿名内部类已经没有外部环境了。我猜想匿名内部类可能会把需要访问的外部变量作为一个隐藏的字段,这样只是得到了一个变量的引用拷贝,所以是只读的,所以编译器要求给要访问的外部局部变量加final。

    可以用一个包装对象来突破这一限制。
    final Result result=new Result();
    sqlMaker.selectById(id).execute(getTransaction(),new Function(){
    public Object call(Object... args) {
    ResultSet rs=(ResultSet)args[0];
    Object obj=sqlMaker.getTable().readFirstObject(rs);
    result.setValue(obj);
    return null;
    }});
    T r= (T)result.getValue();


    理解final问题有很重要的含义。许多程序漏洞都基于此----final只能保证引用永远指向固定对象,不能保证那个对象的状态不变。在多线程的操作中,一个对象会被多个线程共享或修改,一个线程对对象无意识的修改可能会导致另一个使用此对象的线程崩溃。一个错误的解决方法就是在此对象新建的时候把它声明为final,意图使得它“永远不变”。其实那是徒劳的


    请教大家个问题,想了好久也不明白,为什么在某方法内定义一个匿名内部类,并且希望它使用外部定义的对象,那么要求此方法的参数引用要声明为final?(我只知道final的作用对于对象引用来説,此对象引用不能指向新的对象,对于基本类型就是不能改变它的值) 

    因为内部要copy一份自己使用,怕你在外边改了造成一些不确定的问题。所以干脆final

    http://forums.sun.com/thread.jspa?threadID=5325241&messageID=10392871


    这是一个编译器设计的问题,如果你了解java的编译原理的话很容易理解。 
    首先,内部类被编译的时候会生成一个单独的内部类的.class文件,这个文件并不与外部类在同一class文件中。 
    当外部类传的参数被内部类调用时,从java程序的角度来看是直接的调用例如: 
    public void dosome(final String a,final int b){ 
    class Dosome{public void dosome(){System.out.println(a+b)}}; 
    Dosome some=new Dosome(); 
    some.dosome(); 

    从代码来看好像是那个内部类直接调用的a参数和b参数,但是实际上不是,在java编译器编译以后实际的操作代码是
    class Outer$Dosome{ 
    public Dosome(final String a,final int b){ 
    this.Dosome$a=a; 
    this.Dosome$b=b; 

    public void dosome(){ 
    System.out.println(this.Dosome$a+this.Dosome$b); 

    }} 
    从以上代码看来,内部类并不是直接调用方法传进来的参数,而是内部类将传进来的参数通过自己的构造器备份到了自己的内部,自己内部的方法调用的实际是自己的属性而不是外部类方法的参数。 
    这样理解就很容易得出为什么要用final了,因为两者从外表看起来是同一个东西,实际上却不是这样,如果内部类改掉了这些参数的值也不可能影响到原参数,然而这样却失去了参数的一致性,因为从编程人员的角度来看他们是同一个东西,如果编程人员在程序设计的时候在内部类中改掉参数的值,但是外部调用的时候又发现值其实没有被改掉,这就让人非常的难以理解和接受,为了避免这种尴尬的问题存在,所以编译器设计人员把内部类能够使用的参数设定为必须是final来规避这种莫名其妙错误的存在。 

    实现的确是如此,不过final只是让一个引用不能修改而已,照样可以修改它指向的数据的内容。 

    再 一次阐述 内部类,final

    1)所谓“局部内部类”就是在对象的方法成员内部定义的类。而方法中的类,访问同一个方法中的局部变量,是天经地义的。那么为什么要加上一个final呢? 
    2)原因是:编译程序实现上的困难,难在何处:内部类对象的生命周期会超过局部变量的生命期。为什么?表现在:局部变量的生命期:当该方法被调用时,该方法中的局部变量在栈中被创建(诞生),当方法调用结束时(执行完毕),退栈,这些局部变量全部死亡。而:内部类对象生命期,与其它类一样,当创建一个该局部类对象后,只有没有其它人再引用它时,它才能死亡。完全可能:一个方法已调用结束(局部变量已死亡),但该局部类的对象仍然活着。即:局部类的对象生命期会超过局部变量。 
    3)退一万步:局部类的对象生命期会超过局部变量又怎样?问题的真正核心是:如果:局部内部类的对象访问同一个方法中的局部变量,是天经地义的,那么:只要局部内部类对象还活着,则:栈中的那些它要访问的局部变量就不能“死亡”(否则:它都死了,还访问个什么呢?),这就是说:局部变量的生命期至少等于或大于局部内部类对象的生命期。而:正是这一点是不可能做到的
    4)但是从理论上:局部内部类的对象访问同一个方法中的局部变量,是天经地义的。所以:经过努力,达到一个折中结果:即:局部内部类的对象可以访问同一个方法中的局部变量,只要这个变量被定义为final.那么:为什么定义为final变可以呢?定义为final后,编译程序就好实现了:具体实现方法是:将所有的局部内部类对象要访问的final型局部变量,都成员该内部类对象中的一个数据成员。这样,即使栈中局部变量(含final)已死亡,但由于它是final,其值永不变,因而局部内部类对象在变量死亡后,照样可以访问final型局部变量。

    不管变量是不是final,他的生命周期都在于{}中。

    不管对象是不是final,他的生命周期都是 new开始,垃圾回收结束。 

    类对象(class对象)与其它对象不同,类对象的生命周期 开始于类被加到内存中那一刻,结束于垃圾回收。 
    类变量(static)与类对象的生命周期相同。


    解析就是对于编译型常量使用直接的内存地址代替变量,如final static int a = 10;但是对于在编译的时候不能得到具体值得变量不做变换,如final static int a = Math.random()。


    final和abstract一样,都是非访问控制符,当然也不会改变作用域 protect,private,public才是访问控制符

    展开全文
  • Java中final关键字-----(java复习)

    千次阅读 2016-03-23 13:52:39
    谈到final关键字,想必很多人都不陌生,使用匿名内部类的时候可能会经常用到final关键字。另外,Java中的String类就是一个final类,那么今天我们就来了解final这个关键字的... 在Java中final关键字可以用来修饰类
  • 另外,Java中的String类就是一个final类,那么今天我们就来了解final这个关键字的用法。下面是本文的目录大纲:  一.final关键字的基本用法  二.深入理解final关键字  若有不正之处,请多多谅解并欢迎指正。 ...
  • 深入理解 Java final 关键字

    千次阅读 多人点赞 2019-10-28 00:27:18
    finalJava 重要关键字之一,可以应用于...final Java 是一个保留的关键字,可以声明成员变量、方法、类以及本地变量。一旦你将引用声明作 final,你将不能改变这个引用了,编译器会检查代码,如果试图将变...
  • 谈谈Java中final关键字

    万次阅读 2018-07-18 20:19:14
    在Java中final关键字可以用来修饰类、方法和变量(包括成员变量和局部变量)。下面就从这三个方面来了解一下final关键字的基本用法。 1.修饰类  当用final修饰一个类时,表明这个类不能被继承。也就是说,如果...
  • Java中final详解以及用途实战

    千次阅读 2015-06-02 13:49:34
    浅析Java中final关键字  谈到final关键字,想必很多人都不陌生,使用匿名内部类的时候可能会经常用到final关键字。另外,Java中的String类就是一个final类,那么今天我们就来了解final这个关键字的用法。下面...
  • 每天一个知识点(一)final java 有什么作用?
  • 另外,Java中的String类就是一个final类,那么今天我们就来了解final这个关键字的用法。下面是本文的目录大纲: 一.final关键字的基本用法 二.深入理解final关键字 若有不正之处,请多多谅解并欢迎指正。 请尊重...
  • Java中final关键字

    2016-05-15 17:47:27
    另外,Java中的String类就是一个final类,那么今天我们就来了解final这个关键字的用法。下面是本文的目录大纲:  一.final关键字的基本用法  二.深入理解final关键字  若有不正之处,请多多谅解并欢迎指正。  请...
  • java中final关键字详解

    2015-07-23 10:48:57
    谈到final关键字,想必很多人都不陌生,使用匿名内部类的时候可能会经常用到final关键字。另外,Java中的String类就是一个final类,那么今天我们就来了解final这个关键字的用法... 在Java中final关键字可以用来修
  • 浅析Java中final关键字  谈到final关键字,想必很多人都不陌生,使用匿名内部类的时候可能会经常用到final关键字。另外,Java中的String类就是一个final类,那么今天我们就来了解final这个关键字的用法。下面...
  • Java语言浅析final关键字

    多人点赞 2018-08-07 16:59:45
    另外,Java中的String类就是一个final类,那么今天我们就来了解final这个关键字的用法。下面是本文的目录大纲:  一.final关键字的基本用法  二.深入理解final关键字  若有不正之处,请多多谅解并欢迎指正。 ...
  • https://www.cnblogs.com/dolphin0520/p/3736238.html浅析Java中final关键字 谈到final关键字,想必很多人都不陌生,使用匿名内部类的时候可能会经常用到final关键字。另外,Java中的String类就是一个final类,...
  • 在Java面向对象编程final关键字大家应该都知道,匿名内部类使用时可能经常用到。Java中的String类就用了final关键字。final关键字可以用来修饰类、方法和变量(包括成员变量和局部变量),下面看一下final关键字...
  • java-final关键字

    2018-06-19 13:35:50
    在Java中final关键字可以用来修饰类、方法和变量(包括成员变量和局部变量)  final会告诉编译器,这个数据是不会修改的,那么编译器就可能会编译时期就对该数据进行替换甚至执行计算,这样可以对我们的程序起...
  • java中final的意义

    千次阅读 2011-07-08 16:32:35
    final变量的定义本身并...c++它是一个const指针,而不是指向const变量的指针,const指针的意思是说它只能一直指向初始化时的那个地址.但那个地址对象本身是可以修改的.而指向const变量的指针是说所指对象本身是不能

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 25,546
精华内容 10,218
关键字:

在java中关于final的说法

java 订阅