Kotlin boleh mengintegrasikan dengan lancar dengan Java kerana kedua -dua run pada JVM dan bytecode adalah saling beroperasi. Pengkompil Kotlin secara automatik menjana kod yang serasi untuk menjembatani perbezaan sintaks dan menyesuaikan diri dengan ciri -ciri Java melalui reka bentuk bahasa. 1. Kotlin dan Java disusun ke dalam bytecode JVM yang sama, dan kelas boleh dipanggil secara langsung dari satu sama lain dan berkongsi ClassPath; 2. Kotlin menggunakan @jvmoverloads untuk menghasilkan kaedah yang terlalu banyak untuk parameter lalai, dan fungsi peringkat atas disusun menjadi kaedah statik Java (anda boleh menyesuaikan nama kelas melalui @file: JVMName); 3. Kotlin merawat jenis Java sebagai jenis platform (seperti rentetan!), Dan perlu mengendalikan keselamatan kosong secara manual, dan menyokong penukaran SAM untuk menukar lambda secara automatik ke antara muka fungsi Java; 4. Dalam Pembangunan Sebenar ,? Atau !! harus digunakan di Kotlin untuk memastikan keselamatan kosong, dan gunakan fungsi lanjutan untuk meningkatkan kelas Java. Apabila Java memanggil Kotlin, @jvmname, @jvmoverloads dan anotasi lain untuk mengoptimumkan API, dan atribut secara automatik menjana getter/setter untuk akses Java dan decoupling melalui interfaces untuk mengelakkan kebergantungan kitaran. Interoperabilitas yang mendalam ini membolehkan Kotlin dan Java bersesuaian dengan lancar, membolehkan penghijrahan projek secara beransur -ansur.

Interoperability antara Java dan Kotlin: Kenapa ia boleh diintegrasikan dengan lancar?

Kotlin telah membuat interoperabilitas dengan Java salah satu matlamat terasnya sejak penubuhannya. Oleh kerana itu, ia dengan cepat menggantikan Java dalam Perkhidmatan Pembangunan Android dan Backend, menjadi salah satu bahasa pilihan di JVM. Jadi, bagaimanakah Kotlin mengintegrasikan dengan lancar dengan Java? Bagaimanakah kebolehoperasian ini boleh digunakan dengan cekap dalam pembangunan sebenar?

1. Jalankan pada JVM, kod byte dikaitkan

Kod yang disusun oleh Kotlin akan menjana bytecode JVM standard, yang pada dasarnya tidak berbeza dari fail .class Yang disusun oleh Java. Ini bermaksud:

• Kelas Kotlin boleh dipanggil secara langsung oleh Java
• Kelas Java juga boleh dirujuk secara semula jadi oleh Kotlin
• Kedua -duanya dapat disusun bercampur dan berkongsi kelas yang sama

 // Kotlin Class Greeter {
    Fun SaidHello (Nama: String) = Println ("Hello, $ Name!")
}

 // hubungi kelas awam utama di java {
    public static void main (string [] args) {
        Salam salam = salam baru ();
        salam.sayhello ("Alice"); // panggilan biasa}
}

Ciri "kompilasi ini serasi" adalah asas interoperabilitas.

2. Secara automatik mengendalikan perbezaan sintaks biasa

Apabila pengkompil Kotlin menghasilkan bytecode, ia secara automatik akan "menjembatani" beberapa ciri bahasa untuk pemanggil Java, seperti:

• Parameter lalai → kaedah beban
  Kotlin menyokong parameter lalai, tetapi Java tidak. Kotlin menghasilkan pelbagai kaedah yang terlalu banyak untuk Java untuk digunakan melalui anotasi @JvmOverloads .

   @Jvmoverloads
  Salam Salam (Nama: String = "World", semangat: int = 1) {
      println ("Hello $ {name}! $ {"! ". Ulang (semangat)}")
  }

  Java boleh dipanggil seperti ini:

   HELPERKT.GREET (); // Hello World !!
  Helperkt.Greet ("Bob"); // Hello Bob!
  Helperkt.Greet ("Bob", 3); // hello bob !!!

• Fungsi peringkat atas → Kaedah Statik
  Fungsi peringkat atas Kotlin akan disusun menjadi kaedah statik di Java, biasanya diletakkan di kelas XXXKt (disesuaikan).

   // utils.kt
  FormatDate yang menyeronokkan (tarikh: tarikh) = ...

  Panggilan Java:

   String Formatted = UtilSkt.FormatDate (tarikh baru ());

  Anda boleh menukar nama dengan @file:JvmName("Utils") :

   @File: jvmname ("utils")
  Pakej com.example
  
  FormatDate yang menyeronokkan (tarikh: tarikh) = ...

  Panggilan java menjadi: Utils.formatDate(...)

3. "Adaptasi Mesra" Kotlin ke Java

Kotlin telah melakukan banyak reka bentuk di peringkat bahasa untuk "memahami" kod Java, seperti:

• Pemetaan Nulabiliti (Jenis Platform)
  Tidak ada tag yang boleh dibatalkan untuk jenis Java, Kotlin menganggapnya sebagai "jenis platform" (seperti String! ), Dan anda perlu menilai sama ada ia kosong ketika memanggil.

   // java
  rentetan awam getName () {return null; }

   val name = user.getName () // Jenisnya adalah String!
  println (name.length) // boleh membuang nullPointerException

  Cadangan: Buat penghakiman pendek apabila digunakan di Kotlin, atau gunakan @Nullable / @NonNull Annotation di Java, Kotlin akan mengenali mereka.

• Penukaran SAM (kaedah abstrak tunggal)
  Kotlin menyokong antara muka berfungsi yang secara automatik menukar Lambda ke Java.

   // java
  Antara muka awam OnClickListener {
      void onClick (Lihat V);
  }
  
  butang kelas awam {
      public void setonClickListener (onClickListener l) {...}
  }

  Panggilan Kotlin:

   Button.SetonClickListener {view ->
      println ("diklik!")
  }
  // Secara automatik tukar ke contoh OnClickListener

4. Amalan terbaik dalam pembangunan sebenar

Untuk campuran Java dan Kotlin yang lebih lancar, disarankan:

• Semasa memanggil Java di Kotlin :

  • Perhatikan keselamatan null, gunakan ?. Atau !!
  • Tambahkan kaedah yang mudah ke kelas Java menggunakan fungsi lanjutan Kotlin

     fun java.util.list <string> .joinashtml (): String {
        kembali "<ul> $ {Map {" <li> $ It </li> "} .jointoString (" ")} </ul>"
    }

  • Semasa memanggil Kotlin di Java :

    • Susun API menggunakan @JvmName dan @JvmMultifileClass untuk fungsi peringkat teratas
    • Tambah @JvmOverloads ke fungsi dengan parameter lalai
    • Harta ini menjana getter/setter, dan Java boleh mengakses harta name melalui getName()

  • Elakkan kebergantungan bulat
    Kotlin Kelas A memanggil kelas Java B, dan B memanggil atribut atau fungsi Kotlin Kelas A, yang boleh menyebabkan masalah penyusunan. Adalah disyorkan untuk memusnahkan antara muka.

  ---

  Pada dasarnya itu sahaja. Kepercayaan Kotlin dengan Java tidak "hampir tidak tersedia", tetapi integrasi yang mendalam dan penuh dengan butiran. Selagi anda memahami mekanisme penyusunan dan anotasi utama, anda boleh beralih secara bebas dalam projek dan berhijrah secara beransur -ansur untuk mencapai peralihan yang lancar.

  Atas ialah kandungan terperinci Interoperabilitas Java dengan Kotlin: Integrasi Lancar. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!