java基础——如何实现不可变类String、Long、Double是不可变类

客官°小女子只卖身不卖艺 2023-06-18 04:53 2阅读 0赞

String、Long、Double是不可变类

## 实现不可变类的步骤 ##

1）类声明为final，不可以被继承  
2）所有成员是私有的，不允许直接被访问  
3）对变量不要setter方法  
4）所有可变的变量是final的，只能赋值一次  
5）通过构造器初始化所有成员，进行深拷贝  
6）在getter方法中不能返回对象本身，返回对象的拷贝

package FinalClassDemo;
    
    import java.util.HashMap;
    import java.util.Iterator;
    
    public final class FinalClassExample {
    
        private final int id;
    
        private final String name;
    
        private final HashMap testMap;
    
        public int getId() {
            return id;
        }
    
        public String getName() {
            return name;
        }
    
        /**
         * 可变对象的访问方法
         */
        public HashMap getTestMap() {
            //return testMap;
            return (HashMap) testMap.clone();
        }
    
    //    /**
    //     * 实现深拷贝(deep copy)的构造器
    //     * @param i
    //     * @param n
    //     * @param hm
    //     */
    //
    //    public FinalClassExample(int i, String n, HashMap hm){
    //        System.out.println("Performing Deep Copy for Object initialization");
    //        this.id=i;
    //        this.name=n;
    //        HashMap tempMap=new HashMap();
    //        String key;
    //        Iterator it = hm.keySet().iterator();
    //        while(it.hasNext()){
    //            key= (String) it.next();
    //            tempMap.put(key, hm.get(key));
    //        }
    //        this.testMap=tempMap;
    //    }
    
        /**
         * 实现浅拷贝(shallow copy)的构造器
         * @param i
         * @param n
         * @param hm
         */
    
         public FinalClassExample(int i, String n, HashMap hm){
         System.out.println("Performing Shallow Copy for Object initialization");
         this.id=i;
         this.name=n;
         this.testMap=hm;
         }
    
    
        /**
         * 测试浅拷贝的结果
         * 为了创建不可变类，要使用深拷贝
         * @param args
         */
        public static void main(String[] args) {
            HashMap h1 = new HashMap();
            h1.put("1", "first");
            h1.put("2", "second");
    
            String s = "original";
    
            int i=10;
    
            FinalClassExample ce = new FinalClassExample(i,s,h1);
    
            //Lets see whether its copy by field or reference
            System.out.println(s==ce.getName());
            System.out.println(h1 == ce.getTestMap());
            //print the ce values
            System.out.println("ce id:"+ce.getId());
            System.out.println("ce name:"+ce.getName());
            System.out.println("ce testMap:"+ce.getTestMap());
            //change the local variable values
            i=20;
            s="modified";
            h1.put("3", "third");
            //print the values again
            System.out.println("ce id after local variable change:"+ce.getId());
            System.out.println("ce name after local variable change:"+ce.getName());
            System.out.println("ce testMap after local variable change:"+ce.getTestMap());
    
            HashMap hmTest = ce.getTestMap();
            hmTest.put("4", "new");
    
            System.out.println("ce testMap after changing variable from accessor methods:"+ce.getTestMap());
    
        }
    
    }
    //浅拷贝测试结果：
    Performing Shallow Copy for Object initialization
    true
    false
    ce id:10
    ce name:original
    ce testMap:{1=first, 2=second}
    ce id after local variable change:10
    ce name after local variable change:original
    ce testMap after local variable change:{1=first, 2=second, 3=third}
    ce testMap after changing variable from accessor methods:{1=first, 2=second, 3=third}
    //深拷贝测试结果：
    Performing Deep Copy for Object initialization
    true
    false
    ce id:10
    ce name:original
    ce testMap:{1=first, 2=second}
    ce id after local variable change:10
    ce name after local variable change:original
    ce testMap after local variable change:{1=first, 2=second}
    ce testMap after changing variable from accessor methods:{1=first, 2=second}