50 soalan dan jawapan temu duga kerja teratas untuk Java Core. Bahagian 1

Hello semua, tuan-tuan dan puan-puan, jurutera perisian! Mari kita bercakap tentang soalan temuduga. Mengenai perkara yang perlu anda sediakan dan perkara yang perlu anda ketahui. Ini adalah masa yang sesuai untuk menyemak atau mengkaji perkara ini buat kali pertama. Saya berakhir dengan koleksi soalan lazim yang agak luas tentang OOP, sintaks Java, pengecualian Java, koleksi dan multithreading, yang akan saya pecahkan kepada beberapa bahagian untuk kemudahan. Sukar untuk merangkumi semuanya sekaligus, tetapi saya berharap bahan ini akan memberikan asas yang baik bagi mereka yang bersiap sedia untuk mencari pekerjaan pertama mereka sebagai pengaturcara. Untuk pemahaman dan pengekalan yang terbaik, saya menasihatkan untuk menyisir sumber lain juga. Anda boleh mendapatkan pemahaman yang lebih mendalam tentang sesuatu konsep dengan mendekatinya dari beberapa sudut yang berbeza. Penting:Kami hanya akan bercakap tentang Java sebelum versi 8. Semua inovasi yang datang dalam versi 9, 10, 11, 12 dan 13 tidak akan dipertimbangkan di sini. Sebarang idea/ulasan tentang cara menambah baik jawapan adalah dialu-alukan . Selamat membaca. Mari pergi!

Temu bual Java: soalan tentang OOP

1. Apakah ciri-ciri Jawa?

Jawapan:

1. Konsep OOP:

   1. orientasi objek
   2. harta pusaka
   3. enkapsulasi
   4. polimorfisme
   5. abstraksi

2. Cross-platform: Program Java boleh dijalankan pada mana-mana platform tanpa sebarang perubahan. Sudah tentu, ini memerlukan JVM (mesin maya Java) yang dipasang.

3. Prestasi tinggi: Pengkompil Just-In-Time (JIT) membolehkan prestasi tinggi. Pengkompil JIT menukar kod bait kepada kod mesin dan kemudian JVM memulakan pelaksanaan.

4. Multithreading: JVM mencipta utas pelaksanaan yang dipanggil main thread. Seorang pengaturcara boleh mencipta berbilang benang dengan memperoleh daripada kelas Thread atau melaksanakan Runnableantara muka.

2. Apakah harta pusaka?

Warisan bermaksud bahawa satu kelas boleh mewarisi kelas lain (menggunakan kata kunci extends ). Ini bermakna anda boleh menggunakan semula kod daripada kelas yang anda warisi. Kelas sedia ada dikenali sebagai superclassdan kelas yang baru dibuat ialah subclass. Orang kata guna istilah ibu bapa dan child.

public class Animal {
   private int age;
}

public class Dog extends Animal {

}

Animaldi manakah parentdan Dogadalah child.

3. Apakah enkapsulasi?

Soalan ini sering ditanya dalam temu bual untuk jawatan pembangun Java. Enkapsulasi menyembunyikan pelaksanaan dengan menggunakan pengubah suai akses, getter dan setter. Ini dilakukan untuk menghalang akses luaran di mana-mana pemaju fikir ia perlu. Contoh mudah dari kehidupan sebenar ialah kereta. Kami tidak mempunyai akses langsung kepada operasi enjin. Apa yang perlu kita lakukan ialah memasukkan kunci ke dalam penyalaan dan menghidupkan enjin. Proses yang berlaku di bawah hud bukan urusan kami. Lebih-lebih lagi, jika kita mengganggu aktiviti enjin, ia boleh membawa kepada situasi yang tidak dapat diramalkan, mungkin merosakkan kereta dan mengakibatkan kecederaan badan. Perkara yang sama berlaku dalam pengaturcaraan. Ini diterangkan dengan baik di Wikipedia. Terdapat juga artikel tentang enkapsulasi pada CodeGym .

4. Apakah polimorfisme?

Polimorfisme ialah keupayaan program untuk merawat objek dengan antara muka yang sama dengan cara yang sama, tanpa maklumat tentang jenis khusus objek. Seperti kata pepatah, "satu antara muka — banyak pelaksanaan". Dengan polimorfisme, anda boleh menggabungkan dan menggunakan pelbagai jenis objek berdasarkan tingkah laku yang dikongsi. Sebagai contoh, kami mempunyai kelas Haiwan yang mempunyai dua keturunan: Anjing dan Kucing. Kelas Haiwan generik mempunyai tingkah laku yang dikongsi oleh semua, keupayaan untuk mengeluarkan bunyi. Kami menggunakan keupayaan polimorfik apabila kami perlu mengumpulkan semua yang mewarisi kelas Haiwan dan melaksanakan kaedah "membuat bunyi". Begini rupanya:

List<Animal> animals = Arrays.asList(new Cat(), new Dog(), new Cat());
animals.forEach(animal -> animal.makeSound());

Dalam erti kata lain, polimorfisme berguna. Dan ini juga terpakai kepada kaedah polimorfik (lebih beban). Cara menggunakan polimorfisme

Soalan temu bual tentang sintaks Java

5. Apakah pembina dalam Java?

Pembina mempunyai ciri-ciri berikut:

1. Apabila objek baharu dicipta, atur cara menggunakan pembina yang sesuai untuk menciptanya.
2. Pembina adalah seperti kaedah. Ciri tersendirinya terletak pada fakta bahawa tiada nilai pulangan (termasuk void) dan namanya adalah sama dengan nama kelas.
3. Jika tiada pembina dicipta secara eksplisit, pembina kosong dicipta secara automatik.
4. Pembina boleh ditindih.
5. Jika anda mengisytiharkan pembina dengan parameter tetapi juga memerlukan satu tanpa parameter, maka anda mesti menciptanya secara berasingan, kerana ia tidak akan dibuat secara automatik.

6. Dua kelas yang manakah tidak mewarisi Objek?

Jangan tertipu dengan soalan helah — tiada kelas seperti itu. Semua kelas mewarisi kelas Objek sama ada secara langsung atau melalui nenek moyang!

7. Apakah pembolehubah tempatan?

Ini adalah satu lagi soalan wawancara popular untuk pembangun Java. Pembolehubah tempatan ialah pembolehubah yang ditakrifkan di dalam kaedah dan wujud selagi kaedah itu dilaksanakan. Sebaik sahaja pelaksanaan tamat, pembolehubah tempatan tidak lagi wujud. Berikut ialah program yang menggunakan pembolehubah tempatan bernama helloMessage dalam kaedah main():

public static void main(String[] args) {
   String helloMessage;
   helloMessage = "Hello, World!";
   System.out.println(helloMessage);
}

8. Apakah pembolehubah contoh?

Pembolehubah instance ialah pembolehubah yang diisytiharkan di dalam kelas. Ia wujud selagi objek wujud. Sebagai contoh, kami mempunyai kelas Bee, yang mempunyai dua pembolehubah contoh — nectarLoad dan maxNectarLoad:

public class Bee {

   /**
    * Current nectar load
    */
   private double nectarLoad;

   /**
    * Maximum nectar that can the bee can collect.
    */
   private double maxNectarLoad = 20.0;
 
  ...
}

9. Apakah itu pengubahsuai akses?

Pengubah suai akses ialah mekanisme untuk menyesuaikan akses kepada kelas, kaedah dan pembolehubah. Pengubah suai berikut wujud, disenaraikan mengikut urutan peningkatan akses:

1. private— Pengubah suai akses ini digunakan pada kaedah, medan dan pembina. Akses terhad kepada kelas di mana ia diisytiharkan.
2. package-private (default)— Ini ialah tahap akses lalai untuk kelas. Akses terhad kepada pakej khusus di mana kelas, kaedah, pembolehubah atau pembina diisytiharkan.
3. protected— Pengubah suai akses ini menawarkan tahap akses yang sama seperti package-privatepenambahan akses untuk kelas yang mewarisi kelas dengan protectedpengubah suai.
4. public— Tahap akses ini juga digunakan untuk kelas. Tahap akses ini bermakna terdapat akses penuh di seluruh aplikasi.

10. Apakah kaedah mengatasi?

Kami mengatasi kaedah apabila kelas kanak-kanak ingin menukar gelagat kelas induknya. Jika kita juga perlu melakukan apa yang ada dalam kaedah induk, kita boleh menggunakan super.methodName() dalam anak, yang akan melaksanakan kaedah induk. Kita boleh menambah logik tambahan kita selepas itu. Keperluan yang mesti dipatuhi:

• tandatangan kaedah mestilah sama
• nilai pulangan mestilah sama

11. Apakah tandatangan kaedah?

Tandatangan kaedah ialah gabungan nama kaedah dan hujah yang diambil oleh kaedah. Tandatangan kaedah ialah pengecam unik kaedah apabila membebankan kaedah.

12. Apakah kaedah terlebih beban?

Kelebihan kaedah ialah ciri polimorfisme di mana kita menukar tandatangan kaedah untuk mencipta berbilang kaedah yang melakukan tindakan yang sama:

• nama yang sama
• hujah yang berbeza
• terdapat jenis pulangan yang berbeza

Sebagai contoh, kaedah ArrayListkelas add()boleh dibebankan, membolehkan kami menambah dengan cara yang berbeza bergantung pada argumen input:

• add(Object o)— Kaedah ini hanya menambah objek
• add(int index, Object o)— Kaedah ini menambah objek pada indeks tertentu
• add(Collection<Object> c)— Kaedah ini menambah senarai objek
• add(int index, Collection<Object> c)— Kaedah ini menambah senarai objek bermula daripada indeks tertentu.

13. Apakah antara muka?

Java tidak menyokong pelbagai warisan. Untuk mengatasi had ini, antara muka telah ditambah dalam bentuk yang kita tahu dan suka ;) Untuk masa yang lama, antara muka hanya mempunyai kaedah tanpa sebarang pelaksanaan. Dalam konteks jawapan ini, mari kita bercakap tentang mereka. Sebagai contoh:

public interface Animal {
   void makeSound();
   void eat();
   void sleep();
}

Beberapa butiran berikut dari ini:

• Semua kaedah dalam antara muka adalah awam dan abstrak
• Semua pembolehubah adalah muktamad statik awam
• Kelas tidak mewarisi antara muka (iaitu kami tidak menggunakan kata kunci extends). Sebaliknya, kelas melaksanakannya (iaitu kami menggunakan kata kunci implement). Selain itu, anda boleh melaksanakan seberapa banyak antara muka yang anda mahu.
• Kelas yang melaksanakan antara muka mesti menyediakan pelaksanaan semua kaedah yang ada dalam antara muka.

seperti ini:

public class Cat implements Animal {
   public void makeSound() {
       // Method implementation
   }

   public void eat() {
       // Implementation
   }

   public void sleep() {
       // Implementation
   }
}

14. Apakah kaedah lalai dalam antara muka?

Sekarang mari kita bercakap tentang kaedah lalai. Untuk apa mereka? Untuk siapa mereka? Kaedah-kaedah ini telah ditambah untuk melayani "kedua-dua tangan". Apa yang saya cakapkan? Di satu pihak, terdapat keperluan untuk menambah fungsi baharu: lambdas dan API Strim. Sebaliknya, adalah perlu untuk mengekalkan apa yang Java terkenal - keserasian ke belakang. Untuk melakukan ini, antara muka memerlukan beberapa penyelesaian siap sedia baharu. Inilah cara kaedah lalai datang kepada kami. Kaedah lalai ialah kaedah yang dilaksanakan dalam antara muka, ditandakan dengan defaultkata kunci. Sebagai contoh, kaedah yang terkenal stream()dalam Collectionantara muka. Percayalah, antara muka ini tidak semudah yang disangka. Atau juga forEach()kaedah yang sama terkenal dalamIterableantara muka. Ia juga tidak wujud sehingga kaedah lalai ditambahkan. Dengan cara ini, anda juga boleh membaca mengenainya di CodeGym di sini .

15. Bagaimanakah kita boleh mewarisi dua kaedah lalai yang sama?

Jawapan sebelumnya tentang kaedah lalai menimbulkan persoalan lain. Jika anda boleh melaksanakan kaedah dalam antara muka, maka secara teorinya anda boleh melaksanakan dua antara muka dengan kaedah yang sama. Bagaimana kita melakukannya? Berikut ialah dua antara muka yang berbeza dengan kaedah yang sama:

interface A {
   default void foo() {
       System.out.println("Foo A");
   }
}

interface B {
   default void foo() {
       System.out.println("Foo B");
   }
}

Dan kami mempunyai kelas yang melaksanakan kedua-dua antara muka ini. Tetapi bagaimana kita memilih kaedah tertentu dalam antara muka A atau B? Pembinaan khas berikut membenarkan ini: A.super.foo():

public class C implements A, B {
   public void fooA() {
       A.super.foo();
   }

   public void fooB() {
       B.super.foo();
   }
}

Oleh itu, fooA()kaedah akan menggunakan foo()kaedah lalai antara Amuka, manakala fooB()kaedah akan menggunakan foo()kaedah antara Bmuka.

16. Apakah kaedah dan kelas abstrak?

Di Jawa, abstractadalah perkataan terpelihara. Ia digunakan untuk menandakan kelas dan kaedah abstrak. Pertama, kita memerlukan definisi. Kaedah abstrak ialah kaedah yang diisytiharkan menggunakan abstractkata kunci tanpa pelaksanaan dalam kelas abstrak. Iaitu, ini adalah kaedah seperti dalam antara muka, tetapi dengan penambahan kata kunci, sebagai contoh:

public abstract void foo();

Kelas abstrak ialah kelas yang juga ditandakan dengan abstractkata kunci:

public abstract class A {

}

Kelas abstrak mempunyai beberapa ciri:

• anda tidak boleh mencipta objek kelas abstrak
• ia boleh mempunyai kaedah abstrak
• ia juga mungkin tidak mempunyai kaedah abstrak

Kelas abstrak diperlukan untuk abstraksi (maaf untuk tautologi) yang mempunyai set tingkah laku dan keadaan biasa (iaitu kaedah dan pembolehubah). Kehidupan sebenar penuh dengan contoh. Segala-galanya di sekeliling kita. "Haiwan", "Kereta", "Angka geometri", dan sebagainya.

17. Apakah perbezaan antara String, StringBuilder dan StringBuffer?

Stringnilai disimpan dalam kolam rentetan malar. Sebaik sahaja rentetan dibuat, ia muncul dalam kolam ini. Dan anda tidak boleh memadamnya. Sebagai contoh:

String name = "book";

Pembolehubah akan menunjuk ke kolam rentetan malar Menetapkan pembolehubah nama kepada nilai yang berbeza, kami mempunyai:

name = "pen";

Kolam rentetan malar kelihatan seperti ini: Dengan kata lain, kedua-dua nilai kekal di sana. Penampan Rentetan:

• Stringnilai disimpan dalam timbunan. Jika sesuatu nilai diubah, maka nilai baharu akan menggantikan yang lama.
• String Bufferdisegerakkan dan oleh itu selamat untuk rangkaian.
• Oleh kerana keselamatan benang, prestasinya adalah lemah.

Contoh:

StringBuffer name = “book”;

Sebaik sahaja nilai pembolehubah nama berubah, nilai dalam tindanan berubah: StringBuilder betul-betul sama dengan StringBuffer, cuma ia tidak selamat untuk benang. Akibatnya, ia nyata lebih pantas daripada StringBuffer.

18. Apakah perbezaan antara kelas abstrak dan antara muka?

Kelas abstrak:

• Kelas abstrak mempunyai pembina lalai. Ia dipanggil setiap kali keturunan kelas abstrak dicipta.
• Mereka boleh memasukkan kedua-dua kaedah abstrak dan kaedah bukan abstrak. Secara umum, kelas abstrak tidak perlu mempunyai kaedah abstrak.
• Kelas yang mewarisi yang abstrak mesti melaksanakan kaedah abstrak sahaja.
• Kelas abstrak boleh mempunyai pembolehubah contoh (lihat Soalan #5).

Antara muka:

• Antara muka tidak mempunyai pembina dan tidak boleh dimulakan.
• Hanya kaedah abstrak boleh ditambah (kecuali kaedah lalai).
• Kelas yang melaksanakan antara muka mesti melaksanakan semua kaedah (kecuali kaedah lalai).
• Antara muka hanya boleh mempunyai pemalar.

19. Mengapakah mengakses elemen dalam tatasusunan O(1)?

Soalan ini benar-benar ditanya dalam wawancara terakhir saya. Seperti yang saya pelajari kemudian, tujuan soalan ini adalah untuk melihat bagaimana seseorang itu berfikir. Jelas sekali, terdapat sedikit nilai praktikal dalam pengetahuan ini. Mengetahui itu sudah memadai. Pertama, kita perlu menjelaskan bahawa O(1) ialah notasi untuk kerumitan masa algoritma "masa malar". Dengan kata lain, sebutan ini menunjukkan masa pelaksanaan terpantas. Untuk menjawab soalan ini, kita perlu mempertimbangkan apa yang kita tahu tentang tatasusunan. Untuk membuat inttatasusunan, kita mesti menulis yang berikut:

int[] intArray = new int[100];

Beberapa kesimpulan boleh dibuat daripada sintaks ini:

1. Apabila tatasusunan diisytiharkan, jenisnya diketahui. Jika jenisnya diketahui, maka saiz setiap sel dalam tatasusunan diketahui.
2. Saiz keseluruhan tatasusunan diketahui.

Oleh itu, untuk memahami sel yang hendak ditulis, kita hanya perlu mengira kawasan memori yang hendak ditulis. Untuk komputer, ini adalah mudah. Komputer mengetahui di mana memori yang diperuntukkan bermula, bilangan elemen, dan saiz setiap sel. Semua ini bermakna tempat untuk menulis akan sama dengan tempat permulaan tatasusunan + saiz setiap sel didarab dengan indeks.

Jadi bagaimana kita tiba di O(1) apabila mengakses objek dalam ArrayList?

Soalan ini segera mengikuti soalan sebelumnya. Sebenarnya apabila bekerja dengan tatasusunan yang memegang primitif, kita tahu terlebih dahulu (pada masa penciptaan) saiz jenis elemen. Tetapi apa yang kita lakukan jika kita mempunyai hierarki warisan seperti ini dan kita ingin membuat koleksi untuk elemen jenis A dan menambah pelaksanaan yang berbeza (B, C dan D):

List<A> list = new ArrayList();
list.add(new B());
list.add(new C());
list.add(new D());
list.add(new B());

Dalam keadaan ini, bagaimana kita mengira saiz setiap sel? Lagipun, setiap objek akan berbeza, mungkin dengan medan tambahan yang berbeza. Apa nak buat? Di sini soalan itu dikemukakan dengan cara yang bertujuan untuk mengelirukan anda. Kami tahu bahawa koleksi tidak menyimpan objek secara langsung. Ia hanya menyimpan rujukan kepada objek. Dan semua rujukan mempunyai saiz yang sama, dan ia diketahui. Akibatnya, kami mengira alamat di sini dengan cara yang sama seperti dalam soalan sebelumnya.

21. Autoboxing dan unboxing

Latar belakang sejarah: autoboxing dan unboxing ialah beberapa inovasi utama dalam JDK 5. Autoboxing ialah proses penukaran automatik daripada jenis primitif kepada kelas pembalut yang sepadan. Unboxing adalah bertentangan dengan autoboxing. Ia adalah proses menukar kelas pembalut kepada primitif. Tetapi jika nilai pembungkus ialah null, maka a NullPointerExceptionakan dilemparkan semasa unboxing.

Primitif dan pembalutnya yang sepadan

// Autoboxing berlaku:

• apabila memberikan primitif kepada rujukan kepada kelas pembalut:

  SEBELUM Java 5:

  
  // Manual boxing (the way it was BEFORE Java 5).
  public void boxingBeforeJava5() {
     Boolean booleanBox = new Boolean(true);
     Integer intBox = new Integer(3);
     // And so on for other types
  }
  
  After Java 5:
  // Automatic boxing (the way it became in Java 5).
  public void boxingJava5() {
     Boolean booleanBox = true;
     Integer intBox = 3;
     // And so on for other types
  }
  

• apabila primitif diluluskan sebagai hujah kepada kaedah yang mengharapkan pembalut:

  
  public void exampleOfAutoboxing() {
     long age = 3;
     setAge(age);
  }
  
  public void setAge(Long age) {
     this.age = age;
  }
  

// Unboxing berlaku:

• apabila kita menetapkan contoh kelas pembalut kepada pembolehubah primitif:

  
  // BEFORE Java 5:
  int intValue = new Integer(4).intValue();
  double doubleValue = new Double(2.3).doubleValue();
  char c = new Character((char) 3).charValue();
  boolean b = Boolean.TRUE.booleanValue();
  
  // And after JDK 5:
  int intValue = new Integer(4);
  double doubleValue = new Double(2.3);
  char c = new Character((char) 3);
  boolean b = Boolean.TRUE;
  

• Semasa operasi aritmetik. Operasi hanya terpakai untuk jenis primitif, jadi unboxing kepada primitif adalah perlu.

  
  // BEFORE Java 5:
  Integer integerBox1 = new Integer(1);
  Integer integerBox2 = new Integer(2);
  
  // A comparison used to require this:
  integerBox1.intValue() > integerBox2.intValue()
        
  // In Java 5
  integerBox1 > integerBox2
  

• apabila menghantar contoh kelas pembalut kepada kaedah yang mengambil primitif yang sepadan:

  
  public void exampleOfAutoboxing() {
     Long age = new Long(3);
     setAge(age);
  }
  
  public void setAge(long age) {
     this.age = age;
  }
  

22. Apakah kata kunci terakhir dan di mana ia digunakan?

Kata finalkunci boleh digunakan pada pembolehubah, kaedah dan kelas.

1. Nilai pembolehubah akhir tidak boleh diubah selepas ia dimulakan.
2. Kelas akhir adalah steril :) Ia tidak boleh mempunyai anak.
3. Kaedah terakhir tidak boleh ditindih oleh keturunan.

Kami telah membincangkan perkara peringkat tinggi. Sekarang mari menyelam lebih dalam.

Pembolehubah akhir

Java memberi kita dua cara untuk mengisytiharkan pembolehubah dan memberikan nilai kepadanya:

1. Anda boleh mengisytiharkan pembolehubah dan memulakannya kemudian.
2. Anda boleh mengisytiharkan pembolehubah dan menetapkan nilai dengan segera.

Berikut ialah contoh yang menunjukkan penggunaan pembolehubah akhir ini:

public class FinalExample {

   // A static final variable that is immediately initialized:
   final static String FINAL_EXAMPLE_NAME = "I'm likely the final one";

   // A final variable that is not initialized, but will only work if you
   // initialize it in the constructor:
   final long creationTime;

   public FinalExample() {
       this.creationTime = System.currentTimeMillis();
   }

   public static void main(String[] args) {
       FinalExample finalExample = new FinalExample();
       System.out.println(finalExample.creationTime);

       // The final FinalExample.FINAL_EXAMPLE_NAME field cannot be accessed
//    FinalExample.FINAL_EXAMPLE_NAME = "Not you're not!";

       // The final Config.creationTime field cannot be accessed
//    finalExample.creationTime = 1L;
   }
}

Bolehkah pembolehubah akhir dianggap sebagai pemalar?

Oleh kerana kita tidak boleh memberikan nilai baharu kepada pembolehubah akhir, nampaknya ini adalah pembolehubah malar. Tetapi hanya pada pandangan pertama: Jika jenis data pembolehubah ialah immutable, maka, ya, ia adalah pemalar. Tetapi jika jenis data ialah mutable, iaitu, boleh diubah, maka kaedah dan pembolehubah boleh digunakan untuk menukar nilai objek yang dirujuk oleh pembolehubah final. Kerana ini, ia tidak boleh dipanggil pemalar. Contoh berikut menunjukkan bahawa beberapa pembolehubah akhir adalah benar-benar pemalar, manakala yang lain tidak, kerana ia boleh diubah.

public class FinalExample {

   // Immutable final variables
   final static String FINAL_EXAMPLE_NAME = "I'm likely the final one";
   final static Integer FINAL_EXAMPLE_COUNT  = 10;

   // Mutable final variables
   final List<String> addresses = new ArrayList();
   final StringBuilder finalStringBuilder = new StringBuilder("Constant?");
}

Pembolehubah akhir tempatan

Apabila finalpembolehubah dicipta dalam kaedah, ia dipanggil local finalpembolehubah:

public class FinalExample {

   public static void main(String[] args) {
       // You can do this
       final int minAgeForDriveCar = 18;

       // Or you can do this, in a for-each loop:
       for (final String arg : args) {
           System.out.println(arg);
       }
   }

}

Kita boleh menggunakan kata kunci akhir dalam gelung untuk dipertingkatkan, kerana pembolehubah baharu dicipta selepas setiap lelaran gelung. Perlu diingat bahawa ini tidak terpakai pada gelung untuk biasa, jadi kita akan mendapat ralat masa kompilasi.

// The final local j variable cannot be assigned
for (final int i = 0; i < args.length; i ++) {
   System.out.println(args[i]);
}

Kelas akhir

Kelas yang diisytiharkan sebagai finaltidak boleh dilanjutkan. Secara lebih ringkas, tiada kelas lain boleh mewarisinya. Contoh terbaik kelas finaldalam JDK ialah String. Langkah pertama untuk mencipta kelas tidak berubah adalah menandakannya sebagai final, dengan itu menghalangnya daripada dilanjutkan:

public final class FinalExample {
}

// Compilation error!
class WantsToInheritFinalClass extends FinalExample {
}

Kaedah akhir

Apabila kaedah ditanda muktamad, ia dipanggil kaedah akhir (masuk akal, bukan?). Kaedah terakhir tidak boleh ditindih dalam kelas kanak-kanak. Secara kebetulan, kaedah wait() dan notify() kelas Objek adalah muktamad, jadi kami tidak mempunyai keupayaan untuk mengatasinya.

public class FinalExample {
   public final String generateAddress() {
       return "Some address";
   }
}

class ChildOfFinalExample extends FinalExample {

   // Compilation error!
   @Override
   public String generateAddress() {
       return "My OWN Address";
   }
}

Bagaimana dan di mana untuk menggunakan final di Jawa

• Gunakan kata kunci akhir untuk menentukan beberapa pemalar peringkat kelas;
• Cipta pembolehubah akhir untuk objek yang anda tidak mahu ubah. Contohnya, sifat khusus objek yang boleh kita gunakan untuk tujuan pengelogan.
• Jika anda tidak mahu kelas dilanjutkan, maka tandakannya sebagai muktamad.
• Jika anda perlu mencipta kelas tidak berubah, anda perlu menjadikannya muktamad.
• Jika anda mahu pelaksanaan kaedah tidak berubah dalam keturunannya, maka tandakan kaedah sebagai final. Ini sangat penting untuk memastikan pelaksanaan tidak berubah.

23. Apakah jenis boleh ubah dan tidak berubah?

Boleh ubah

Objek boleh ubah ialah objek yang keadaan dan pembolehubahnya boleh diubah selepas penciptaan. Contoh kelas boleh ubah termasuk StringBuilder dan StringBuffer. Contoh:

public class MutableExample {

   private String address;

   public MutableExample(String address) {
       this.address = address;
   }

   public String getAddress() {
       return address;
   }

   // This setter can change the name field
   public void setAddress(String address) {
       this.address = address;
   }

   public static void main(String[] args) {

       MutableExample obj = new MutableExample("First address");
       System.out.println(obj.getAddress());

       // We are updating the name field, so this is a mutable object
       obj.setAddress("Updated address");
       System.out.println(obj.getAddress());
   }
}

tidak boleh ubah

Objek tidak boleh ubah ialah objek yang keadaan dan pembolehubahnya tidak boleh diubah selepas objek itu dicipta. Kunci yang bagus untuk HashMap, bukankah anda fikir? :) Contohnya, String, Integer, Double, dan sebagainya. Contoh:

// We'll make this class final so no one can change it
public final class ImmutableExample {

   private String address;

   ImmutableExample(String address) {
       this.address = address;
   }

   public String getAddress() {
       return address;
   }

   // We remove the setter

   public static void main(String[] args) {

       ImmutableExample obj = new ImmutableExample("Old address");
       System.out.println(obj.getAddress());

       // There is no way to change this field, so it is an immutable object
       // obj.setName("new address");
       // System.out.println(obj.getName());

   }
}

Dalam bahagian seterusnya, kami mempertimbangkan soalan dan jawapan tentang koleksi. Profil saya di GitHub Top 50 soalan dan jawapan temu duga kerja untuk Java Core. Bahagian 2