Comportamento del metodo statico finale

Ho giocato con modificatori con metodo statico e mi sono imbattuto in un comportamento strano.

Come sappiamo, i metodi statici non possono essere sovrascritti, poiché sono associati alla classe piuttosto che all'istanza.

Quindi, se ho lo snippet di seguito, si compila bene

//Snippet 1 - Compiles fine
public class A {
    static void ts() {
    }
}

class B extends A {
    static void ts() {
    }
}

Ma se includo il modificatore finale al metodo statico nella classe A, la compilazione fallisce ts () in B non può sovrascrivere ts () in A; il metodo sostituito è statico finale .

Perché succede quando il metodo statico non può essere assolutamente sovrascritto?

I metodi statici non possono essere sovrascritti ma possono essere nascosti. Il ts()metodo di B non sovrascrive (non soggetto a polimorfismo) il metodo di ts()A ma lo nasconde. Se chiami ts()in B (NOT A.ts()o B.ts()... solo ts()), verrà chiamata quella di B e non A. Poiché questa non è soggetta a polimorfismo, la chiamata ts()in A non sarà mai reindirizzata a quella in B.

La parola chiave finaldisabiliterà il metodo dall'essere nascosto. Quindi non possono essere nascosti e un tentativo di farlo risulterà in un errore del compilatore.

Spero che questo ti aiuti.

i metodi statici non possono essere sovrascritti

Questo non è esattamente vero. Il codice di esempio significa davvero che il metodo ts in B nasconde il metodo ts in A. Quindi non è esattamente sovrascrivente. Su Javaranch c'è una bella spiegazione.

I metodi statici appartengono alla classe, non all'istanza.

A.ts()e B.ts()saranno sempre metodi separati.

Il vero problema è che Java ti consente di chiamare metodi statici su un oggetto istanza. I metodi statici con la stessa firma della classe genitore vengono nascosti quando vengono chiamati da un'istanza della sottoclasse. Tuttavia, non è possibile sovrascrivere / nascondere i metodi finali .

Penseresti che il messaggio di errore utilizzi la parola nascosta invece di sovrascritta ...

Potresti trovarti nella posizione di pensare di rendere definitivo un metodo statico, considerando quanto segue:

Avere le seguenti classi:

class A {
    static void ts() {
        System.out.print("A");
    }
}
class B extends A {
    static void ts() {
        System.out.print("B");
    }
}

Ora il modo "corretto" per chiamare questi metodi sarebbe

A.ts();
B.ts();

che risulterebbe ABma potresti anche chiamare i metodi sulle istanze:

A a = new A();
a.ts();
B b = new B();
b.ts();

che risulterebbe ABanche.

Ora considera quanto segue:

A a = new B();
a.ts();

che verrebbe stampato A. Questo potrebbe sorprenderti visto che stai effettivamente avendo un oggetto di classe B. Ma poiché lo chiami da un riferimento di tipo A, chiamerà A.ts(). Puoi stampare Bcon il seguente codice:

A a = new B();
((B)a).ts();

In entrambi i casi l'oggetto che hai è effettivamente di classe B. Ma a seconda del puntatore che punta all'oggetto, chiamerai il metodo da Ao da B.

Supponiamo ora che tu sia lo sviluppatore della classe Ae desideri consentire la sottoclasse. Ma vuoi davvero il metodo ts(), ogni volta che viene chiamato, anche da una sottoclasse, che fa quello che vuoi che faccia e non sia nascosto da una versione della sottoclasse. Quindi potresti farlo finale impedire che venga nascosto nella sottoclasse. E puoi essere certo che il seguente codice chiamerà il metodo dalla tua classe A:

B b = new B();
b.ts();

Ok, ammettetamente che è in qualche modo costruito, ma potrebbe avere senso per alcuni casi.

Non dovresti chiamare metodi statici sulle istanze ma direttamente sulle classi, quindi non avrai quel problema. Anche IntelliJ IDEA, ad esempio, ti mostrerà un avviso, se chiami un metodo statico su un'istanza e anche se rendi finale un metodo statico.

Il metodo ts () in B non sovrascrive il metodo ts () in A, è semplicemente un altro metodo. La classe B non vede il metodo ts () in A poiché è statico, quindi può dichiarare il proprio metodo chiamato ts ().

Tuttavia, se il metodo è definitivo, il compilatore rileverà che esiste un metodo ts () in A che non dovrebbe essere sovrascritto in B.

Penso che l'errore di compilazione sia stato abbastanza fuorviante qui. Non avrebbe dovuto dire "il metodo sovrascritto è finale statico", ma avrebbe dovuto invece dire "il metodo sostituito è finale". Il modificatore statico è irrilevante qui.

Un metodo statico non può essere sovrascritto in Java, a differenza dei metodi non statici. Ma vengono ereditati come membri di dati statici e non statici. Ecco perché un metodo non statico con lo stesso nome non può essere creato nella classe genitore

class Writer { 
    public static void doo(){
        System.out.println("sth");
    } 
}
class Author extends Writer{ 
    public void doo(){
        System.out.println("ok"); // error overridden method is static
    }
}

La finalparola chiave garantisce che il corpo del metodo specifico venga eseguito ogni volta che viene chiamata al metodo. Ora se un metodo statico viene creato nella classe figlia con lo stesso nome e viene effettuata una chiamata al metodo, viene eseguito il metodo nella sottoclasse, il che non dovrebbe essere il caso se final è preceduto dal nome del metodo statico nella classe genitore . Quindi la parola chiave finale limita la creazione del metodo con lo stesso nome nella classe figlia.