程序代码:

1. class Address
   
2. {
   
3.         private final String detail;
   
4.         private final String postCode;
   
5.         //在构造器内初始化两个Field
   
6.         public Address()
   
7.         {
   
8.                 this.detail = "";
   
9.                 this.postCode = "";
   
10.         }
    
11.         public Address(String detail, String postCode)
    
12.         {
    
13.                 this.detail = detail;
    
14.                 this.postCode = postCode;
    
15.         }
    
16.         //仅为Field提供getter方法
    
17.         public String getDetail()
    
18.         {
    
19.                 return this.detail;
    
20.         }
    
21.         public String getPostCode()
    
22.         {
    
23.                 return this.postCode;
    
24.         }
    
25. }
    
26. public class OverrideAddress
    
27. {
    
28.         public static void main(String[] args)
    
29.         {
    
30.                 Address add = new Address("哈哈", "呵呵");
    
31.                 System.out.println(add.getDetail() + add.getPostCode());
    
32.         }
    
33. }

复制代码

上面程序符合不可变类的三个要素..
编译,创建对象时应该是无法传入形参的..
为什么创建对象的形参还是可以传入??  
是否是我理解错了? 前面已经有构造器初始化Field了,后面传入的算是第一次赋值??  

张利 发表于 2012-11-23 22:16
你这个就算是不可变类了 所谓不可变类，是指当创建了这个类的实例后，就不允许修改它的属性值。
在你通过ne ...

谢谢了..  前几天网络有问题了,一直没上来看...

楼上的几位哥们讲的很明白，学习了

你这个就算是不可变类了 所谓不可变类，是指当创建了这个类的实例后，就不允许修改它的属性值。
在你通过new创建了一个实例后，这个实例的属性值是无法再更改的了，不可变类指的是你创建完的这个对象的属性不变
而你还是可以接着创建对象的
若是想要该类的对象只能有一个 可以用单例模式，私有化构造方法

张利 发表于 2012-11-22 22:52
对于变量的修饰为public static的时候，相当于定义了一个常量，需要直接赋值
对于final修饰的变量，要求是 ...

不可变类,其实说的是通过构造器创建的该类的对象Field不可变? 而该类的对象数量可以增加?

张利 发表于 2012-11-22 22:52
对于变量的修饰为public static的时候，相当于定义了一个常量，需要直接赋值
对于final修饰的变量，要求是 ...

那通过创建对象就可以重新对Address对象Field赋值, 和没有final修饰有什么区别的呢?
Field用private修饰,没有setter方法再次接受值传递,不用final修饰也一样的啊..

要创建不可变类如有必要可以重写equals方法和hashCode方法; 下面是修改的程序:

1. class Address
   
2. {
   
3.         private final String detail;
   
4.         private final String postCode;
   
5.         //在构造器内初始化两个Field
   
6.         //此处省略中间代码
   
7.         ...
   
8.         public String getPostCode()
   
9.         {
   
10.                 return this.postCode;
    
11.         }
    
12.         //重写equals方法判断两个对象是否相等
    
13.         public boolean equals(Object obj)
    
14.         {
    
15.                 if (this == obj)
    
16.                 {
    
17.                         return true;
    
18.                 }
    
19.                 if (obj != null && obj.getClass() == Address.class)
    
20.                 {
    
21.                         Address a = (Address)obj;
    
22.                         if (this.getDetail().equals(a.getDetail()) &&
    
23.                                 this.getPostCode().equals(a.getPostCode()))
    
24.                         {
    
25.                                 return true;
    
26.                         }
    
27.                 }
    
28.                 return false;
    
29.         }
    
30.         public int hashCode()
    
31.         {
    
32.                 return detail.hashCode() + postCode.hashCode();
    
33.         }
    
34. }
    
35. public class OverrideAddress
    
36. {
    
37.         public static void main(String[] args)
    
38.         {
    
39.                 Address add = new Address("哈哈", "呵呵");
    
40.                 System.out.println(add.getDetail() + add.getPostCode());
    
41.                 Address ad = new Address("哈哈", "呵呵");
    
42.                 //判断两个对象Field以及哈希值是否相等,结果为true
    
43.                 System.out.println(add.equals(ad));
    
44.                 System.out.println(add.hashCode() == ad.hashCode());
    
45.         }
    
46. }

复制代码

这是重写后的equals方法和hashCode方法, 是否是通过比较两个对象Field
如果重新创建对象Field和已有的相同,就表示是不可变类???  (可变类在创建对象后,Field是不同的)
这样不是有点掩耳盗铃的感觉..  

对于变量的修饰为public static的时候，相当于定义了一个常量，需要直接赋值
对于final修饰的变量，要求是只能赋值一次，你这个就是在构造函数中赋值的了， 第一个是空参数构造函数赋值为空，第二个是全参构造函数，赋值为传入的数据
main函数中，创建对象调用的是全参的构造函数，在对象建立的时候对于变量赋值的

个人认为是这样的,你实力对象的时候调用的是有参数的构造方法,所以在初始化变量的时候用的是有参构造函数里面的方法。你可以在两个构造函数里打印点输出语句,看看你主函数的输出结果就知道了。