mutable class extending into immutable class

[willemien]

What is the right/ best way to do this?

I have two classes.

A class Varies that has a lot of methods and where the importand private fields are mutable,

A class Fixed that is an extention of class Varies but where the fields that it inherits from class Varies have to be immutable. (the whole object of class Fixed should be immutable)

I was thinking to do this by overiding the methods of Varies in Fixed but that doesn't look right. (what if I later add an new changing method to Varies and forget to override it?)

Treating them as unrelated classes also don't seem right, it means copying most methods from Varies to Fixed

What is the right/ best way to do this?

[Tolls]

You don't extend.
You wrap.

Since Varies will have methods that allow you to change the fields, and you cannot change those methods to private in Fixed, you have no way of making it immutable via inheritance. So wrap it.

[willemien]

you mean something like:

public class Fixed
{
    private fixed Varies fixedObject

    public Fixed(Varies v)
    {
        fixedObject = new Varies(v.toString)    
    }

     
    public Fixed(String s)
    {
        fixedObject = new Varies(s)    
    }
    
    private Fixed()
    {
        // no public empty constructor    
    }

    public toVaries()
    {
        return = new Varies(fixedObject.toString)    
    }
     
    // wrapped methods from varies 
    public int getLen {return fixedObject.getLen} 
    public char getFirst {return fixedObject.getFirst} 
    public String toString {return fixedObject.toString}
    // ect
}

But then I have to do all those wrapped methods is there no other way?
Also does recognize that fixedObject is immutable?

[Tolls]

fixedObject won't be immutable. Varies is not an immutable class.
But whatever object of class Fixed that is created that contains fixedObject will be immutable.

This is the standard pattern for removing an objects setters, though the above won't actually compile.
It does work better if both Varies and Fixed share an interface, but that's often not possible.