[JAVA] Kotlin Memorandum-Code Edition (Teil 1)

Kotlin Memorandum. Fortsetzung der vorherigen Sitzung.

Letztes Mal schrieb über das Erstellen einer Umgebung.

Und viele Leute haben über Java-> Kotlin geschrieben. Als ich gegoogelt habe, gab es zuerst einen Beitrag von dieser Person, also habe ich ihn als Referenz verwendet.

Kogarasis Kotlin beginnt mit der Android-Entwicklung

Es macht jedoch keinen Sinn, es nur zu lesen Wie auch immer, du solltest es versuchen Ich werde schreiben, wie es ist, indem ich es berühre.

Mach eine Klasse

Nun, lassen Sie uns zuerst eine Klasse erstellen.

-1 AppCompatActivity erben -2. Implementieren Sie View.OnClickListenerOnClickListener

Java


public class MainActivity extends AppCompatActivity implements View.OnClickListener {

}

kotlin


open class MainActivity : AppCompatActivity() , View.OnClickListener {

}

Modifikator öffnen

Zunächst über "offen".

Klassen mit diesem offenen Status sind vererbbare Klassen. Wenn Sie open nicht hinzufügen, kann die Klasse nicht vererbt werden.

Die drei Sichtbarkeit von öffentlich, privat und geschützt bisher Ich denke, es wäre gut, sich daran zu erinnern, dass es zwei Möglichkeiten gibt, mit oder ohne Offenheit.

Was ist der abstrakte Modifikator?

Ich habe diesmal nicht geschrieben, aber wenn Sie den abstrakten Modifikator hinzufügen möchten,

kotlin


abstract open class HogeClazz {

}

Und legen Sie es vor dem Öffnen. Nach der Überprüfung scheint es, dass eine abstrakte Klasse vererbt werden kann, ohne open hinzuzufügen.

▼ Vererbungsquelle abstrakte Klasse

kotlin


abstract class AbstractSample {
    abstract fun aaa() : Boolean
}

▼ Vererbungsklasse

kotlin


open class ExtendsClazz : AbstractSample() {
    override fun aaa() : Boolean {
        return false;
    }
}

Da es mit einer abstrakten Klasse erstellt wurde, scheint es, als würde es normalerweise vererbt, oder?

Wenn Sie es versuchen, scheint es, dass Sie privat vor die Klasse stellen können. Sie können die Sichtbarkeit so einstellen, dass Sie dies tun können.

Wenn dies der Fall ist, scheint der Kommentar, dass die vorherige Öffnung in die drei Sichtbarkeitsmuster aufgenommen werden sollte, keine gute Interpretation zu sein. open-> kann vererbt werden open-> kann nicht vererbt werden Ich werde mich nur daran erinnern.

Was ist eine Privatklasse? Sie müssen sehen, wie weit auf private Klassen zugegriffen werden kann. .. Darüber später ...

interface Wie sieht die Schnittstelle aus? Lass uns einen Blick darauf werfen.

java


public interface IBaseListener {
    void onSuccess();
    void onError(String message, Throwable e);
}

kotlin


interface IBaseListener {
    fun onSuccess()
    fun onError(message: String, e: Throwable)
}

Es ist fast das gleiche. Übrigens können Sie der Schnittstelle auch den Modifikator open hinzufügen. Es scheint keine Rolle zu spielen, ob Sie es nicht ohne open implementieren können.

Innere Klasse

Die erste ist die innere Klasse, die nichts Besonderes erbt oder implementiert. Übergeben wir den Kontext und die Zeichenfolge als Argumente und machen sie zu einer Klasse, die sie nur enthält.

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)

Es ist viel kürzer geworden. Es scheint, dass Sie jeden Teil sehen können.

Definition der inneren Klasse

In Java wurde es nicht explizit angegeben, sondern in Kotlin "Ich werde eine innere Klasse schreiben! Ist es okay? Ich werde es schreiben !!!!" Es scheint notwendig zu sein, "innere Klasse" zu schreiben, nur um es zu sagen.

private inner class InnerClass

() Nach dem Klassennamen

Da ist etwas (). Was um alles in der Welt ist das, was in Java nicht besonders ist? Vergleichen wir Java vor der Konvertierung und Kotlin nach der Konvertierung.

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)

Ich habe es zweimal gepostet, aber kurz gesagt, es scheint, dass der Konstruktor weggelassen werden kann.

Da dies jedoch ein Konstruktor ist, der Werte in mContext und mString einfügt, ist das nicht so? Lass es uns versuchen.

Fügen Sie, ohne etwas im Konstruktor zu tun, eine Initialisierungsmethode hinzu und fügen Sie dort Werte in mContext und mString ein.

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
        }
    }

Das war's. Wenn Sie also einen Konstruktor verwenden, können Sie ihn mit () wie folgt verarbeiten!

... Was ist, wenn Sie es im Konstruktor super nennen? ?? ?? ?? Lass es uns versuchen.

Lassen Sie die innere Klasse View erben und die mit zwei Konstruktoren in Kotlin anzeigen.

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! !! !!

Sie schreiben "Konstruktor". Super nach dem ":" Es scheint andere Verarbeitungen in Klammern zu schreiben.

Es scheint, dass Sie eine andere Angewohnheit haben als zuvor. Dies scheint in Erinnerung zu bleiben.

Wenn es nur einen Konstruktor gab, war die Beschreibung übrigens anders.

In einem Fall

kotlin


private inner class InnerClass(private val mContext: Context) : View(mContext) {
}

Es scheint, dass die Beschreibung des Konstruktors weggelassen werden kann.

// Nachtrag Ich war ein wenig besorgt und versuchte es herauszufinden, aber dies war nicht auf die innere Klasse beschränkt. .. ..

Diese Aussage gilt also für jede reguläre Klasse.

kotlin


open class HogeClass(private val mContext: Context) : View(mContext) {
}

Die gleiche Beschreibung gilt, wenn eine Klasse generiert wird, die View erbt, wie in.

Nun, früher

Nach dem Versuch scheint es, dass privat vor dem Unterricht hinzugefügt werden kann.

Ich habe es bereits erwähnt, aber vielleicht ist es wahrscheinlich die Sichtbarkeit, die für diese innere Klasse bereitgestellt wird. Möglicherweise können Sie diesen Punkt nur verstehen, wenn Sie etwas weiter gehen. .. ..

Variablen und Konstanten

Schauen wir uns Variablen und Konstanten an.

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

Lassen Sie uns zunächst die Variablen erklären.

private val hoge: String? = null

val und var

privat ** val ** ← dieser Typ

Dies hat dieselbe Rolle wie der letzte Modifikator in Java.

java


final String strHoge = "hoge";
strHoge = "huga";★ Kompilierungsfehler, da keine Zuordnung möglich ist

String strHuga = "hoge";
strHuga = "huga";★ Kann ersetzt werden

Dies ist bei Kotlin der Fall.

kotlin


val strHoge: String? = "hoge";
strHoge = "huga";★ Kompilierungsfehler, da keine Zuordnung möglich ist

var strHuga: String? = "hoge";
strHuga = "huga";★ Kann ersetzt werden

Es ist nicht so viel wie schreiben. ..

Objektdefinition

hoge **: String ** ← Dieser Typ

Das ist der Teil. Da die Reihenfolge der Spezifikation der von Java entgegengesetzt ist, beginne ich jedes Mal, Kotlin zu schreiben "Oh ... ich habe es wieder getan" Es wird w sein

Bisher wurde die Objektspezifikation-> Variablenname zuerst in den Variablennamen geändert. Dies liegt daran, dass Sie bei Kotlin kein Objekt mehr angeben müssen.

Mit anderen Worten ist es jetzt möglich, durch Typinferenz zu definieren. aus diesem Grund

kotlin


var hoge = null

Natürlich ist es OK. Für diejenigen, die bisher Java gemacht haben, ist dies jedoch sehr schwierig. Ich weiß nicht, was ich eingeben oder verwenden soll. Wenn hoge ein Variablenname ist, ist er überflüssig.

Ich weiß also nicht, wie ich es in Zukunft verwenden soll, aber normalerweise

  1. var oder val
  2. Variablenname
  3. Geben Sie das Objekt an

Ich denke, es ist okay, es so zu schreiben.

"?" Hinter dem Objekt

: String **? ** ← Dieser Typ

Was ist das?

Ich habe es genauso interpretiert wie die Annotation NonNull und die Annotation Nullable in Java. Vorerst ist es das Verhalten mit und ohne "?".

kotlin


var str1: String?
str =null ★ Was ist das? Da es Nullable ist, ist die Nullzuweisung in Ordnung

var str2: String
str =null ★ Was ist das? Nullsubstitution NG, da es keine None Null gibt

Dies? Ich denke, dass die Bezeichnung dem entspricht, was die schnellen Entwickler "optionaler Typ" und "nicht optionaler Typ" nennen.

Es mag denjenigen bekannt sein, die es schnell machen, aber es kann einige Zeit dauern, es zu akzeptieren, da es denen, die Java für die Android-Entwicklung die ganze Zeit gemacht haben, zu unbekannt ist. In Bezug auf die Behandlung dieses Bereichs möchte ich einen separaten Artikel schreiben und ihn richtig organisieren.

Konstante

Weiter ist eine Konstante. Der Schreibstil hat sich drastisch geändert, daher denke ich, dass es ausreicht, zu lernen, wie man ihn vorerst spezifiziert. Ich werde den Code noch einmal schreiben.

Konstante Definition in Kotlin


    companion object {
        private val TEISU_INT = 0
        private val TEISU_STRING = "hoge"
    }

Ich habe es mit Begleiter übersetzt. .. Fühlt es sich wie "einander" an? ?? image.png

Übrigens, wenn es privat ist, kann es natürlich nicht aus anderen Klassen referenziert werden. Es war möglich, ohne private darauf zu verweisen. Es wird als öffentlich behandelt. Ich konnte nicht geschützt angeben, da die Sichtbarkeit anscheinend verloren geht.

Konstante Definition in Kotlin


    companion object {
        private val TEISU_INT =0 ← Kann nicht von anderen Klassen referenziert werden
        val TEISU_STRING = "hoge"← Kann aus anderen Klassen bezogen werden
    }

Vorerst habe ich eine Klasse erstellt, dann Variablen definiert und so weiter.

Ah, wenn Sie am Ende der Anweisung "; (Semikolon)" hinzufügen, wird ein Kompilierungsfehler angezeigt. Ich denke, Sie werden ihn als Gewohnheit hinzufügen, aber seien Sie vorsichtig.

Ich werde viele andere Dinge schreiben, aber ich werde es vorerst hier lassen.

Wenn Sie ein Beispiel für Kotlin sehen möchten, können Sie es auch hier sehen. https://try.kotlinlang.org/

Recommended Posts

Kotlin Memorandum-Code Edition (Teil 1)
Anmerkung: Kotlin + Raum + RecyclerView + Datenbindung (Teil 2)
Kotlins Klasse Teil 2 zum Senden an Java-Entwickler