Polymorphism implement forced common alterations to child's fields

What's the best design pattern to force children of an abstract class to call a function defined in the abstract class that alters the value of its implemented abstract variables?

<br>

The problem:

I want to scale my bitmaps according to the screen size to keep the ratio. I want to avoid having multiple abstract variables that are essentially assigned the same way. For example in this case widthScale * width will scale the width when assigned to the width. If I create an abstract method named scaleWidth(), though it would imply to the user of the class that they should implement such functionality, it'd cause a repetitious implementation of the same method throughout the codebase.

Also can't have a scaledWidth variable in the abstract class that multiplies 2 abstract variables since parent's fields are initialized before the childrens'

Pseudocode example:

Abstract Class Image
{
  abstract int width;

}

Class Apple extends Image
{
  override int width = 100 * StaticAppClass.scaleFactorWidth;

}

Class Banana extends Image
{
  override int width = 50 * StaticAppClass.scaleFactorWidth;
}

So as you can see every time the programmer has to multiply the width with the StaticAppClass.scaleFactorWidth. Not only it's inconvenient also it's not explicit. Meaning, the programmer wouldn't even know he has to do that

Binding to member fields happens at compile time, so there's no way to directly do what you want. I.e. there's no @Override for fields. I believe the best way is as follows:

public static final int scaleFactor = 10;

public abstract class A
{
    public int getScaledWidth()
    {
        return this.getWidth() * scaleFactor;
    }
    public abstract int getWidth();
}

public class B extends A
{
    public int width = 50;
    @Override
    public int getWidth() { return width; }
}

public class C extends A
{
    public int width = 100;
    @Override
    public int getWidth() { return width; }
}

public static void main(String[] args)
{
    B b = new B();
    System.out.println(b.getScaledWidth());
    C c = new C();
    System.out.println(c.getScaledWidth());
}

With this structure, when writing a new specialization of A, the developer will be required to provide getWidth(), forcing them to consider what is needed.

Couldn't you just have the subclasses assign their width values, and have the superclass implement a scaledWidth getter? (You said Kotlin and I'm in Kotlin mode so here's my example!)

abstract class Image {
    abstract val width: Int
    val scaleFactorWidth = 2
    fun getScaledWidth() = width * scaleFactorWidth
}

class Banana : Image() {
    override val width = 100
}

that way the only thing the subclasses need to implement is a width property (I mean it would be better to pass them into the constructor but there might be too many properties for that). The scaled width is accessed through a getter function, so it's all initialised by the time anyone calls it.

If you are in Kotlin you could even do

val scaledWidth by lazy { width * scaledWidth }

which stores a single value, but calculates it (once) when it's first accessed - so long as that's not during the initialisation of the Image superclass, you should be ok?

If I understand well, width is a constant different for each implementation?

I would do something like that:

In the abstract class:

public abstract int getWidth();

In the implementations:

@Override
public int getWidth() {
    return value;
}