Java-java疯狂讲义-第六章面向对象（下）-6.4final修饰符

亦凉 2023-05-29 13:07 21阅读 0赞

## 6.4final修饰符 ##

final修饰类、变量、方法。

### 6.4.1final成员变量  ###

修饰变量：表示变量一旦获得了初始值就不可改变，final既可以修饰成员变量（类变量和实例变量），也可以修饰局部变量，形参

final修饰的成员变量必须由程序员显示的指定初始值

package com.cdmt.demo.staticblock;
    
    /**
     * @ClassName: FinalVariableTest
     * @Description: final的所有初始化位置
     **/
    public class FinalVariableTest {
        final int a =6;
        final String str;
        final int c;
        final static double d;
    
        {
            str = "hello";
        }
    
        static{
            d = 5.6;
        }
    
        public FinalVariableTest(){
            c = 5;
        }
    
        public void changeFinal(){
        }
    
        public static void main(String[] args) {
            FinalVariableTest ft = new FinalVariableTest();
            System.out.println(ft.a);
            System.out.println(ft.c);
            System.out.println(ft.d);
        }
    }

结果：

![20191106155903491.png][]

PS:如果打算要在构造器、初始化块中初始化final成员变量，则不要在之前直接访问final成员变量，否则系统会自动赋初始值

代码：

package com.cdmt.demo.staticblock;
    
    /**
     * @ClassName: FinalErrorTest
     * @Description: TODO
     **/
    public class FinalErrorTest {
        final int age;
        {
            //因为没有初始化，所以会报错
            System.out.println(age);
            printAge();
            age = 6;
            System.out.println(age);
        }
    
        private void printAge() {
            System.out.println(age);
        }
    
        public static void main(String[] args) {
            new FinalErrorTest();
        }
    }

PS：final成员变量在显示初始化之前不能直接访问

### 6.4.2final局部变量 ###

形参使用final传入必须已经赋值，如果不能赋值系统也会自动赋值初始化

### 6.4.3 final 修饰基本类型变量和引用类型变量的区别 ###

final修饰基本类型不更变，但是修饰引用类型，只要引用的地址一直不变，引用的对象是可以变的。

###  6.4.4可执行"宏替换"的 final 变量 ###

宏替换

对于一个final变量来说，不管他是类变量、实例变量、局部变量只要满足三个条件这个final变量就不再是一个变量，而是相当于一个直接量。

1.  使用final修饰符修饰
2.  在定义该final变量时指定了初始值
3.  该初始值可以在编译时就被确定下来

package com.cdmt.demo.staticblock;
    
    /**
     *
     * @ClassName: StringJoinTest
     * @Description: TODO
     **/
    public class StringJoinTest {
        public static void main(String[] args) {
            String s1 = "javakaka";
            String s2 = "java" + "kaka";
            System.out.println(s1 == s2);
    
            String s3 = s1 + s2;
            System.out.println(s1 == s3);
    
            final String st1 = "java";
            final String st2 = "kaka";
            String st3 = st1 + st2;
            System.out.println(s1 == st3);
        }
    }

结果：

![20191106191347291.png][]

总结：

用final指定st1、st2又在编译时能确定下来，就是宏变量，可以执行宏替换 。可以默认把他们当做常量来使用。

### 6.4.5final方法  ###

final方法不可以重写 ，java提供的Object类里面就有一个final方法，getClass（），因为java不希望任何类重写这个方法。

package com.cdmt.demo.staticblock;
    
    /**
     * @ClassName: PrivateFinalMethodTest
     * @Description: TODO
     **/
    public class PrivateFinalMethodTest {
        private final void test(){
            System.out.println("PrivateFinalMethodTest方法");
        }
    }
    
    class Sub extends PrivateFinalMethodTest{
    
        //下面这种方法定义不会出问题
        public void test(){
            System.out.println("Sub方法");
        }
    
        public static void main(String[] args) {
            Sub sub = new Sub();
            sub.test();
        }
    }

结果：

![20191106192407800.png][]

总结：

说明sub的test是重新的一个方法，而不是父类的。如果Sub类试图重写父类的方法则会报错，因为父类的方法是final类型

![20191106192641264.png][]

### 6.4.6final类 ###

final修饰的类不可以有子类，例如java.lang.Math类就是一个final类，它不可以有子类。

### 6.4.7不可变类 ###

不可变类的意思是创建该类的实例后，该实例的实例变量时不可以改变的。Java提供的8个包装类和java.lang.Stirng类都是不可变类。

![20191106193001964.png][]

自定义不可变类：

1.  使用private和final修饰符来修饰该类的成员变量
2.  提供带参数的构造器，用于传入初始化类变量
3.  仅为该类的成员变量提供getter方法，不需要setter方法，因为final修饰的成员变量没办法修改
4.  如果有必要，重写Object类的hashCode（）和equals（）方法

PS：与不可变相对的是可变类，即提供了getter和setter方法的类（比如javaBean）。与可变类相比，不可变类的实例在整个生命周期中永远处于初始化状态。

PS：设计一个不可变类，如果存在一个private fnal的引用变量（这个引用变量是可变的）。这个不可变类的参数是可以变的。所以需要特别注意

### 6.4.8缓存实例的不可变类  ###

不可变类的实例状态不可改变，可以很方便的背多个对象所共享。如果程序经常使用不可变类实例，则应该考虑缓存这种不可变类的实例。

使用一个数组实来作为缓存池，从而实现一个缓存实例的不可变

package com.cdmt.demo.staticblock;
    
    import sun.misc.Cache;
    
    /**
     *
     * @ClassName: CacheImmutale
     * @Description: TODO
     **/
    public class CacheImmutale {
        private static int MAX_SIZE = 10;
        private static CacheImmutale[] cache = new CacheImmutale[MAX_SIZE];
    
        private static int pos = 0;
        private final String name;
    
        private CacheImmutale(String name){
            this.name = name;
        }
        public String getName(){
            return name;
        }
        public static CacheImmutale valueOf(String name){
            //遍历已缓存的对象
            for(int i=0; i < MAX_SIZE; i++){
                //如果已有相同实例，则直接返回该缓存的实例
                if(cache[i] != null && cache[i].getName().equals(name)){
                    return cache[i];
                }
            }
            //如果缓存池已满
            if (pos == MAX_SIZE){
                //吧缓存的第一个对象覆盖，即把刚刚生成的对象放在缓存池的最前面
                cache[0] = new CacheImmutale(name);
                //把pos设置为1
                pos = 1;
            }else{
                //把新创建的对象缓存起来，pos加1
                cache[pos++] = new CacheImmutale(name);
            }
            return cache[pos - 1];
        }
    
        @Override
        public boolean equals(Object obj){
            if(this == obj){
                return true;
            }
            if(obj != null && obj.getClass() == CacheImmutale.class){
                CacheImmutale ci = (CacheImmutale)obj;
                return name.equals(ci.getName());
            }
            return false;
        }
    
        @Override
        public int hashCode(){
            return name.hashCode();
        }
    }
    
    class CacheImmutaleTest{
        public static void main(String[] args) {
            CacheImmutale c1 = CacheImmutale.valueOf("hello");
            CacheImmutale c2 = CacheImmutale.valueOf("hello");
            System.out.println(c1 == c2);
        }
    }

结果：

![20191106200547452.png][]

是否为同一个实例，根据name去判断。比较类似的就是Integer构造器，也是用了缓存技术

PS：缓存技术什么时候用，取决于使用频率。不能盲目使用，因为缓存对于内存有开销

[20191106155903491.png]: https://img-blog.csdnimg.cn/20191106155903491.png
[20191106191347291.png]: https://img-blog.csdnimg.cn/20191106191347291.png
[20191106192407800.png]: https://img-blog.csdnimg.cn/20191106192407800.png
[20191106192641264.png]: https://img-blog.csdnimg.cn/20191106192641264.png
[20191106193001964.png]: https://img-blog.csdnimg.cn/20191106193001964.png
[20191106200547452.png]: https://img-blog.csdnimg.cn/20191106200547452.png