What is called the replaceable method in the constructor?

Question

In a class that extends JFrame, I have some calls on the builder, as can be seen below:

 public ListaDeOficiosUI() {
        try {
            this.oficioController = new OficioController();
            this.initComponents();
            //o alerta é exibido nas 3 chamadas de métodos
           //  seguintes, todos da classe JFrame
            this.setTitle(GerOficiosUI.TITULO + " - Lista de Oficios");
            this.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
            this.addWindowListener(
                    new WindowAdapter() {
                        @Override
                        public void windowClosed(WindowEvent e) {
                            GerOficiosUI x = new GerOficiosUI();
                            x.setLocationRelativeTo(null);
                            x.setVisible(true);
                        }

                        @Override
                        public void windowOpened(WindowEvent e) {
                            requestFocus();
                        }
                    });
            this.setRowSorter();
        } catch (ExcecaoErroIO ex) {
            PrintMessageUI.exibirError(this.getInstance(), ex.getMessage());
            System.exit(0);
        }
    }

However, netbeans is highlighting some passages with the message Call for replaceable method in the constructor, as can be seen in the print below:

Code does not generate errors, normally runs without any kind of problem.

What does this warning message mean? Ignoring it may bring some problem in the application?

Answer 1

What is

Replaceable method means a method that can be superscripted by a subclass.

The warning

This is just one Warning of its IDE on a potential problem, not necessarily an error or something inherent to Java.

The problem in this case is that your constructor is depending on a method that can be overridden by a subclass. If this occurs, the subclass can change the behavior of the method and make the construction of the class unpredictable.

This breaks the inheritance contract, because if the subclass wants to change the boot behavior, it must override the constructor and not a method that affects the superclass constructor.

Personally, I don’t consider this a very serious case. In most cases, as this should be, this is simply not a class that will be overwritten and that will never happen. Then I would simply turn off this warning in the IDE settings.

Some Ides allow you to omit the warning in the code snippet, in the class, in the project or globally.

The solution

Surely it’s not putting the call into another method private as the other reply says, as you are simply adding unnecessary code in order to omit a warning from the IDE, but that does not solve in anything the possible problem pointed, that is, to allow the superscription of a method used in the constructor.

If this class is not designed to be inherited, the solution is simply to do nothing and disable the warning.

If you are designing the class for inheritance, a possible solution would simply make the method setTitle private. It makes no sense for a subclass to change something that was set in the superclass builder.

If the subclass needs to change the title, add a new constructor with a parameter String titulo. Example:

public ListaDeOficiosUI() {
    this("Título default");
}
public ListaDeOficiosUI(String titulo) {
    ...
    this.setTitulo(titulo);
    ...
}
private setTitulo() { ... } 

This way you maintain the expected behavior of the superclass and the child classes can explicitly change the title, making clear the behavior contract in the hierarchy.

Note on the JFrame

How you are using the inherited method of JFrame, the visibility of the setTitulo and other methods.

In this specific case, you could use the JFrame that already receives the title. Example

public ListaDeOficiosUI() {
    super("Meu Título");
}

For the other cases is not very good.

However, another approach is not to use inheritance. You nay need to extend JFrame! You can simply reference an attribute in your class that represents the screen, like this:

public class ListaDeOficiosUI {
    private JFrame frame;
    public ListaDeOficiosUI() {
        frame = new JFrame();
        frame.setTitle("Título");
        ....
    }
    ...
}

I consider this approach better because it avoids inheritance where it is simply not needed.

Considerations

Tip: avoid using Ides in English. I don’t mean any harm from those who translated, but translating technical terms are hardly reliable.

Answer 2

The way to fix this problem is not to use methods that are replaceable (since Java does not use the virtual word) within the constructor.

Only use static, private or final methods in manufacturers.

Answer 3

In Netbeans, with the project window open, I solved the problem by clicking:

Navegador -> JFrame -> Eventos -> componenteResized. 

In the code :

setExtendedState(Frame.MAXIMIZED_BOTH);