[JAVA] Kotlin Memorandum-Code Edition (Partie 1)
Mémorandum de Kotlin. Suite de la session précédente.
Dernière fois a écrit sur la création d'un environnement.
Et beaucoup de gens ont écrit sur Java-> Kotlin. Lorsque j'ai cherché sur Google, il y avait d'abord un message de cette personne, alors je l'ai utilisé comme référence.
Kogarasi Kotlin commençant par le développement Android
Cependant, le simple fait de le lire n'a pas de sens, alors Quoi qu'il en soit, vous devriez l'essayer J'écrirai ce que c'est en le touchant.
- Veuillez noter qu'il peut y avoir des erreurs d'interprétation.
Faire un cours
Eh bien, créons d'abord une classe.
-1. Hériter de AppCompatActivity -2. Implémenter View.OnClickListenerOnClickListener
Java
public class MainActivity extends AppCompatActivity implements View.OnClickListener {
}
kotlin
open class MainActivity : AppCompatActivity() , View.OnClickListener {
}
- "ouvrir" avant le cours
- La description des extensions et des outils a disparu
modificateur ouvert
Tout d'abord, sur "ouvert".
Les classes avec cette ouverture seront des classes héritables. Si vous n'ajoutez pas open, la classe ne peut pas être héritée.
Les trois visions du public, du privé et de la protection jusqu'à présent Je pense qu'il serait bon de se rappeler qu'il y a deux façons, avec ou sans ouverture.
Quel est le modificateur abstrait?
Je n'ai pas écrit cette fois, mais si vous voulez ajouter le modificateur abstrait,
kotlin
abstract open class HogeClazz {
}
Et mettez-le avant de l'ouvrir. Après vérification, il semble que dans le cas d'une classe abstraite, elle puisse être héritée sans ajouter open.
▼ Classe abstraite de source d'héritage
kotlin
abstract class AbstractSample {
abstract fun aaa() : Boolean
}
▼ Classe d'héritage
kotlin
open class ExtendsClazz : AbstractSample() {
override fun aaa() : Boolean {
return false;
}
}
Puisqu'il a été fait avec une classe abstraite, il semble qu'il serait normalement hérité, non?
Si vous l'essayez, il semble que vous puissiez mettre le privé devant la classe. Vous pouvez définir la visibilité pour pouvoir le faire.
Si tel est le cas, le commentaire selon lequel l'ouverture précédente devrait être incorporée dans les trois modèles de visibilité ne semble pas être une bonne interprétation. open-> peut être hérité open-> ne peut pas être hérité Je m'en souviendrai simplement.
Bref, qu'est-ce qu'un cours privé? Vous devez voir dans quelle mesure les cours privés sont accessibles. .. À propos de cela plus tard ...
interface À quoi ressemble l'interface? Nous allons jeter un coup d'oeil.
java
public interface IBaseListener {
void onSuccess();
void onError(String message, Throwable e);
}
kotlin
interface IBaseListener {
fun onSuccess()
fun onError(message: String, e: Throwable)
}
C'est presque pareil. À propos, vous pouvez également ajouter le modificateur ouvert à l'interface. Cela n'a pas d'importance si vous ne pouvez pas l'implémenter sans ouverture.
Classe intérieure
Le premier est la classe interne, qui n'hérite ni n'implémente quoi que ce soit en particulier. Passons le contexte et la chaîne comme arguments et faisons-en une classe qui les contient.
java
private class InnerClass {
private Context mContext;
private String mString;
public InnerClass(final Context context, final String str) {
mContext = context;
mString = str;
}
}
kotlin
private inner class InnerClass(private val mContext: Context, private val mString: String)
C'est devenu beaucoup plus court. Il semble que vous puissiez voir chaque partie.
Définition de la classe intérieure
En Java, ce n'était pas explicitement indiqué, mais dans Kotlin "Je vais écrire une classe intérieure! Est-ce que ça va? Je vais l'écrire !!!!" Il semble qu'il soit nécessaire d'écrire «classe interne» juste pour dire.
private inner class InnerClass
() Après le nom de la classe
Il ya quelque chose (). Qu'est-ce qui n'est pas spécial à Java? Comparons Java avant conversion et Kotlin après conversion.
Java
private class InnerClass {
private Context mContext;
private String mString;
public InnerClass(final Context context, final String str) {
mContext = context;
mString = str;
}
}
private inner class InnerClass(private val mContext: Context, private
val mString: String)
Je l'ai posté deux fois, mais en bref, il semble que le constructeur puisse être omis.
Cependant, étant donné qu'il s'agit d'un constructeur qui met des valeurs dans mContext et mString, n'est-ce pas comme ça? Essayons.
Sans rien faire dans le constructeur, essayez d'ajouter une méthode d'initialisation et de placer des valeurs dans mContext et mString.
java
private class InnerClass {
private Context mContext;
private String mString;
public InnerClass() {
}
public void initialize(final Context context, final String str) {
mContext = context;
mString = str;
}
}
kotlin
private inner class InnerClass {
private var mContext: Context? = null
private var mString: String? = null
fun initialize(context: Context, str: String) {
mContext = context
mString = str
}
}
Je vois. Ainsi, lorsque vous utilisez un constructeur, vous pouvez le traiter avec () comme ceci!
... Et si vous l'appeliez super dans le constructeur? ?? ?? ?? Essayons.
Laissez la classe interne hériter de View et afficher celle avec deux constructeurs dans Kotlin.
java
private class InnerClass extends View {
private Context mContext;
private AttributeSet mAttr;
public InnerClass(Context context) {
super(context);
mContext = context;
}
public InnerClass(Context context, @Nullable AttributeSet attrs) {
super(context, attrs);
mContext = context;
mAttr = attrs;
}
}
kotlin
private inner class InnerClass : View {
private var mContext: Context? = null
private val mAttr: AttributeSet
constructor(context: Context) : super(context) {
mContext = context
}
constructor(context: Context, attrs: AttributeSet?) : super(context, attrs) {
mContext = context
mAttr = attrs
}
}
Oh! !! !!
Vous écrivez "constructeur". Appeler super après le ":" Il semble écrire d'autres traitements entre parenthèses.
Il semble que vous ayez une habitude différente qu'avant. Cela semble devoir être rappelé.
À propos, quand il n'y avait qu'un seul constructeur, la description était différente.
Dans un cas
kotlin
private inner class InnerClass(private val mContext: Context) : View(mContext) {
}
Il semble que la description du constructeur puisse être omise.
// Addenda J'étais un peu inquiet et j'ai essayé de le découvrir, mais cela ne se limitait pas à la classe intérieure. .. ..
Donc, cette déclaration s'applique à n'importe quelle classe régulière.
kotlin
open class HogeClass(private val mContext: Context) : View(mContext) {
}
La même description s'applique lorsqu'une classe qui hérite de View est générée, comme dans.
Eh bien, plus tôt
Après l'avoir essayé, il semble que le privé puisse être ajouté avant la classe.
Je l'ai mentionné plus tôt, mais c'est peut-être la visibilité fournie pour cette classe interne. Vous ne pourrez peut-être pas comprendre ce point à moins d'aller un peu plus loin. .. ..
Variables et constantes
Regardons les variables et les constantes.
java
private static final int TEISU_INT = 0;
private static final String TEISU_STRING = "hoge";
private Context mContext;
private View mView;
kotlin
private val mContext: Context? = null
private val mView: View? = null
companion object {
private val TEISU_INT = 0
private val TEISU_STRING = "hoge"
}
variable
Tout d'abord, expliquons les variables.
private val hoge: String? = null
val et var
private ** val ** ← ce gars
Cela a le même rôle que le modificateur final en Java.
java
final String strHoge = "hoge";
strHoge = "huga";★ Erreur de compilation car l'affectation n'est pas possible
String strHuga = "hoge";
strHuga = "huga";★ Peut être remplacé
C'est le cas de Kotlin.
kotlin
val strHoge: String? = "hoge";
strHoge = "huga";★ Erreur de compilation car l'affectation n'est pas possible
var strHuga: String? = "hoge";
strHuga = "huga";★ Peut être remplacé
Ce n'est pas autant qu'écrire. ..
Définition d'objet
hoge **: String ** ← Ce mec
C'est la partie. Puisque l'ordre de spécification est opposé à celui de Java, chaque fois que je commence à écrire Kotlin "Oh ... je l'ai encore fait" Ce sera w
Jusqu'à présent, la spécification de l'objet -> nom de la variable a d'abord été remplacée par le nom de la variable. En effet, Kotlin ne vous oblige plus à spécifier un objet.
En d'autres termes, il est désormais possible de définir par inférence de type. pour cette raison
kotlin
var hoge = null
Bien sûr, ça va. Cependant, pour ceux qui ont fait Java jusqu'à présent, c'est vraiment difficile. Je ne sais pas quoi mettre ni quoi utiliser. Si hoge est un nom de variable, c'est superflu.
Donc je ne sais pas comment l'utiliser dans le futur, mais normalement
- var ou val
- Nom de variable
- Spécifiez l'objet
Je pense que c'est normal de l'écrire comme ça.
"?" Derrière l'objet
: Chaîne **? ** ← Ce mec
Qu'est-ce que c'est?
Je l'ai interprété comme identique à l'annotation NonNull et à l'annotation Nullable en Java. Pour le moment, c'est le comportement avec et sans "?".
kotlin
var str1: String?
str =null ★ Qu'est-ce que c'est? Puisqu'il est Nullable, l'attribution nulle est OK
var str2: String
str =null ★ Qu'est-ce que c'est? Null substitution NG car il n'y a aucun Null
cette? Je pense que la désignation équivaut à ce que les développeurs rapides appellent «type optionnel» et «type non optionnel».
Cela peut être familier à ceux qui font du swift, mais cela peut prendre un certain temps pour l'accepter car il est trop peu familier à ceux qui ont toujours développé Java pour Android. En ce qui concerne la gestion de cette zone, je voudrais écrire un article séparé et l'organiser correctement.
constant
Vient ensuite une constante. Le style d'écriture a radicalement changé, donc je pense qu'il suffit d'apprendre à le spécifier pour le moment. J'écrirai à nouveau le code.
Définition constante dans kotlin
companion object {
private val TEISU_INT = 0
private val TEISU_STRING = "hoge"
}
Je l'ai traduit avec un compagnon. ..
Vous sentez-vous "l'un à l'autre"? ??
Au fait, s'il est privé, il ne peut pas être référencé à partir d'autres classes, bien sûr. Il était possible de s'y référer sans privé. Il est traité comme public. Je n'ai pas pu spécifier protégé car il semble que la visibilité soit perdue.
Définition constante dans kotlin
companion object {
private val TEISU_INT =0 ← Ne peut pas être référencé à partir d'autres classes
val TEISU_STRING = "hoge"← Peut être référé d'autres classes
}
Pour le moment, j'ai créé une classe, puis défini des variables, etc.
Ah, si vous ajoutez "; (point-virgule)" à la fin de l'instruction, vous obtiendrez une erreur de compilation, donc je pense que vous l'ajouterez comme habitude, mais soyez prudent.
J'écrirai beaucoup d'autres choses, mais je vais le laisser ici pour l'instant.
Aussi, si vous voulez voir un échantillon de kotlin, vous voudrez peut-être le voir ici. https://try.kotlinlang.org/