Metodi di estensione statica a Kotlin

Come si definisce un metodo di estensione statica in Kotlin? È possibile? Al momento ho un metodo di estensione come mostrato di seguito.

public fun Uber.doMagic(context: Context) {
    // ...
}

L'estensione sopra può essere invocata su un'istanza.

uberInstance.doMagic(context) // Instance method

ma come posso renderlo un metodo statico come mostrato di seguito.

Uber.doMagic(context)         // Static or class method

Per raggiungere questo obiettivo Uber.doMagic(context), è possibile scrivere un'estensione sull'oggetto associato di Uber(è richiesta la dichiarazione dell'oggetto associato):

class Uber {
    companion object {}
}

fun Uber.Companion.doMagic(context: Context) { }

Questo è ciò che dice la documentazione ufficiale:

Kotlin genera metodi statici per funzioni a livello di pacchetto. Kotlin può anche generare metodi statici per le funzioni definite in oggetti con nome o oggetti associati se si annotano tali funzioni come @JvmStatic. Per esempio:

Metodi statici di Kotlin

class C {
  companion object {
    @JvmStatic fun foo() {}
    fun bar() {}
  }
}

Ora, foo () è statico in Java, mentre bar () non è:

C.foo(); // works fine
C.bar(); // error: not a static method

In realtà ho avuto questa domanda esatta 30 minuti fa, quindi ho iniziato a scavare e non sono riuscito a trovare alcuna soluzione o soluzione alternativa, MA durante la ricerca ho trovato questa sezione sul sito Web di Kotlinglang che afferma che:

Si noti che le estensioni possono essere definite con un tipo di ricevitore nullable. Tali estensioni possono essere richiamate su una variabile oggetto anche se il suo valore è nullo.

Quindi ho avuto l'idea più folle di sempre, perché non definire una funzione di estensione con un ricevitore nullable (senza effettivamente utilizzare quel ricevitore) e quindi chiamarla su un oggetto null! Quindi l'ho provato, e ha funzionato abbastanza bene, ma sembrava così brutto. Era così:

(null as Type?).staticFunction(param1, param2)

Quindi ho aggirato il problema creando un valore nel mio file delle estensioni del tipo destinatario che aveva un valore null e quindi lo usavo nell'altra mia classe. Quindi, ad esempio, ecco come ho implementato una funzione di estensione "statica" per la Navigationclasse in Android: Nel mio file NavigationExtensions.kt:

val SNavigation: Navigation? = null
fun Navigation?.createNavigateOnClickListener(@IdRes resId: Int, args: Bundle? = null, navOptions: NavOptions? = null,
                                                navigationExtras: Navigator.Extras? = null) : (View) -> Unit {
    //This is just implementation details, don't worry too much about them, just focus on the Navigation? part in the method declaration
    return { view: View -> view.navigate(resId, args, navOptions, navigationExtras) }
}

Nel codice che lo utilizza:

SNavigation.createNavigateOnClickListener(R.id.action_gameWonFragment_to_gameFragment)

Ovviamente, questo non è un nome di classe, è solo una variabile del tipo di classe che ha un valore nullo. Questo è ovviamente brutto dal lato del produttore dell'estensione (perché devono creare la variabile) e dal lato dello sviluppatore (perché devono usare il STypeformato anziché il nome della classe effettiva), ma è il più vicino che può essere raggiunto in questo momento rispetto alle effettive funzioni statiche. Si spera che i produttori di lingue Kotlin risponderanno al problema creato e aggiungano tale funzionalità nella lingua.

Puoi creare un metodo statico usando l'oggetto Companion come:

class Foo {
    // ...
    companion object {
        public fun bar() {
            // do anything
        }
    }
}

e quindi puoi chiamarlo come:

class Baz {
    // ...
    private fun callBar() {
        Foo.bar()
    }
}

Ti consiglio di guardare questo link. Come puoi vedere lì, dovresti semplicemente dichiarare il metodo al livello più alto del pacchetto (file):

package strings
public fun joinToString(...): String { ... }

Questo è uguale a

package strings;

public class JoinKt {
    public static String joinToString(...) { ... }
}

Con constan tutto è uguale. Questa dichiarazione

val UNIX_LINE_SEPARATOR = "\n"

è uguale a

public static final String UNIX_LINE_SEPARATOR = "\n";

Mi piace anche avere la possibilità di aggiungere metodi di estensione statica in Kotlin. Come soluzione alternativa per ora sto aggiungendo il metodo exntension a più classi invece di utilizzare un metodo di estensione statica in tutte.

class Util    

fun Util.isDeviceOnline(context: Context): Boolean {
    val connMgr = context.getSystemService(Context.CONNECTIVITY_SERVICE) as ConnectivityManager
    val networkInfo = connMgr.activeNetworkInfo
    return networkInfo != null && networkInfo.isConnected
}

fun Activity.isDeviceOnline(context: Context) = { Util().isDeviceOnline(context) }
fun OkHttpClient.isDeviceOnline(context: Context) = { Util().isDeviceOnline(context) }

Per creare un metodo di estensione in kotlin devi creare un file kotlin (non una classe) quindi dichiarare il tuo metodo nel file Ad esempio:

public fun String.toLowercase(){
    // **this** is the string object
}

Importa la funzione nella classe o nel file su cui stai lavorando e usala.