为什么不允许子类重写方法会导致创建不可变对象？

Question

我是Java的新手，并试图学习定义不可变对象的概念。我已阅读Java教程oracle，创建不可变对象的方法之一是

不允许子类重写方法。最简单的方法是将类声明为final。

我的问题是，为什么不允许子类重写方法可以导致创建不可变对象？我在努力了解这里的联系。

Answer 1

假设字符串的方法可以被另一个类扩展。不能保证其他类将像String一样是不可变的。

所以，如果你调用一些库方法并得到一个字符串回来，该字符串是否会改变？它是字符串基类或扩展它是可变的东西？字符串是最终的类，所以我们不必担心这一点。

我做了以下混乱的一个例子：

public class WhyImmutableClassesShouldBeFinal { 
    /* 
    * This is an immutable class 
    */ 
    private static class ImmutableClass { 
     private final String data; 

     public ImmutableClass(String data) { 
      this.data = data; 
     } 

     public String getData() { 
      return data; 
     } 
    } 

    /* 
    * This extends an immutable class, but is not immutable. 
    */ 
    private static class NotSoImmutableClass extends ImmutableClass { 
     private int oops; 

     public NotSoImmutableClass() { 
      super("WHATEVER"); 
     } 

     public String getData() { 
      return Integer.toString(oops++); 
     } 
    } 

    /* 
    * Here's some function that looks like it returns an immutable class but 
    * doesn't. 
    */ 
    private static ImmutableClass immutableClassProducer() { 
     return new NotSoImmutableClass(); 
    } 

    public static void main(String[] args) { 
     /* 
     * I called a method and got an ImmutableClass back. 
     */ 
     ImmutableClass c = immutableClassProducer(); 

     /* 
     * But why is the value changing? 
     */ 
     System.out.println(c.getData()); 
     System.out.println(c.getData()); 
     System.out.println(c.getData()); 
     System.out.println(c.getData()); 
    } 
}