Java的关键字final通常是指被它修饰的数据是不能被改变的,不想改变可能出于两种理由:设计或效率。主要特性:
* final数据的使用
* final参数的使用
* final方法的使用
* final类不能被继承
### final数据
**1.1 final修饰变量**
final 变量一经初始化,就不能改变其值
这里的值对于一个对象或者数组来说指的是这个对象或者数组的引用地址。因此,一个线程定义了一个final变量之后,其他任意线程都拿到这个变量。但有一点需要注意的是,当这个final变量为对象或者数组时,虽然我们不能讲这个变量赋值为其他对象或者数组,但是我们可以改变对象的域或者数组中的元素;
> final域能确保初始化过程的安全性,从而可以不受限制地访问不可变对象,并在共享这些对象时无须同步;
线程对这个对象变量的域或者数据的元素的改变不具有线程可见性;
所以final修饰的变量必须被初始化
```
public static final String LOAN = "loan";
LOAN = new String("loan") //invalid compilation error
```
final变量初始化时机:
* 定义时初始化
* 初始化块中,但不可在静态初始化块中,静态的final实例变量才可以在静态初始化块中
* 构造方法中,但静态final实例变量不可以在其中
特性
* 修饰的变量是基本数据类型:告知编译器这一块数据是不变的,这样可以在执行计算时,减少一些运行时的负担;
* final变量必须在声明时被初始化;
* final实例变量必须在所有的构造函数末尾初始化;
* 在JMM中要求final域的初始化动作必须在构造方法return之前完成;
```
package com.quancheng;
import java.util.Random;
public class FinalTest {
private static Random random = new Random(20);
private final int VALUE_A = 10;
private static final int VALUE_B = 20;
public static final int VALUE_C = random.nextInt(10);
public final int VALUE_D = random.nextInt(10);
public static void main(String[] args) {
FinalTest test = new FinalTest();
//test.VALUE_A = 5;//Error:不可以这样做
//test.VALUE_B =21;//Error:不可以这样做
FinalTest finalT = new FinalTest();
FinalTest finalT1 = new FinalTest();
System.out.println("VALUE_C:"+VALUE_C);
System.out.println("VALUE_C:"+finalT.VALUE_C);
System.out.println("VALUE_C:"+finalT1.VALUE_C);
System.out.println("---------");
System.out.println("VALUE_D:"+finalT.VALUE_D);
System.out.println("VALUE_D:"+finalT1.VALUE_D);
}
}
output==>
VALUE_C:3
VALUE_C:3
VALUE_C:3
---------
VALUE_D:1
VALUE_D:1
```
以上结果得出一点我们不能因为某数据时final的就认为在编译时可以知道它的值。在运行时使用随机生成的VALUE\_C和VALUE\_D说明了这一点。示例代码展示了final数值定义为static和非static的区别。此区别只有当数值在运行时内被初始化时才会显现,这是因为编译器对编译时数值一视同仁(并且他们可能因为优化而消失)。使用static final 的数值是不可以通过一个新的对象而改变的。这是因为在装载时已经被初始化,而不是每次创建新对象时初始化。
**1.2 final用于引用**
当使用final用于对对象的引用而不是基本类型时,对于基本类型final使数值恒定不变,而对于对象引用,final使引用恒定不变。一旦引用被初始化指向一个对象,就无法再把它改为指向另一个对象。然而,对象自身的数据是可以修改的
```
package com.game.lll;
public class FinalTest {
private final int a = 10;
private final Value v1 = new Value(10);
public static void main(String[] args) {
FinalTest test = new FinalTest();
//test.a = 5;//不可以这样做
test.v1.value++;
//test.v1 = new Value(12);//Error:不可以这样做
System.out.println("对象内的数据:"+test.v1.value);
}
class Value{
int value;
public Value(int value) {
this.value = value;
}
}
}
```
**1.3 final用于数组**
final用于数组和引用时一样的,数组只不过是另一种引用,对于这个变量的引用是不能被重新赋值,但是对象本身是可以修改的。代码如下:
```
package com.game.lll;
public class FinalTest {
private final Value v1 = new Value(10);
private final int[] values = { 1, 2, 3, 4, 5, 6 };
public static void main(String[] args) {
FinalTest test = new FinalTest();
//test.a = 5;//不可以这样做
test.v1.value++;
//test.v1 = new Value(12);//Error:不可以这样做
test.values[0] = 100;//对象本身是可以修改的
for(int i = 0; i < test.values.length;i++){
System.out.println(test.values[i]++);//对于这个变量的引用是不能被重新赋值
}
}
class Value{
int value;
public Value(int value) {
this.value = value;
}
}
}
```
**1.4 空白final**
Java允许生成“空白final”,空白final是指被声明为final但又给未定初值的域。代码如下:
```
package com.game.lll;
public class BlankFinal {
private final int a;
public BlankFinal(int i)
{
this.a = i;
}
public static void main(String[] args) {
BlankFinal blankFinal = new BlankFinal(5);
System.out.println(blankFinal.a);
}
}
```
虽然未对a直接赋值,但是在构造函数中对a进行了初始化。所以无论什么情况,都要确保final在使用前被初始化
> 在JMM中要求final域的初始化动作必须在构造方法return之前完成
### final方法
使用final方法的原因是把方法锁定,以防任何继承类修改它的含义。final声明的方法不能被重写;
* 当调用final方法时,直接将方法主体插入到调用处,而不是进行方法调用,这样能提高程序效率\(内联机制\)
* 如果你认为一个方法的功能已经足够完整了,子类中不需要改变的话,你可以声明此方法为final
* final方法比非final方法快,因为在编译时候已静态绑定了,不需要在运行时再动态绑定
```
class PersonalLoan{
public final String getName(){
return "personal loan";
}
}
class CheapPersonalLoan extends PersonalLoan{
@Override
public final String getName(){
return "cheap personal loan"; //compilation error: overridden method is final
}
}
```
### final类
当你将某个类定义为final class时,那么子类就无法继承该类
思考一个有趣的现象:
```
byte b1=1;
byte b2=3;
byte b3=b1+b2; //当程序执行到这一行的时候会出错,因为b1、b2可以自动转换成int类型的变量,运算时java虚拟机对它进行了转换,结果导致把一个int赋值给byte
final byte b1=1;
final byte b2=3;
byte b3=b1+b2; //不会出错,相信你看了上面的解释就知道原因了。
```
### 其它特性
* final变量一经初始化,就不能改变其值;
* final变量应该全部应用大写(编码规则);
* final类的所有方法为隐式的final方法;
* 类不能同时被声明为final和abstract;
### 知识点
* 为何System类中的out/err可以更改值
```
public final static InputStream in = null;
public final static PrintStream out = null;
public final static PrintStream err = null;
```
setOut/setIn/setErr是native方法,可以绕过java语言的存取控制机制;这种罕见的情况来自早期JAVA,并且不会再其它地方遇到;
```
private static native void setIn0(InputStream in);
private static native void setOut0(PrintStream out);
private static native void setErr0(PrintStream err);
```
- java演变
- JDK各个版本的新特性
- JDK1.5新特性
- JDK1.6新特性
- JDK1.7新特性
- JDK1.8新特性
- JAVA基础
- 面向对象特性
- 多态
- 方法重载
- 方法重写
- class
- 常量
- 访问修饰符
- 类加载路径
- java-equals
- 局部类
- java-hashCode
- Java类初始化顺序
- java-clone方法
- JAVA对象实例化的方法
- 基础部分
- JAVA基础特性
- JAVA关键字
- javabean
- static
- 日期相关
- final
- interface
- 函数式接口
- JAVA异常
- 异常屏蔽
- try-with-resource资源泄露
- JAVA引用
- WeakReference
- SoftReference
- PhantomReference
- 位运算符
- try-with-resource语法糖
- JDK冷知识
- JAVA包装类
- JAVA基本类型与包装类
- java.lang.Boolean
- java.lang.Integer
- java.lang.Byte
- java.lang.Short
- java.lang.Long
- java.lang.Float
- java.lang.Double
- java.lang.Character
- 日期相关
- TemporalAdjusters
- String
- 字符串常量池
- String拼接
- String编译期优化
- StringBuilder&StringBuffer
- intern
- 注解
- java标准注解
- 内置注解
- 元注解
- 自定义注解
- 注解处理器
- JVM注解
- Java8 Annotation新特性
- 反射-Reflective
- Reflection
- Class
- Constructor
- Method
- javabean-property
- MethodHandles
- 泛型
- 类型擦除
- bridge-method
- Accessor&Mutator方法
- enum
- JAVA数组
- finalize方法
- JAR文件
- JAVA高级编程
- CORBA
- JMX
- SPI
- Java SPI使用约定
- ServiceLoader
- 实际应用
- IO
- 工具类
- JDK常用工具类
- Objects
- System
- Optional
- Throwable
- Collections
- Array
- Arrays
- System
- Unsafe
- Number
- ClassLoader
- Runtime
- Object
- Comparator
- VarHandle
- 数据结构
- 栈-Stack
- 队列(Queue)
- Deque
- PriorityQueue
- BlockingQueue
- SynchronousQueue
- ArrayBlockingQueue
- LinkedBlockingQueue
- PriorityBlockingQueue
- ConcurrentLinkedQueue
- 列表
- 迭代器
- KV键值对数据类型
- HashMap
- TreeMap
- Hash冲突
- ConcurrentHashMap
- JDK1.7 ConcurrentHashMap结构
- jdk7&jdk8区别
- 集合
- Vector
- Stack
- HashSet
- TreeSet
- ArrayList
- LinkedList
- ArrayList && LinkedList相互转换
- 线程安全的集合类
- 集合类遍历性能
- 并发容器
- CopyOnWriteArrayList
- ConcurrentHashMap
- 同步容器
- BitMap
- BloomFilter
- SkipList
- 设计模式
- 设计模式六大原则
- 单例模式
- 代理模式
- 静态代理
- 动态代理
- JDK动态代理
- cglib动态代理
- spring aop
- 策略模式
- SpringAOP策略模式的运用
- 生产者消费者模式
- 迭代器模式
- 函数式编程
- 方法引用
- 性能问题
- Lambda
- Lambda类型检查
- Stream
- findFirst和findAny
- reduce
- 原始类型流特化
- 无限流
- 收集器
- 并行流
- AOP
- 静态织入
- aspect
- aspect的定义
- AspectJ与SpringAOP
- 动态织入
- 静态代理
- 动态代理
- JDK动态代理
- CGLib动态代理
- Spring AOP
- SpringAOP五种通知类型
- @Before
- @AfterReturning
- @AfterThrowing
- @After
- @Around
- Aspect优先级
- SpringAOP切点表达式
- within
- execution
- 嵌套调用
- 系统优化与重构
- 重叠构造器模式
- 工具类构造器优化
- 常见面试题
- new Object()到底占用几个字节
- 访问修饰符
- cloneable接口实现原理
- 异常分类以及处理机制
- wait和sleep的区别
- 数组在内存中如何分配
- 类加载为什么要使用双亲委派模式,有没有什么场景是打破了这个模式
- 类的实例化顺序
- 附录
- JAVA术语
- FAQ
- 墨菲定律
- 康威定律
- 软件设计原则
- 阿姆达尔定律
- 字节码工具
- OSGI