Cours d'enseignement d'apprentissage novice Kotlin

Code d'interface d'origine:

public @ interface ActivityScoped { 
}

Code d'interface Kotlin:

classe d'annotation ActivityScoped

Méthode d'implémentation d'origine:

@Override
 vide inject (instance de DaggerApplication) ;

Application AppComponent.Builder (Application application) ;

Méthode d'implémentation de Kotlin:

remplacer l' injection amusante (instance: DaggerApplication)

application amusante (application: Application): AppComponent.Builder

1. Utilisation puissante: connexion du côlon

2. éviter d'être remplacé par du plaisir

Contrôles définis à l'origine:

ImageView mPlayingUserAvatar ;

Contrôle de définition de Kotlin:

var interne mPlayingUserAvatar : ImageView ? = null

1. interne signifie domaine de définition

2. Toutes les variables doivent ajouter var

3. Variables de classe puissantes: classe

4.? Le point d'interrogation indique s'il est vide 

Le code d'origine définit statique:

int statique final privé CACHE_STRATEGY_FAST = 1 ;

Kotlin définit statique:

objet compagnon {
     var mHandler : Handler? = null
     val privé CACHE_STRATEGY_FAST = 1   // 极速
 val privé CACHE_STRATEGY_SMOOTH = 2   // 流畅
 val privé CACHE_STRATEGY_AUTO = 3   // 自动
 val privé CACHE_TIME_FAST = 1.0f
 val privé CACHE_TIME_SMOOTH = 5.0f

                

}

1. L'indicateur statique statique est ajouté à l'objet compagnon pour singleton

2. Toutes les variables qui définissent les types de variables sont remplacées par var

Méthode d'alimentation d'origine:

carte privée <chaîne , chaîne> mUrlMap = new HashMap <> () ;

Méthode de résistance de Kotlin:

private val mUrlMap = HashMap <String , String> ()

1. La variable directe est égale à celle à renforcer

Variables d'initialisation d'origine:

private int mCacheStrategy ;
private String mPlayUrl ;

Variables d'initialisation de Kotlin:

var var mCacheStrategy : Int = 0
 var var mPlayUrl : String? = null

1. Ajoutez var devant 

2. Besoin d'ajouter un type de chaîne? Bon pour juger s'il est vide et attribuer null

Écrire à l'origine une méthode avec une valeur de retour:

public int getDeviceId () {
     return mEntity .getId () ;
}

Kotlin écrit une méthode avec une valeur de retour:

val deviceId : Int
     get () = mEntity !!. id

1.val pour indiquer nouveau. Des variables et des méthodes doivent être ajoutées

2. La méthode du type get supprime les minuscules de la première lettre du get comme nom de méthode et donne au nom de la méthode un signe deux-points suivi du type de valeur de retour

3.get () = Ajouter les données à retourner après

4. Si vous avez besoin d'ajouter de la logique pour obtenir (), vous devez obtenir () {Ajoutez-le ici, puis renvoyez-le avec return}

5. Lors de l'écriture de méthodes, le vide public peut être remplacé par du plaisir

6. Tous les types de valeurs peuvent être définis avec var lors de l'attribution

7.! ! Cela signifie que le premier chargement peut être vide, et vous devez l'ajouter lors de l'appel des méthodes à l'intérieur de la classe instanciée !!

Le commutateur d'origine utilise un jugement multi-conditions

switch ( action ) {
     case AppConstant. UP :
         mGamePresenter .up () ;
        Pause;
    case AppConstant. BAS :
         mGamePresenter .down () ;
        Pause; 
}

Kotlin l'a remplacé par quand:

quand (action) { 
    AppConstant. UP -> mGamePresenter !!. Up () 
    AppConstant. DOWN -> mGamePresenter !!. Down () 
  
}

1. !! signifie que le premier chargement peut être vide, et vous devez l'ajouter lors de l'appel des méthodes à l'intérieur de la classe instanciée !!.

2. Pas besoin d'ajouter à la fin;

Comparaison de méthodes complètes

public void onFinish () { 
    CountDownTimer timer = mTimerMap .get ( action ) ;
    if (timer! = null ) { 
        timer.cancel () ;
    } 
}

Kotlin:

 fun onFinish () {
     val timer = mTimerMap [action] 
    timer? .cancel () 
}

1. Le vide public peut être remplacé par du plaisir

2. Lorsque l'affectation est nécessaire, var peut être directement converti en celui correspondant en fonction du type d'affectation ultérieur, de sorte que toutes les variables affectées peuvent être définies avec var

3.? Le symbole de point d'interrogation correspond à si la minuterie est vide

4. La méthode get peut être changée en crochets au lieu de tableaux

Le besoin d'origine de forcer le code d'affectation de l'objet:

ActivityManager am = (ActivityManager) getSystemService ( ACTIVITY_SERVICE ) ;

Kotlin doit forcer le code d'affectation de l'objet:

val am = getSystemService (Context. ACTIVITY_SERVICE ) en tant que ActivityManager

1. Changement forcé à ajouter, suivi du type à forcer

Fil de départ d'origine:

new Thread(new Runnable() {
    @Override
    public void run() {
        while (showDanmaku) {
            int time = new Random().nextInt(300);
            
            try {
                Thread.sleep(time);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}).start();

Kotlin开启线程：

Thread(Runnable {
    while (showDanmaku) {
        val time = Random().nextInt(300)
   
        try {
            Thread.sleep(time.toLong())
        } catch (e: InterruptedException) {
            e.printStackTrace()
        }

    }
}).start()

1.不需要实例化new

2.不需要实现run()方法

后续还有偶