Comportamento del metodo statico finale

Question

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

Come sappiamo, i metodi statici non possono essere sovrascritti, in quanto associati alla classe anziché all'istanza.

Quindi, se ho il frammento di codice 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 in classe A, quindi la compilazione fallisce ts() in B non può ignorare ts() in un; il metodo sovrascritto è statico finale.

Perché ciò accade quando il metodo statico non può essere sovrascritto?

Answer 1

I metodi statici non possono essere sovrascritti ma possono essere nascosti. Il metodo ts() di B non è prioritario (non soggetto a polimorfismo) il ts() di A, ma lo nasconderà. Se chiami ts() in B (NON A.ts() o B.ts() ... solo ts()), quello di B sarà chiamato e non A. Poiché questo non è soggetto al polimorfismo, la chiamata ts() in A non verrà mai reindirizzata a quella in B.

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

Spero che questo aiuti.

Answer 2

metodi statici non possono essere sovrascritte

Questo non è esattamente vero. Il codice di esempio in realtà significa che il metodo ts in B nasconde il metodo ts in A. Quindi non è esattamente override. Oltre a Javaranch c'è una bella spiegazione.

Answer 3

Il metodo ts() in B non sta sovrascrivendo 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 è definitiva, quindi il compilatore prelevamento che esiste un metodo ts() in A che non dovrebbe essere ignorato in B.

Answer 4

metodi statici appartengono alla classe, non l'istanza .

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

Il vero problema è che Java consente di chiamare metodi statici su un oggetto istanza. I metodi statici con la stessa firma della classe genitore sono hidden quando vengono chiamati da un'istanza della sottoclasse. Tuttavia, non è possibile ignorare/nascondere final methods.

si potrebbe pensare che il messaggio di errore potrebbe usare la parola nascosta, invece di sovrascritto ...

Answer 5

penso che l'errore di compilazione è del tutto fuorviante qui. Non avrebbe dovuto dire che "il metodo sovrascritto è statico finale", ma dovrebbe invece dire che "il metodo sovrascritto è definitivo". Il modificatore statico è irrilevante qui.

Answer 6

Potreste trovarvi nella posizione di pensare di fare un ultimo metodo statico, considerando quanto segue:

aventi 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' a chiamare questi metodi sarebbe

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

che si tradurrebbe in AB ma si potrebbe anche chiamare i metodi su casi:

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

che risulterebbe in AB pure.

Consideriamo ora il seguente:

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

che stampare A. Questo potrebbe sorprenderti dato che hai effettivamente un oggetto della classe B. Ma dal momento che lo chiami da un riferimento di tipo A, chiamerà A.ts(). Si potrebbe stampare B con il seguente codice:

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

In entrambi i casi l'oggetto che hai è in realtà dalla classe B. Ma a seconda del puntatore che punta all'oggetto, chiamerai il metodo da A o da B.

Ora supponiamo che tu sia lo sviluppatore della classe A e desideri consentire la sottoclassificazione. Ma vuoi davvero il metodo ts(), ogni volta che viene chiamato, anche da una sottoclasse, cioè fa ciò che vuoi che faccia e non sia nascosto da una versione di sottoclasse. Quindi potresti renderlo final e impedire che venga nascosto nella sottoclasse. E si può essere sicuri che il seguente codice chiamerà il metodo dalla classe A:

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

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

Non dovresti chiamare metodi statici su istanze ma direttamente sulle classi - quindi non avrai questo problema. Ad esempio, IntelliJ IDEA ti mostrerà un avviso, se chiami un metodo statico su un'istanza e anche se definisci un metodo statico definitivo.