又一次认识java（七） ---- final keyword

时间 2019-11-06

标签又一次认识 java final keyword 栏目 Java 繁體版

原文原文链接

你总觉得你会了，事实上你仅仅是只知其一;不知其二。html

final 关键字概览

final关键字可用于声明属性、方法、參数和类，分别表示属性不可变、方法不可覆盖、參数不可变和类不可以继承。java

咱们来分别看看它的使用方法。c++

final关键字是一个比較简单的知识点，因此这篇文章我写的比較舒服，你看着也比較舒服。因为，很是easy呀~安全

final 属性

被final修饰的属性不可变。这样的不可变的属性。咱们可以称之为“常量”。markdown

这样的常量大致上有两种表现形式。多线程

先来看如下的代码：dom

public class FinalAttribute {
    private final String attribute_a = "chengfan";

    public void test(){
        //attribute_a = "zhangbingxiao"; 不可以这样写
    }
}

这是最主要的final属性，在定义的时候初始化。并且在编译期值就已经肯定，不能改动。ide

咱们再来看一种：函数

public class FinalAttributeB {
    private final String attribute_b;

    public FinalAttributeB(String attribute_b){
        this.attribute_b = attribute_b;
    }

    public void test(){
        //attribute_b = "zhangbingxiao";
    }

    public void test(String attribute_b){
        //this.attribute_b = attribute_b;
    }
}

这样的final属性在编译期间是没法肯定属性值的。仅仅有执行的时候才干够肯定（经过构造器初始化属性）。相同，属性一经初始化后就不可以改变。因此如下的test方法都没法改动final属性。post

上一篇文章中，咱们讲了代码块，那么能不能使用代码块来初始化final属性呢？答案固然是可以的：

public class FinalAttributeB {
    private final String attribute_b;

    {
        attribute_b = "zhangbingxiao";
    }

    static {
        //attribute_b = "zhangbingxiao"; 
    }

// public FinalAttributeB(String attribute_b){
// this.attribute_b = attribute_b;
// }

}

经过构造代码块初始化final属性也是可以的，但是这样就不能再使用构造函数初始化了。因为构造代码块先于构造函数执行。

而final属性仅仅能且必须初始化一次。

你可能发现了，我写了静态代码块。但是凝视掉了。没错，因为静态代码块仅仅能初始化静态属性。咱们在文章最后再讨论它。

这样的不在定义时初始化，而使用构造函数初始化的，也称为空白final变量。它为final在使用上提供了更大的灵活性。为此，一个类中的final数据成员就可以实现依对象而有所不一样，却有保持其恒定不变的特征。

那除了构造函数，有没有别的方式也达到编译时初始化呢？固然有。比方你使用Random来初始化：

private final int attribute_c = new Random().nextInt();

这样你仅仅有在执行的时候，才知道属性值是多少。

刚刚咱们研究的都是基本数据类型。那么，引用数据类型呢？直接看代码：

public class FinalAttributeC {
    private final Person person = new Person("zhangbingxiao");

    public void change(){
        person.setName("chengfan");
        System.out.println(person.getName());
    }
   //public void change(Person p){
   //this.person = p;
   //}

    public static void main(String[] args) {
        new FinalAttributeC().change();
    }
}
//结果 ： chengfan

凝视掉的代码是会报错的代码，也就是说引用类型person是不可以被改动的。

从结果可以看出来，Person对象内部的属性被改变了。

因此，对于引用类型来讲，引用自己是不可以改变得，但是引用指向的对象是可以改变的。

引用存在于栈中，而对象存在于堆中。引用的值是对象在堆中的地址。

在本质上，final修饰的是引用，而不是对象。因此引用的那个地址不可以变，而和对象没多大关系。

举个简单的样例，一我的是一个对象，他会穿上衣。裤子，鞋子，这些事人这个对象的属性。

而人的名字是引用。当你一辈子下来，名字肯定（引用肯定）。你可以随便换衣服，但是你的名字仍是那个。

我就举个样例。别和我抬杠。

。什么可以去更名字，重名啥的。。你理解了final引用类型这个知识就行了。

final 方法

当一个方法声明为final时，该方法不能被不论什么子类重写。本类可以重载，但是子类可以使用这种方法。

public class FinalMethod {
    public final void test(){

    }

    public void test(int i){

    }
}

class Test extends FinalMethod{

    //public void test(){} 不可以重写

    @Override
    public void test(int i) {
        super.test(i);
    }
    public void test(int i,int j) {

    }
}

被final修饰的方法，不可以被重写。但是不影响本类的重载以及重载函数的重写。

这里有一种称为内联（inline）的机制，当调用一个被声明为final的方法时。直接将方法主体插入到调用处。而不是进行正常的方法调用（类似于c++的内联）。这样有利于提升程序的效率。

但是假设方法过于庞大。可能看不到内联调用带来的不论什么性能提高。在近期的Java版本号中。不需要使用final方法进行这些优化了。

final 參数

当一个方法的形參被final修饰的时候，这个參数在该方法内不可以被改动。

public class FinalParam {
    public void test(final int a ){
        //a = 10; 值不可以被改动
    }
    public void test(final Person p){
        //p = new Person("zhangbingxiao"); 引用自己不可以被改动
        p.setName("zhangbingxiao");  //引用所指向的对象可以被改动
    }
}

对于引用数据类型的改动规则同final属性同样。

final修饰參数在内部类中是很是实用的，在匿名内部类中，为了保持參数的一致性。若所在的方法的形參需要被内部类里面使用时，该形參必须为final。

这个知识会在解说内部类的时候进行具体的讨论，感兴趣的可以先自行研究。

final修饰局部变量

final修饰局部变量时仅仅能初始化(赋值)一次。可以不立刻初始化。

public class StaticPartAttr {
    public void test(){
        final int a ;
        final int b = 2;

        a = 3;
        //a = 4; 报错 
        //b = 5; 报错
    }
}

被final修饰的局部变量，仅仅能赋值一次。

你也可以一直不初始化。但是不不赋值，定义这个变量还有什么用呢？

final 类

被final修饰的类不可以被继承。所有方法不能被重写（废话，都不能继承了，哪来的重写）。但是这并不表示类内部的属性也是不可改动的，除非这个属性也被final修饰。这点在jdk里有很是多应用，比方咱们熟知的String，Integer等类都被final修饰。

final类有很是多优势，譬如它们的对象是仅仅读的，可以在多线程环境下安全的共享。不用额外的同步开销等等。

怎样写一个不可变类呢？

将类声明为final，因此它不能被继承
将所有的成员声明为私有的，这样就不一样意直接訪问这些成员
对变量不要提供setter方法
将所有可变的成员声明为final，这样仅仅能对它们赋值一次
经过构造器初始化所有成员，进行深拷贝(deep copy)
在getter方法中，不要直接返回对象自己。而是克隆对象，并返回对象的拷贝

详情—>丢个连接赶忙跑。

值得注意的是。一个类不可以既被abstract修饰又被final修饰。因为final类不可以被继承，而abstract类需要被继承。关于抽象类。咱们会在下篇文章中具体解说。

final 与 static

当final和static同一时候使用的时候，咱们所熟知的“全局常量”就出现了：一个可以处处使用并且不可以改变的属性，比方咱们熟知的Math.PI。Math.E。

上面咱们说到了静态代码块初始化final变量的问题。

public class FinalStatic {
    private final static double PI = 3.14;
    private final static double E;
    private final static double C ; //这里会报错

    static {
        E = 2.71;
    }

    public FinalStatic(double c){
        C = c;
        //PI = C; 这里会报错
    }
}

对于静态final变量，咱们可以直接初始化，或者使用静态代码块。

而不可以使用构造函数或者构造代码块。

因为static要求在编译期间就肯定值，而后放入静态区。

而构造函数和构造代码块发生在执行期间。因此不存在空白静态final。

final和private

类中所有的private方法都隐式的指定为final的，因为没法取用private方法，因此也就没法覆盖它。可以对private方法加入final修饰符，但并无加入不论什么额外意义。

总结

关于final的重要知识点

final关键字可以用于成员变量、本地变量、方法以及类。
final成员变量必须在声明的时候初始化或者在构造器中初始化，不然就会报编译错误。
你不可以对final变量再次赋值。
本地变量必须在声明时赋值。
在匿名类中所有变量都必须是final变量。
final方法不能被重写。
final类不能被继承。
接口中声明的所有变量自己是final的。
final和abstract这两个关键字是反相关的，final类就不多是abstract的。
final方法在编译阶段绑定。称为静态绑定(static binding)。
没有在声明时初始化final变量的称为空白final变量(blank final variable)。它们必须在构造器中或者代码块中初始化。
将类、方法、变量声明为final可以提升性能。这样JVM就有机会进行预计。而后优化。
依照Java代码惯例，final变量就是常量，并且通常常量名要大写。

本文内容到此结束。假设文章有错误或者你有更好的理解方式，请及时与我联系~欢迎指出错误，比較我也是个学习的人而不是大神。

转载请注明出处
本文地址：http://blog.csdn.net/qq_31655965/article/details/54800523

看完了，点个赞呗~