Kotlin 与 Java基本语法对比

kotlin 与 java基本语法对比

kotlin比java更年轻，但它是一个非常有前途的编程语言，它的社区不断增长。 每个人都在谈论它，并说它很酷。 但为什么这么特别？

我们准备了一系列文章，分享我们在kotlin开发android应用程序的经验。 我们将讨论kotlin与java在语法，可用性，ui性能和异步性方面的区别，以便您可以决定哪种语言最适合您。

让我们从一些基本的语法差异开始。 这是第一个：

1. 使用kotlin，你可以用更少的代码做更多

kotlin的一个主要优点是它的简洁。 你用更少的代码获得更多的功能。 而你写的代码越少，你犯的错误就越少。 这很简单。 让

我们看看kotlin的基础知识，从类开始。

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

上面是一个通常的java类。 它做的不多。 它只包含一些数据。 但是，当你意识到它给表带来的不足时，看看这段代码有多大是很痛苦的。 为了鼓励你，我们会给你一个等同的类写在kotlin。

data class person(var name: string,
         var age: int,
         var height: float = 1.8f)

是的，你会为你的数据类自动获取需要的getters，setters，equals（），hashcode（），tostring（）和copy（）函数！ 当然，你可以轻松地重写这些函数，但在大多数情况下，只需声明类及其属性就足够了。

这正是我们的意思，当我们说kotlin简洁。

2. 你可以避免 nullpointerexception

现在我们想提醒你在许多编程语言中最大的痛苦 - 空指针异常。 我们几乎不能想象自从托尼·霍尔在1965年发明它之后，有多少开发者遭受了空指针，同时试图使事情更简单一些。

可悲的是，我们不能及时回来，防止tony犯这个错误。 但是使用kotlin，我们现在可以轻松地转义nullpointerexception。

val person: person? = null
...
person?.name = "john"

如果变量是可空的，编译器将不允许你访问它没有适当的检查。 kotlin强迫你使用？ 运算符。 这可以防止应用程序自动崩溃。
它如何在引擎盖下工作？ 让我们回顾一下生成的字节码。

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

正如你所看到的，我们在这里有相同的空检查。 jetbrains的开发人员（创建kotlin）知道每次检查我们的变量是避免nullpointerexception的唯一方法。 但他们也知道android开发人员不想在他们的项目中处理nullpointerexception。 他们可能想：“为什么不自动生成这个检查如果变量是可空的？

jetbrains的开发人员只是这样，让我们的生活更容易了！

3. 你可以摆脱util类

让我们来讨论一下有关使用util类的丑陋事情。 你有没有一个项目没有他们？ 我们几乎不记得这一切。 kotlin有一个聪明的解决方案 - 扩展功能 - 帮助你摆脱所有的util类一劳永逸。

扩展函数几乎是一个通常的kotlin函数。 但是当你声明它，你需要指定的实例将具有扩展功能的类。
fun context.toast(text: string) = toast.maketext(this, text, toast.length_short).show()

注意'this'，我们作为参数传递给maketext（）方法？ 它不是类的一个实例，我们声明这个函数，而是一个context实例。 现在你可以直接从你的activity或任何其他context实例调用这个函数。 例如：

toast("hi")

你应该记住，扩展函数不以任何方式修改它扩展的类。 那么它如何工作而不改变原来的类？ 让我们再次看到字节码。

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

哈！ 您的函数隐式接收它作为第一个参数扩展的类的实例。 因此，在字节码中，对函数体中“this”的任何访问都将替换为对第一个参数的访问。 没有魔法真的。 您可以在项目的任何位置使用此函数。

时间删除你的util包！

4. 你可以忘记视图绑定

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

感谢阅读，希望能帮助到大家，谢谢大家对本站的支持！