final关键字

{

//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.如果实例变量类型是可变类类型，则不能直接将外部传入的可变类对象作为初始化值，而是创建一个备份值来接收。

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{” +

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

“, age=” + age +

‘}’;

}

}

class Main3{

public static void main(String[] args) {

CacheUnChangedTest c1 = CacheUnChangedTest.getInstance(“qfc”,18);//缓存池中的实例：[null, null, null]

CacheUnChangedTest c2 = CacheUnChangedTest.getInstance(“zyx”,19);//缓存池中的实例：[CacheUnChangedTest{name=‘qfc’, age=18}, null, null]

CacheUnChangedTest c3 = CacheUnChangedTest.getInstance(“孙悟空”,18);//缓存池中的实例：[CacheUnChangedTest{name=‘qfc’, age=18}, CacheUnChangedTest{name=‘zyx’, age=19}, null]

CacheUnChangedTest c4 = CacheUnChangedTest.getInstance(“qfc”,18);//缓存池中的实例：[CacheUnChangedTest{name=‘qfc’, age=18}, CacheUnChangedTest{name=‘zyx’, age=19}, CacheUnChangedTest{name=‘孙悟空’, age=18}]

System.out.println(c4 == c1);//true

CacheUnChangedTest c5 = CacheUnChangedTest.getInstance(“zyx”,19);//缓存池中的实例：[CacheUnChangedTest{name=‘qfc’, age=18}, CacheUnChangedTest{name=‘zyx’, age=19}, CacheUnChangedTest{name=‘孙悟空’, age=18}]

System.out.println(c5 == c2);//true

CacheUnChangedTest c6 = CacheUnChangedTest.getInstance(“zyx1”,18);//缓存池中的实例：[CacheUnChangedTest{name=‘qfc’, age=18}, CacheUnChangedTest{name=‘zyx’, age=19}, CacheUnChangedTest{name=‘孙悟空’, age=18}]

CacheUnChangedTest c7 = CacheUnChangedTest.getInstance(“qfc”,18);//缓存池中的实例：[CacheUnChangedTest{name=‘zyx1’, age=18}, CacheUnChangedTest{name=‘zyx’, age=19}, CacheUnChangedTest{name=‘孙悟空’, age=18}]

System.out.println(c7 == c1);//false

}

}

思考题

===

1.Java是否允许访问未初始化的final成员变量?或者请看下面代码的运行结果是什么？（final设计缺陷，好玩的题目）

---

public class Main5 {

final int a;

{

test();

a = 6;

System.out.println(a);

}

private void test() {

System.out.println(a);

}

public static void main(String[] args) {

Main5 main = new Main5();

}

}

最后

自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。

深知大多数初中级Android工程师，想要提升技能，往往是自己摸索成长，自己不成体系的自学效果低效漫长且无助。

因此收集整理了一份《2024年Web前端开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上Android开发知识点！不论你是刚入门Android开发的新手，还是希望在技术上不断提升的资深开发者，这些资料都将为你打开新的学习之门！

如果你觉得这些内容对你有帮助，需要这份全套学习资料的朋友可以戳我获取！！

由于文件比较大，这里只是将部分目录截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且会持续更新！
}

}

最后

自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。

深知大多数初中级Android工程师，想要提升技能，往往是自己摸索成长，自己不成体系的自学效果低效漫长且无助。

因此收集整理了一份《2024年Web前端开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。

[外链图片转存中…(img-swa8IPi7-1715356480011)]

[外链图片转存中…(img-cI4Su6EV-1715356480011)]

[外链图片转存中…(img-D3jLcEyu-1715356480012)]

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上Android开发知识点！不论你是刚入门Android开发的新手，还是希望在技术上不断提升的资深开发者，这些资料都将为你打开新的学习之门！

如果你觉得这些内容对你有帮助，需要这份全套学习资料的朋友可以戳我获取！！

由于文件比较大，这里只是将部分目录截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且会持续更新！