3.29-3.30学习总结

目录

包装类，类成员http://t.csdn.cn/GeTkm

final

1.final修饰成员变量

2. final修饰局部变量

3.final修饰引用变量

4.final变量->宏变量

5.final方法

6.final类

7.不可变类

8.缓存不可变类

---

包装类，类成员http://t.csdn.cn/GeTkm

final

1.final修饰成员变量

1. 须在声明时/初始化块中，初始化。实例变量还可以在构造器中
2. final修饰的成员变量，系统不会对其默认初始化
3. 不允许初始化之前访问final成员变量，warning

2. final修饰局部变量

        只能赋值一次

3.final修饰引用变量

        一直引用同一个对象，但对象可以发送变化

4.final变量->宏变量

        当一个final变量，在定义时指定了初始值，且该初始值在编译时就是确定的，这个final变量就相当于一个直接量

public class Main {
    public static void main(String[] args) {
        final String str1="114";//直接量
        final String str2="514";
        String str=str1+str2;//编译时确定的值
        System.out.println(str=="114514");//true
        String str3="114";//不是直接量
        String str4="514";
        String str5=str3+str4;//编译时，不确定的值
        System.out.println(str5=="114514");//false
    }
}

str5的值由str3与str4连接而成，对编译器来说，str1和str2只是普通变量，不会进行“宏替换”。

5.final方法

        不可被重写，但可被重载

#对于父类中的private方法，子类可以重新定义

6.final类

        阻止继承

7.不可变类

        创建该类实例后，实例变量不可变

8个包装类与String都为不可变类

1. 使用final、private修饰成员变量
2. 构造器带参，用于初始化变量
3. 只提供getter方法，不提供setter方法        
4. 必要时，依据关键成员变量重写Object的hashCode(),equals()方法

#当不可变类中含有可变引用变量成员时，应保护该成员

class Person{
    private final Name name;
    public Person(Name name){
        this.name=new Name(name.getFir_name(),name.getLastname());//将传入的name的内容拷贝给成员name
    }
    public Name getName(){
        return new Name(name.getFir_name(),name.getLastname());//返回一个与成员name内容相同的name
    }
}
class Name{
    private String fir_name;
    private String lastname;
    public Name(String fir,String last){
        fir_name=fir;
        lastname=last;
    }
    public Name(){

    }
    public void setFir_name(String fir){
        fir_name=fir;
    }
    public void setLastname(String last){
        lastname=last;
    }
    public String getFir_name(){
        return fir_name;
    }
    public String getLastname(){
        return lastname;
    }
}

如果这样做，对传入的name修改，person里面的name成员也会发生变化

class Person{
    private final Name name;
    public Person(Name name){
        this.name=name;
    }
    public Name getName(){
        return name;
    }
}

8.缓存不可变类

        如果要经常使用相同的不可变类实例，考虑缓存        如Integer的缓存机制-128~127

public class Main {
    public static void main(String[] args) {
        Integer n=new Integer(127);
        Integer n1=Integer.valueOf(127);
        Integer n2=Integer.valueOf(127);
        System.out.println(n==n1);//false
        System.out.println(n1==n2);//true,缓存成功
    }
}
class Integer{
    final private int value;
    public Integer(int value){
        this.value=value;//不推荐，可能浪费内存
    }
    private static int Max_size=128;
    static final Integer[] cache=new Integer[Max_size+Max_size];
    static {
        for(int i=0;i=-Max_size)
        {
            return cache[value];
        }
        else
        {
            return new Integer(value);
        }
    }
    static public void setMax_size(int size){
        //由于final修饰了cache，扩容不方便
    }
}

意义：节省内存