Detaillierter Vergleich der grundlegenden Syntax von Java und Kotlin

In diesem Artikel werden hauptsächlich relevante Informationen zum Vergleich der grundlegenden Syntax von Kotlin und Java vorgestellt. Freunde, die sie benötigen, können darauf zurückgreifen

Vergleich der grundlegenden Syntax von Kotlin und Java

Kotlin Jünger als Java, aber es ist eine vielversprechende Programmiersprache mit einer wachsenden Community. Alle redeten darüber und sagten, es sei cool. Aber warum ist es so besonders? Wir haben eine Reihe von Artikeln vorbereitet, um unsere Erfahrungen bei der Entwicklung von Android
-Anwendungen in Kotlin zu teilen. Wir besprechen die Unterschiede zwischen Kotlin und Java in Bezug auf Syntax, Benutzerfreundlichkeit, UI-Leistung und Asynchronität, damit Sie entscheiden können, welche Sprache für Sie am besten geeignet ist.

Beginnen wir mit einigen grundlegenden Syntaxunterschieden. Hier ist der erste:

1 Mit Kotlin können Sie mit weniger Code mehr erreichen

Einer der Hauptvorteile von Kotlin Einfachheit davon. Sie erhalten mehr Funktionalität mit weniger Code. Und je weniger Code Sie schreiben, desto weniger Fehler machen Sie. Es ist ganz einfach. Schauen wir uns
die Grundlagen von Kotlin an, beginnend mit dem Unterricht.

Das Obige ist eine übliche Java-Klasse. Es bringt nicht viel. Es enthält nur einige Daten. Aber es ist schmerzhaft zu sehen, wie groß dieser Code ist, wenn man sich der Mängel bewusst wird, die er mit sich bringt. Um Sie zu ermutigen, bieten wir Ihnen einen gleichwertigen Kurs an, der in Kotlin geschrieben ist.

public final class Person {
  private String name;
  private int age;
  private float height;

  public Person(String name, int age, float height) {
    this.name = name;
    this.age = age;
    this.height = height;
  }

  public Person(String name, int age) {
    this.name = name;
    this.age = age;
    this.height = 1.8f;
  }

  public String getName() {
    return name;
  }

  public void setName(String name) {
    this.name = name;
  }

  public int getAge() {
    return age;
  }

  public void setAge(int age) {
    this.age = age;
  }

  public float getHeight() {
    return height;
  }

  public void setHeight(float height) {
    this.height = height;
  }

  @Override
  public String toString() {
    return "Person{" +
        "name='" + name + '\'' +
        ", age=" + age +
        ", height=" + height +
        '}';
  }

  @Override
  public boolean equals(Object o) {
    if (this == o) return true;
    if (o == null || getClass() != o.getClass()) return false;

    Person person = (Person) o;

    if (age != person.age) return false;
    if (Float.compare(person.height, height) != 0) return false;
    return name != null ? name.equals(person.name) : person.name == null
  }

  @Override
  public int hashCode() {
    int result = name != null ? name.hashCode() : 0;
    result = 31 * result + age;
    result = 31 * result + (height != +0.0f ? Float.floatToIntBits(height) : 0);
    return result;
  }  
}

Ja, Sie erhalten automatisch die erforderlichen Getter, Setter, equal(), hashcode(), toString() und

copy

()<🎜 für Ihre Datenklassenfunktion

data class Person(var name: String,
         var age: Int,
         var height: Float = 1.8f)

! Natürlich können Sie diese Funktionen problemlos überschreiben, aber in den meisten Fällen reicht es aus, nur die Klasse und ihre

Attribute zu deklarieren. Das ist genau das, was wir meinen, wenn wir sagen, dass Kotlin prägnant ist.
2. Sie können NullPointer

Ausnahme vermeiden

Jetzt möchten wir Sie an den größten Schmerz in vielen Programmiersprachen erinnern - Nullzeiger abnormal. Wir können uns kaum vorstellen, wie viele Entwickler unter dem Nullzeiger gelitten haben, seit Tony Hall ihn 1965 erfunden hat, als er versuchte, die Dinge einfacher zu machen.
Leider können wir nicht rechtzeitig zurückkommen, um zu verhindern, dass Tony diesen Fehler macht. Aber mit Kotlin können wir NullPointerException jetzt problemlos entkommen.

Wenn die

-Variable

nullbar ist, erlaubt Ihnen der Compiler nicht, ohne ordnungsgemäße Prüfung darauf zuzugreifen. Kotlin zwingt Sie dazu, es zu verwenden?

Betreiber

val person: Person? = null
...
person?.name = "John"

. Dadurch wird verhindert, dass die Anwendung automatisch abstürzt.

Wie funktioniert es unter der Haube? Sehen wir uns den generierten Bytecode an. Wie Sie sehen, haben wir hier den gleichen leeren Scheck. Die Entwickler von JetBrains (die Kotlin erstellt haben) wussten, dass die ständige Überprüfung unserer Variablen die einzige Möglichkeit war, NullPointerException zu vermeiden. Sie wissen aber auch, dass Android-Entwickler sich in ihren Projekten nicht mit NullPointerException auseinandersetzen wollen. Sie denken vielleicht: „Warum diese Prüfung nicht automatisch generieren, wenn die Variable nullbar ist?

Die Entwickler von JetBrains machen das einfach und machen unser Leben einfacher!

L2
LINENUMBER 18 L2
ALOAD 3
DUP
IFNULL L3
LDC "John"
INVOKEVIRTUAL igalata/com/kotlinexample/Person.setName (Ljava/lang/String;)V
GOTO L4
L3
POP

3 . Sie können Util-Klassen loswerden

Haben Sie jemals ein Projekt ohne sie gehabt? Eine clevere Lösung. Erweiterungsfunktionen – hilft Ihnen, alle Util-Klassen ein für alle Mal loszuwerden.
Eine Erweiterungsfunktion ist fast eine normale Kotlin-Funktion, aber wenn Sie sie deklarieren, müssen Sie angeben, was die Instanz haben soll. Klassen, die die Funktionalität erweitern.

fun Context.toast(text: String) = Toast.makeText(this, text, Toast.LENGTH_SHORT).show()

Beachten Sie, dass „this“ was ist Wir verwenden als Parameter, der an die Methode makeText() übergeben wird, keine Instanz der Klasse, die wir für diese Funktion deklarieren, sondern eine Kontextinstanz. Jetzt können Sie diese Funktion direkt von Ihrer Aktivität oder einer anderen Kontextinstanz aus aufrufen:

Sie sollten bedenken, dass die Erweiterungsfunktion die Klasse, die sie erweitert, in keiner Weise verändert. Wie funktioniert sie also, ohne die ursprüngliche Klasse zu ändern? 🎜>

toast("Hi")

Ha! Ihre Funktion erhält implizit eine Instanz der Klasse, die sie als erstes Argument erweitert. Jeder Zugriff auf „this“ im Funktionskörper wird durch einen Zugriff auf ersetzt Der erste Parameter. Sie können diese Funktion überall in Ihrem Projekt verwenden

Sie können

Ansicht
verbindlich

public final toast(Landroid/content/Context;Ljava/lang/String;)V
  @Lorg/jetbrains/annotations/NotNull;() // invisible, parameter 0
  @Lorg/jetbrains/annotations/NotNull;() // invisible, parameter 1
  L0
  ALOAD 1
  LDC "$receiver"
  INVOKESTATIC kotlin/jvm/internal/Intrinsics.checkParameterIsNotNull (Ljava/lang/Object;Ljava/lang/String;)V
  ALOAD 2
  LDC "text"
  INVOKESTATIC kotlin/jvm/internal/Intrinsics.checkParameterIsNotNull (Ljava/lang/Object;Ljava/lang/String;)V
  L1
  LINENUMBER 31 L1
  ALOAD 1
  ALOAD 2
  CHECKCAST java/lang/CharSequence
  ICONST_0
  INVOKESTATIC android/widget/Toast.makeText (Landroid/content/Context;Ljava/lang/CharSequence;I)Landroid/widget/Toast;
  INVOKEVIRTUAL android/widget/Toast.show ()V
  L2
  LINENUMBER 32 L2
  RETURN
  L3
  LOCALVARIABLE this Ligalata/com/kotlinexample/MainActivity; L0 L3 0
  LOCALVARIABLE $receiver Landroid/content/Context; L0 L3 1
  LOCALVARIABLE text Ljava/lang/String; L0 L3 2
  MAXSTACK = 3
  MAXLOCALS = 3

你还记得findViewById（）method（）吗？ 我们相信你不喜欢它。 我们也不是。 此外，我们不想为我们需要访问的每个视图声明变量和Butterknife注释。

你可以忘记与Kotlin Android Extensions的视图绑定。 不再需要创建变量和绑定视图。 您可以使用在xml布局中声明的标识符直接访问您的视图。

public class MainActivity extends AppCompatActivity {
  @Override
  protected void onCreate(@Nullable Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_main);

    Button button = (Button) findViewById(R.id.button);
    final TextView text = (TextView) findViewById(R.id.text); 
    button.setOnClickListener(new View.OnClickListener() {
      @Override
      public void onClick(View v) {
        text.setText("You've clicked a button");
      }
    });
  }
}

class MainActivity : AppCompatActivity() {

  override fun onCreate(savedInstanceState: Bundle?, persistentState: PersistableBundle?) {
    super.onCreate(savedInstanceState, persistentState)
    setContentView(R.layout.activity_main)

    button.setOnClickListener { text.text = "You've clicked a button" }
  }
}

这太简单了，不是吗？

基本上，findViewById（）方法仍在使用中。 但是没有必要自己写。 Kotlin会为你做。

当您使用Android扩展时，findCachedViewById（）函数和HashMap实例将会自动生成。 每次通过其标识符访问您的视图将被一个新的函数调用替换。 如果是第一次访问视图，此函数将调用通常的findViewById（）函数，并将接收的视图添加到HashMap中，以便在下次访问视图时从中检索视图。

5. 你可以更容易地使用集合

让我们谈谈Kotlin的集合。 因为我们经常需要使用数据模型集合执行困难的操作。 例如，我们可能有一个学生名单，我们需要从中检索三个A级成绩的学生和两个B成绩的学生。

看看Kotlin的解决方案：

var students = listOf(Student("John", 0), Student("Julia", 2), Student("Matt", 1),
        Student("Katie", 0), Student("Dan", 0))

var firstList = students.filter { it.mark == 0 }.take(3)
var secondList = students.filter { it.mark == 1 }.take(2)

下面是我们如何解决Java中的同样的问题：

ArrayList<Student> students = new ArrayList<Student>() {{
      add(new Student("John", 0));
      add(new Student("Julia", 2));
      add(new Student("Matt", 1));
      add(new Student("Katie", 0));
      add(new Student("Dan", 0));
}};

ArrayList<Student> firstList = new ArrayList<>();
ArrayList<Student> secondList = new ArrayList<>();

for (Student student: students) {
      boolean isFirstFilled = firstList.size() >= 3;
      boolean isSecondFilled = secondList.size() >= 2;

      if (isFirstFilled && isSecondFilled) break;
      int mark = student.getMark();
      if (mark == 0 && !isFirstFilled) {
        firstList.add(student);
      } else if (mark == 1 && !isSecondFilled) {
        secondList.add(student);
      }
    }

这只是一个小例子，说明如何在Kotlin和Java中使用集合，但你可以看到差别！ 你能想象如果我们处理一个大项目的集合，Kotlin会有什么区别吗？

Das obige ist der detaillierte Inhalt vonDetaillierter Vergleich der grundlegenden Syntax von Java und Kotlin. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!