2016-03-31 15 views
5

Sto sovrascrivendo un metodo da una libreria Java e il parametro per la funzione è annotato come @NonNull. Tuttavia, quando viene chiamato il metodo, il parametro viene spesso con un valore null. Quando sovrascrivo il metodo in Kotlin, mi costringe a rispettare l'annotazione @NonNull e contrassegnare il parametro come non annullabile. Ovviamente, Kotlin lancia un'eccezione in fase di esecuzione quando il parametro entra in un valore nullo. C'è un modo per sovrascrivere il metodo in Kotlin e ignorare l'annotazione @NonNull?Come è possibile sovrascrivere un metodo java e modificare il nullability di un parametro?

In particolare, sto utilizzando la libreria appcompat per Android. Il metodo è in AppCompatActivity.java

@CallSuper 
public void onSupportActionModeFinished(@NonNull ActionMode mode) { 
} 

L'override in Kotlin:

override fun onSupportActionModeFinished(mode: ActionMode) { 
    super.onSupportActionModeFinished(mode) 
} 
+0

Il motivo è di vitale importanza che si segue il modello non nullo è perché si tratta anche con l'annotazione CallSuper. Se hai passato un valore nullo, non ci sarebbero stati controlli nel metodo super poiché l'annotazione è per garantire che il valore non sia nullo. Quasi sicuramente ti ritroverai con un NPE. Se non si sta chiamando questo metodo esplicitamente al di fuori del framework, non dovrebbe mai venire con un valore nullo, in quanto il framework rispetterà questa annotazione. – zgc7009

+0

La libreria chiama questo metodo e passa un valore nullo, non il mio codice. La libreria sta rompendo la propria annotazione. Quando eseguo l'override in Java e consento al null di passare al metodo super, non si verifica alcuna NPE. – brain

+0

Che diavolo, si, è strano. – zgc7009

risposta

4

Non sembra esserci alcun modo semplice per sopprimere la gestione delle annotazioni nullability da Kotlin compilatore.

Come soluzione alternativa, è possibile effettuare una classe derivata intermedia con @Nullable annotazioni in Java: quando Kotlin compilatore vede sia @Nullable e @NonNull sullo stesso elemento di codice si comporta come se non ci fossero le annotazioni valori Null. Quindi basta sottoclassi in Kotlin. Esempio:

consideri una classe con un parametro @NonNull in Java:

abstract class Base { 
    public abstract void f(@NonNull String str); 
    //... 
} 

Kotlin comprende l'annotazione: f(str: String), il tipo non è nullo.

Ora estendere Base in Java, l'override del metodo e aggiungere @Nullable annotazioni al parametro in Intermediate:

abstract class Intermediate extends Base { 
    @Override 
    public abstract void f(@Nullable String str); 
} 

Per Intermediate, Kotlin vede f(str: String!), il parametro ha platform type, cioè la sua annullabilità è sconosciuta.

Dopo di che, si sarà in grado di dichiarare parametro nullable in una sottoclasse di Kotlin Intermediate:

class Derived(): Intermediate() { 
    override fun f(url: String?) { ... } 
} 
+2

Spero solo che aggiungano un modo per sopprimere o ignorare questo avviso per casi come questo. È difficile creare quella classe intermedia solo per fissare un parametro. – brain

Problemi correlati