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

我是Java新手，正在尝试学习定义不可变对象的概念。我在Java教程oracle中读到，创建不可变对象的方法之一是

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

---

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

假设String的方法可以被另一个类扩展。不能保证另一个类会像String一样是不可变的

所以，如果调用某个库方法并获取一个字符串，该字符串是否会更改？是字符串基类还是扩展它的东西是可变的？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());
    }
}

---

我认为正确的问题应该是“为什么允许子类重写方法是设计不可变对象的必要步骤”？这就是你的意思吗？非常感谢你向我解释这件事并举个例子！！非常感谢你的帮助！！