final关键字

==============================================================

点击标题可以下载xmind

代码练习

====

final可修饰

---

package finalTest;

// final可以修饰类

// final修饰的类是最终类，即不能派生子类的类

public final class FinalTest {

// final可以修饰变量

// 被final修饰的变量是常量，一旦初始化，则不能二次赋值，否则编译报错

// 被final修饰的成员变量，系统不会自动初始化，必需由程序员显式初始化

// 被final修饰的（成员变量）非静态变量初始化时机有三个：

// 1.在声明时

final int NUM = 10;

// 2.在非静态初始化块中

{

//NUM = 11;

}

//3.在构造器中

FinalTest(){

//NUM = 12;

}

// 被final修饰的（成员变量）静态成员变量初始化时机有两个:

// 1.在声明时

static final double PI = 3.1415;

//2.在静态初始化块中

static {

//PI = 3.145926;

}

// 被final修饰的局部变量,必须要在【使用前】由程序员显式初始化，如果不使用，可以不初始化。

// 被final修饰的方法形参

void test(final int d){

// 被final修饰的方法局部变量

final int b;

final int c;

c = 10;

//c = 11;//Variable ‘c’ might already have been assigned to

System.out.println©;

//d = 12;//Cannot assign a value to final variable ‘d’

System.out.println(d);

}

// 被final修饰的初始化块局部变量

{

final int e;

final int f;

f = 10;

//f = 11;//Variable ‘f’ might already have been assigned to

System.out.println(f);

}

public static void main(String[] args) {

FinalTest finalTest = new FinalTest();

finalTest.test(2);

}

}

// 被final修饰的类不能派生子类，否则编译报错

//Cannot inherit from final ‘finalTest.FinalTest’

class Test //extends FinalTest

{}

宏变量

---

public class Main{

public static void main(String[] args){

// 满足宏变量要求：1.final修饰变量 2.在声明时初始化 3.变量值在编译器就能确定

// 编译器会将这条语句看成一个直接量30

final int NUM = 10+20;

// 不满足宏变量要求：未在声明时初始化

final String DESC;

DESC = “123”;

// 不满足宏变量要求：变量值不能再编译器确定

final Person p = new Person(“qfc”,18);

// 编译器会替换宏变量为对应的直接量

System.out.println(NUM);

System.out.println(DESC);

System.out.println§;

}

}

class Person{

String name;

int age;

Person(String name,int age){

this.name = name;

this.age = age;

}

}

不可变类

---

package finalTest;

public class FinalTest2 {

// 不可变类定义要求：1.将实例变量定义为private final修饰

private final int num;

private final String desc;

private final Person person;

// 不可变类定义要求：3.实例变量初始化再构造器中进行

public FinalTest2(int num, String desc, Person person) {

this.num = num;

this.desc = desc;

// 不可变类定义要求：4.如果实例变量类型是可变类类型，则不能直接将外部传入的可变类对象作 《大厂前端面试题解析+Web核心总结学习笔记+企业项目实战源码+最新高清讲解视频》无偿开源 徽信搜索公众号【编程进阶路】 为初始化值，而是创建一个备份值来接收。

this.person = new Person(person.getName(),person.getAge());

}

// 不可变类定义要求：2.不对外提供实例变量set方法

public int getNum() {

return num;

}

public String getDesc() {

return desc;

}

public Person getPerson() {

// 不可变类定义要求：5.如果实例变量类型是可变类类型，则不能直接将该实例变量的原始值提供出去，而是创建一个备份值提供出去

return new Person(person.getName(),person.getAge());

}

@Override

public String toString() {

return “FinalTest2{” +

“num=” + num +

“, desc='” + desc + ‘’’ +

“, person=” + person +

‘}’;

}

}

// Person类是一个可变类

class Person{

String name;

int age;

public Person(String name, int age) {

this.name = name;

this.age = age;

}

public String getName() {

return name;

}

public void setName(String name) {

this.name = name;

}

public int getAge() {

return age;

}

public void setAge(int age) {

this.age = age;

}

@Override

public String toString() {

return “Person{” +

“name='” + name + ‘’’ +

“, age=” + age +

‘}’;

}

}

class Main2{

public static void main(String[] args) {

FinalTest2 finalTest2 = new FinalTest2(10, “desc”, new Person(“qfc”, 10));

System.out.println(finalTest2);

finalTest2.getPerson().setAge(60);

finalTest2.getPerson().setName(“qfc father”);

System.out.println(finalTest2);

}

}

缓存不可变类实例

---

package finalTest;

import java.util.Arrays;

// 缓存不可变类实例

// 1.定义一个不可变类

public class CacheUnChangedTest {

private final String name;

private final int age;

// 4.创建一个容量合适的容器，来存储不可变类实例

private static CacheUnChangedTest[] cArr = new CacheUnChangedTest[3];

// 5.定义一个位置变量，来标记容器中实例存储的最新位置

private static int pos = 0;

// 2.私有化不可变类构造器

private CacheUnChangedTest(String name, int age) {

this.name = name;

this.age = age;

}

// 3.提供一个公有方法对外提供新创建或缓存过的实例

public static CacheUnChangedTest getInstance(String name,int age){

// 6.判断需要提供的实例是否已经创建过了?如果创建过了，则从容器中取出提供；如果未创建，则创建一个新的实例，加入到容器中，并提供出去

// 定义对外提供的实例变量 c

CacheUnChangedTest c = null;

System.out.println(“缓存池中的实例：”+Arrays.toString(cArr));

// 定义flag来标识外部需要的实例是否已经创建过，true表示已经创建过，false表示没有创建过

boolean flag = false;

// 遍历容器元素，判断外部需要的实例是否已经缓存过了？

for (CacheUnChangedTest cacheUnChangedTest : cArr) {

// 具体判断实例相同的标准可以自己定，只要在缓存池cArr中发现了相同的实例，则终止循环，直接提供缓存池中的实例给外部，而不需要创建新的实例

if (cacheUnChangedTest != null && cacheUnChangedTest.getName().equals(name) && cacheUnChangedTest.getAge() == age) {

flag = true;

c = cacheUnChangedTest;

break;

}

}

// 如果外部需要的实例还没有被创建过

if (!flag) {

// 则直接创建一个新的实例

c = new CacheUnChangedTest(name,age);

// 并且存入缓存池中

if (pos != cArr.length) {

// 如果缓存池还没有存满，则继续存

cArr[pos++] = c;

} else {

// 如果换存储已经存满了，则将位置变量变为0，从头开始重新覆盖存

pos = 0;

cArr[pos] = c;

}

}

return c;

}

public String getName() {

return name;

}

public int getAge() {

return age;

}

@Override

public String toString() {

return “CacheUnChangedTest{” +