Comparaison détaillée de la syntaxe de base de Java et Kotlin

Cet article présente principalement les informations pertinentes sur la comparaison de la syntaxe de base de Kotlin et Java. Les amis qui en ont besoin peuvent s'y référer

Comparaison de la syntaxe de base de Kotlin et Java

Kotlin Plus jeune que Java, mais c'est un langage de programmation très prometteur et sa communauté ne cesse de croître. Tout le monde en parlait et disait que c'était cool. Mais pourquoi est-ce si spécial ?

Nous avons préparé une série d'articles pour partager notre expérience dans le développement d'applications Android en Kotlin. Nous discuterons des différences entre Kotlin et Java en termes de syntaxe, de convivialité, de performances de l'interface utilisateur et d'asynchronicité afin que vous puissiez décider quel langage vous convient le mieux.

Commençons par quelques différences de syntaxe de base. Voici le premier :

1 Avec Kotlin, vous pouvez faire plus avec moins de code

Un avantage majeur de Kotlin C'est la simplicité de il. Vous obtenez plus de fonctionnalités avec moins de code. Et moins vous écrivez de code, moins vous faites d’erreurs. C'est très simple. Examinons les bases de Kotlin, en commençant par les cours.
Ce qui précède est une classe Java habituelle. Cela ne fait pas grand chose. Il contient juste quelques données. Mais il est douloureux de voir l’ampleur de ce code lorsque l’on réalise les lacunes qu’il apporte. Pour vous encourager, nous vous donnerons un cours équivalent écrit en Kotlin.

Oui, vous obtiendrez automatiquement les getters, setters, equals(), hashcode(), toString() et

copy

()Fonction

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

! Bien sûr, vous pouvez facilement remplacer ces fonctions, mais dans la plupart des cas, il suffit de déclarer la classe et ses

attributs

.

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

C'est exactement ce que nous voulons dire lorsque nous disons que Kotlin est concis. 2. Vous pouvez éviter NullPointerException

Nous voulons maintenant vous rappeler la plus grande douleur dans de nombreux langages de programmation. - Pointeur nul anormal. On peut difficilement imaginer combien de développeurs ont souffert du pointeur nul depuis que Tony Hall l'a inventé en 1965 en essayant de simplifier les choses.

Malheureusement, nous ne pouvons pas revenir à temps pour empêcher Tony de commettre cette erreur. Mais en utilisant Kotlin, nous pouvons désormais facilement échapper à NullPointerException.
Si la

variable

est nullable, le compilateur ne vous permettra pas d'y accéder sans une vérification appropriée. Kotlin vous oblige à l'utiliser ?
Opérateur

. Cela empêche l'application de planter automatiquement.

Comment ça marche sous le capot ? Passons en revue le bytecode généré.

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

Comme vous pouvez le constater, nous avons ici le même chèque vide. Les développeurs de JetBrains (qui ont créé Kotlin) savaient que vérifier nos variables à chaque fois était le seul moyen d'éviter NullPointerException. Mais ils savent aussi que les développeurs Android ne veulent pas gérer NullPointerException dans leurs projets. Ils pensent peut-être : "Pourquoi ne pas générer automatiquement cette vérification si la variable est nullable ? Les développeurs de JetBrains font simplement cela et nous facilitent la vie !

3 . Vous pouvez vous débarrasser des classes util

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

Parlons des choses laides liées à l'utilisation des classes util. Avez-vous déjà eu un projet sans elles ? fonctions d'extension - vous aide à vous débarrasser de toutes les classes util une fois pour toutes

Une fonction d'extension est presque une fonction Kotlin normale mais lorsque vous la déclarez, vous devez spécifier ce que l'instance aura. Classes qui étendent les fonctionnalités. fun Context.toast(text: String) = Toast.makeText(this, text, Toast.LENGTH_SHORT).show()

Notez que 'this' est ce que que nous utilisons comme paramètre passé à la méthode makeText() ? Ce n'est pas une instance de la classe que nous déclarons cette fonction, mais une instance de Context. Vous pouvez désormais appeler cette fonction directement depuis votre activité ou toute autre instance de contexte :

<🎜. >

Vous devez vous rappeler que la fonction d'extension ne modifie en aucune façon la classe qu'elle étend. Alors, comment cela fonctionne-t-il sans changer la classe d'origine ?

Ha ! Votre fonction reçoit implicitement une instance de la classe qu'elle étend comme premier argument, tout accès à "this" dans le corps de la fonction. sera remplacé par un accès au premier paramètre. Il n'y a pas vraiment de magie. Vous pouvez utiliser cette fonction n'importe où dans votre projet

toast("Hi")

Supprimer

votre package util

4. peut oublier la
vue

la liaison

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会有什么区别吗？

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!