50 Soalan dan Jawapan Temuduga Teras Java Teratas. 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 sebab terbaik untuk mengulangi atau mengkaji perkara ini dari awal. Saya mempunyai koleksi soalan lazim yang agak luas tentang OOP, Java Syntax, pengecualian dalam Java, koleksi dan multithreading, yang untuk kemudahan saya akan bahagikan kepada beberapa bahagian. Penting:kami hanya akan bercakap tentang versi Java sehingga 8. Semua inovasi dari 9, 10, 11, 12, 13 tidak akan diambil kira di sini. Sebarang idea/ulasan tentang cara menambah baik jawapan adalah dialu-alukan . Selamat membaca, jom!

Temu bual Java: soalan OOP

1. Apakah ciri yang ada pada Java?

Jawapan:

1. Konsep OOP:

   1. orientasi objek;
   2. warisan;
   3. enkapsulasi;
   4. polimorfisme;
   5. abstraksi.

2. Cross-platform: Program Java boleh dijalankan pada mana-mana platform tanpa sebarang pengubahsuaian. Satu-satunya perkara yang anda perlukan ialah JVM yang dipasang (mesin maya java).

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

4. Multithreading: Urutan pelaksanaan yang dikenali sebagai Thread. JVM mencipta benang yang dipanggil main thread. Seorang pengaturcara boleh mencipta berbilang utas dengan mewarisi daripada kelas Thread atau dengan melaksanakan antara muka Runnable.

2. Apakah harta pusaka?

Warisan bermaksud bahawa satu kelas boleh mewarisi (“ memanjangkan ”) kelas lain. Dengan cara ini anda boleh menggunakan semula kod daripada kelas yang anda warisi. Kelas sedia ada dikenali sebagai superclass, dan kelas yang dicipta dikenali sebagai subclass. Mereka juga berkata parentdan child.

public class Animal {
   private int age;
}

public class Dog extends Animal {

}

Animaldi mana parent, dan Dog- child.

3. Apakah enkapsulasi?

Soalan ini sering timbul semasa temu bual pembangun Java. Enkapsulasi menyembunyikan pelaksanaan menggunakan pengubah suai akses, menggunakan getter dan setter. Ini dilakukan untuk menutup akses untuk kegunaan luaran di tempat yang difikirkan perlu oleh pembangun. Contoh yang boleh diakses dari kehidupan ialah sebuah kereta. Kami tidak mempunyai akses terus kepada operasi enjin. Bagi kami, tugasnya ialah meletakkan kunci di dalam penyalaan dan menghidupkan enjin. Dan proses yang akan berlaku di bawah hud bukan urusan kami. Selain itu, campur tangan kita dalam aktiviti ini boleh membawa kepada situasi yang tidak dapat diramalkan, yang mana kita boleh memecahkan kereta dan membahayakan diri sendiri. Perkara yang sama berlaku dalam pengaturcaraan. Diterangkan dengan baik di Wikipedia . Terdapat juga artikel mengenai enkapsulasi pada JavaRush .

4. Apakah polimorfisme?

Polimorfisme ialah keupayaan atur cara untuk menggunakan objek secara identik dengan antara muka yang sama tanpa maklumat tentang jenis objek tertentu. Seperti yang mereka katakan, satu antara muka - banyak pelaksanaan. Dengan polimorfisme, anda boleh menggabungkan dan menggunakan pelbagai jenis objek berdasarkan tingkah laku biasa mereka. Sebagai contoh, kami mempunyai kelas Haiwan, yang mempunyai dua keturunan - Anjing dan Kucing. Kelas Haiwan generik mempunyai kelakuan yang sama untuk semua - buat bunyi. Dalam kes apabila kita perlu mengumpulkan semua keturunan kelas Haiwan dan melaksanakan kaedah "membuat bunyi", kita menggunakan kemungkinan polimorfisme. Inilah yang akan kelihatan seperti:

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

Jadi polimorfisme membantu kita. Selain itu, ini juga terpakai kepada kaedah polimorfik (lebih muatan). Amalan menggunakan polimorfisme

Soalan Temu Bual - Sintaks Java

5. Apakah pembina dalam Java?

Ciri-ciri berikut adalah sah:

1. Apabila objek baharu dicipta, atur cara menggunakan pembina yang sesuai untuk berbuat demikian.
2. Pembina adalah seperti kaedah. Keistimewaannya ialah tiada unsur kembali (termasuk void), dan namanya sama dengan nama kelas.
3. Jika tiada pembina ditulis secara eksplisit, pembina kosong akan dibuat secara automatik.
4. Pembina boleh ditindih.
5. Jika pembina dengan parameter telah dibuat, tetapi anda juga memerlukan satu tanpa parameter, anda perlu menulisnya secara berasingan, kerana ia tidak dibuat secara automatik.

6. Dua kelas yang manakah tidak diwarisi daripada Objek?

Jangan tertipu oleh provokasi, tidak ada kelas sedemikian: semua kelas secara langsung atau melalui nenek moyang diwarisi daripada kelas Objek!

7. Apakah Pembolehubah Tempatan?

Satu lagi soalan popular semasa temu bual pembangun Java. Pembolehubah tempatan ialah pembolehubah yang ditakrifkan di dalam kaedah dan wujud sehingga saat kaedah itu dilaksanakan. Sebaik sahaja pelaksanaan tamat, pembolehubah tempatan akan tidak lagi wujud. Berikut ialah program yang menggunakan pembolehubah tempatan helloMessage dalam kaedah main():

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

8. Apakah Pembolehubah Instance?

Instance Variable ialah pembolehubah yang ditakrifkan di dalam kelas, dan ia wujud sehingga saat objek itu wujud. Contohnya ialah kelas Bee, yang mempunyai dua pembolehubah nectarCapacity dan maxNectarCapacity:

public class Bee {

   /**
    * Current nectar capacity
    */
   private double nectarCapacity;

   /**
    * Maximal nectar that can take bee.
    */
   private double maxNectarCapacity = 20.0;

  ...
}

9. Apakah itu pengubahsuai akses?

Pengubah suai akses ialah alat yang membolehkan anda menyesuaikan akses kepada kelas, kaedah dan pembolehubah. Terdapat pengubah suai berikut, disusun mengikut urutan peningkatan akses:

1. private- digunakan untuk kaedah, medan dan pembina. Tahap akses hanyalah kelas di mana ia diisytiharkan.
2. package-private(default)- boleh digunakan untuk kelas. Akses hanya dalam pakej tertentu di mana kelas, kaedah, pembolehubah, pembina diisytiharkan.
3. protected— akses yang sama seperti package-private+ untuk kelas yang mewarisi daripada kelas dengan pengubah suai protected.
4. public- juga digunakan untuk kelas. Akses penuh sepanjang keseluruhan aplikasi.

10. Apakah kaedah mengatasi?

Penggantian kaedah berlaku apabila kanak-kanak ingin mengubah tingkah laku kelas induk. Jika anda mahu apa yang ada dalam kaedah induk dilaksanakan, anda boleh menggunakan pembinaan seperti super.methodName() dalam anak, yang akan melakukan kerja kaedah induk, dan kemudian tambah logik. Keperluan yang perlu dipenuhi:

• tandatangan kaedah mestilah sama;
• nilai pulangan hendaklah sama.

11. Apakah tandatangan kaedah?

Tandatangan kaedah ialah satu set nama kaedah dan hujah yang diterima oleh kaedah. Tandatangan kaedah ialah pengecam unik untuk kaedah apabila membebankan kaedah.

12. Apakah kaedah terlebih beban?

Kelebihan kaedah ialah sifat polimorfisme di mana dengan menukar tandatangan kaedah, anda boleh mencipta kaedah yang berbeza untuk tindakan yang sama:

• nama kaedah yang sama;
• hujah yang berbeza;
• mungkin terdapat jenis pulangan yang berbeza.

Sebagai contoh, yang sama add()boleh ArrayListdibebankan seperti berikut dan akan melakukan penambahan dengan cara yang berbeza, bergantung pada hujah yang masuk:

• add(Object o)- hanya menambah objek;
• add(int index, Object o)— menambah objek pada indeks tertentu;
• add(Collection<Object> c)— menambah senarai objek;
• add(int index, Collection<Object> c)— menambah senarai objek, bermula dari indeks tertentu.

13. Apakah Antara Muka?

Warisan berbilang tidak dilaksanakan di Java, jadi untuk mengatasi masalah ini, antara muka seperti yang kita tahu telah ditambah;) Untuk masa yang lama, antara muka hanya mempunyai kaedah tanpa melaksanakannya. Sebagai sebahagian daripada jawapan ini, kita akan bercakap tentang mereka. Sebagai contoh:

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

Beberapa nuansa mengikuti dari ini:

• semua kaedah dalam antara muka adalah awam dan abstrak;
• semua pembolehubah adalah muktamad statik awam;
• kelas tidak mewarisinya (melanjutkan), tetapi melaksanakannya (melaksanakan). Selain itu, anda boleh melaksanakan seberapa banyak antara muka yang anda suka.
• kelas yang melaksanakan antara muka mesti menyediakan pelaksanaan semua kaedah yang mempunyai 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, untuk siapa? Kaedah ini telah ditambahkan untuk menjadikan segala-galanya "milik anda dan kami." Apa yang saya cakapkan? Ya, di satu pihak, adalah perlu untuk menambah fungsi baharu: lambdas, Stream API, sebaliknya, perlu meninggalkan apa yang Java terkenal - keserasian ke belakang. Untuk melakukan ini, adalah perlu untuk memperkenalkan penyelesaian siap pakai ke dalam antara muka. Inilah cara kaedah lalai datang kepada kami. Iaitu, kaedah lalai ialah kaedah yang dilaksanakan dalam antara muka yang mempunyai kata kunci default. Sebagai contoh, kaedah yang terkenal stream()dalam Collection. Semak ia, antara muka ini tidak semudah yang kelihatan;). Atau juga kaedah yang sama terkenal forEach()dari Iterable. Ia juga tidak wujud sehingga kaedah lalai ditambahkan. Dengan cara ini, anda juga boleh membaca tentang ini di JavaRush .

15. Bagaimana pula untuk mewarisi dua kaedah lalai yang sama?

Berdasarkan jawapan sebelum ini tentang kaedah lalai, anda boleh bertanya soalan lain. Jika anda boleh melaksanakan kaedah dalam antara muka, maka secara teorinya anda boleh melaksanakan dua antara muka dengan kaedah yang sama, dan bagaimana untuk melakukan ini? Terdapat 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 terdapat kelas yang melaksanakan kedua-dua antara muka ini. Untuk mengelakkan ketidakpastian dan untuk menyusun kod, kita perlu mengatasi kaedah foo()dalam kelas C, dan kita hanya boleh memanggil kaedah foo()mana-mana antara muka di dalamnya - Aatau B. Tetapi bagaimana untuk memilih kaedah antara muka tertentu Аatau В? Terdapat struktur seperti ini untuk ini A.super.foo():

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

atau:

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

Oleh itu, kaedah foo()kelas Cakan menggunakan sama ada kaedah lalai foo()daripada antara muka Aatau kaedah foo()daripada antara muka B.

16. Apakah kaedah dan kelas abstrak?

Java mempunyai perkataan terpelihara abstractyang digunakan untuk menunjukkan kelas dan kaedah abstrak. Pertama, beberapa definisi. Kaedah abstrak ialah kaedah yang dibuat tanpa pelaksanaan dengan kata kunci abstractdalam kelas abstrak. Iaitu, ini adalah kaedah seperti dalam antara muka, hanya dengan penambahan kata kunci, sebagai contoh:

public abstract void foo();

Kelas abstrak ialah kelas yang juga mempunyai abstractperkataan:

public abstract class A {

}

Kelas abstrak mempunyai beberapa ciri:

• objek tidak boleh dicipta berdasarkannya;
• ia boleh mempunyai kaedah abstrak;
• ia mungkin tidak mempunyai kaedah abstrak.

Kelas abstrak diperlukan untuk menyamaratakan beberapa jenis abstraksi (maaf untuk tautologi), yang tidak wujud dalam kehidupan sebenar, tetapi ia mengandungi banyak tingkah laku dan keadaan biasa (iaitu kaedah dan pembolehubah). Terdapat lebih daripada cukup contoh dari kehidupan. Semuanya ada di sekeliling kita. Ia boleh menjadi "haiwan", "kereta", "angka geometri" dan sebagainya.

17. Apakah perbezaan antara String, String Builder dan String Buffer?

Nilai Stringdisimpan dalam kolam rentetan malar. Sebaik sahaja baris dibuat, baris itu akan muncul dalam kolam ini. Dan tidak mungkin untuk memadamkannya. Sebagai contoh:

String name = "book";

...pembolehubah akan merujuk kepada kolam rentetan Kolam rentetan malar Jika anda menetapkan nama pembolehubah kepada nilai yang berbeza, anda akan mendapat perkara berikut:

name = "pen";

Kolam rentetan malar Jadi kedua-dua nilai ini akan kekal di sana. Penampan Rentetan:

• nilai Stringdisimpan pada timbunan. Jika nilai diubah, maka nilai baru akan digantikan dengan yang lama;
• String Bufferdisegerakkan dan oleh itu selamat benang;
• Oleh kerana keselamatan benang, kelajuan operasi meninggalkan banyak yang diinginkan.

Contoh:

StringBuffer name = "book";

Sebaik sahaja nilai nama berubah, nilai pada tindanan berubah: StringBuilder Sama persis seperti StringBuffer, cuma ia tidak selamat untuk benang. Oleh itu, kelajuannya jelas lebih tinggi daripada dalam StringBuffer.

18. Apakah perbezaan antara kelas abstrak dan antara muka?

Kelas abstrak:

• kelas abstrak mempunyai pembina lalai; ia dipanggil setiap kali kanak-kanak kelas abstrak ini dicipta;
• mengandungi kaedah abstrak dan bukan abstrak. Pada umumnya, ia mungkin tidak mengandungi kaedah abstrak, tetapi masih merupakan kelas abstrak;
• kelas yang mewarisi daripada yang abstrak mesti melaksanakan kaedah abstrak sahaja;
• kelas abstrak boleh mengandungi Pembolehubah Instance (lihat soalan #5).

Antara muka:

• tidak mempunyai pembina dan tidak boleh dimulakan;
• hanya kaedah abstrak perlu ditambah (tidak mengira kaedah lalai);
• kelas yang melaksanakan antara muka mesti melaksanakan semua kaedah (tidak mengira kaedah lalai);
• antara muka hanya boleh mengandungi pemalar.

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

Soalan ini betul-betul dari temu bual lepas. Seperti yang saya pelajari kemudian, soalan ini ditanya untuk melihat bagaimana seseorang berfikir. Jelas bahawa terdapat sedikit makna praktikal dalam pengetahuan ini: mengetahui fakta ini sudah memadai. Pertama, kita perlu menjelaskan bahawa O(1) ialah sebutan untuk kerumitan masa sesuatu algoritma apabila operasi berlaku dalam masa yang tetap. Iaitu, penunjukan ini adalah pelaksanaan terpantas. Untuk menjawab soalan ini, kita perlu memahami apa yang kita tahu tentang tatasusunan? Untuk mencipta array int, kita mesti menulis yang berikut:

int[] intArray = new int[100];

Beberapa kesimpulan boleh dibuat daripada rakaman ini:

1. Apabila mencipta tatasusunan, jenisnya diketahui.Jika jenisnya diketahui, maka jelas saiz setiap sel tatasusunan itu.
2. Adalah diketahui saiz tatasusunan itu.

Ia berikutan daripada ini: untuk memahami sel yang hendak ditulis, anda hanya perlu mengira kawasan memori yang hendak ditulis. Untuk kereta ia tidak boleh menjadi lebih mudah. Mesin mempunyai permulaan memori yang diperuntukkan, beberapa elemen, dan saiz sel tunggal. Daripada ini jelas bahawa ruang rakaman akan sama dengan lokasi permulaan tatasusunan + saiz sel yang didarab dengan saiznya.

Bagaimanakah anda mendapat O(1) dalam mengakses objek dalam ArrayList?

Soalan ini segera mengikuti soalan sebelumnya. Memang benar bahawa apabila kita bekerja dengan tatasusunan dan terdapat primitif di sana, kita tahu terlebih dahulu saiz jenis ini apabila ia dicipta. Tetapi bagaimana jika terdapat skema seperti dalam gambar: dan kami ingin membuat koleksi dengan elemen jenis A, dan menambah pelaksanaan yang berbeza - B, C, D:

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

Dalam situasi ini, bagaimana anda boleh memahami saiz setiap sel, kerana setiap objek akan berbeza dan mungkin mempunyai medan tambahan yang berbeza (atau berbeza sama sekali). Apa nak buat? Di sini persoalan dikemukakan sedemikian rupa sehingga mengelirukan dan mengelirukan. Kami tahu bahawa sebenarnya, koleksi tidak menyimpan objek, tetapi hanya memaut ke objek ini. Dan semua pautan mempunyai saiz yang sama, dan ia diketahui. Jadi mengira ruang di sini berfungsi dengan cara yang sama seperti dalam soalan sebelumnya.

21. Autoboxing dan unboxing

Latar belakang sejarah: autoboxing dan autounboxing ialah salah satu inovasi utama JDK 5. Autoboxing ialah proses penukaran automatik daripada jenis primitif kepada kelas pembalut yang sesuai. Auto-nyah kotak - melakukan yang bertentangan dengan auto-tinju - menukar kelas pembalut kepada primitif. Tetapi jika terdapat nilai pembalut null, maka pengecualian akan dilemparkan semasa membongkar NullPointerException.

Padanan primitif - pembalut

Autopacking berlaku:

• apabila memberikan rujukan primitif kepada kelas pembalut:

  SEBELUM Java 5:

  //manual packaging or how it was BEFORE Java 5.
  public void boxingBeforeJava5() {
     Boolean booleanBox = new Boolean(true);
     Integer intBox = new Integer(3);
     // and so on to other types
  }
  
  после Java 5:
  //automatic packaging or how it became in Java 5.
  public void boxingJava5() {
     Boolean booleanBox = true;
     Integer intBox = 3;
     // and so on to other types
  }

• apabila menghantar primitif sebagai hujah kepada kaedah yang mengharapkan pembungkus:

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

Pembongkaran automatik berlaku:

• apabila kita menetapkan pembolehubah primitif kepada kelas pembalut:

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

• Dalam kes dengan operasi aritmetik. Mereka hanya digunakan untuk jenis primitif; untuk ini anda perlu melakukan pembongkaran kepada primitif.

  // Before Java 5
  Integer integerBox1 = new Integer(1);
  Integer integerBox2 = new Integer(2);
  
  // for comparison it was necessary to do this:
  integerBox1.intValue() > integerBox2.intValue()
  
  //в Java 5
  integerBox1 > integerBox2

• apabila diserahkan kepada pembungkus dalam kaedah yang menerima 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 untuk menggunakannya?

Kata kunci finalboleh digunakan untuk pembolehubah, kaedah dan kelas.

1. Pembolehubah akhir tidak boleh ditugaskan semula ke objek lain.
2. kelas akhir adalah steril)) ia tidak boleh mempunyai waris.
3. kaedah akhir tidak boleh ditindih pada nenek moyang.

Kami telah membincangkan bahagian atas, sekarang mari kita membincangkannya dengan lebih terperinci.

pembolehubah akhir

;Java memberi kita dua cara untuk mencipta pembolehubah dan memberikan beberapa nilai kepadanya:

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

Contoh menggunakan pembolehubah akhir untuk kes ini:

public class FinalExample {

   //final static variable, which is immediately initialized:
   final static String FINAL_EXAMPLE_NAME = "I'm likely final one";

   //final is a variable that is not initialized, but will only work if
   //initialize this 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);

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

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

Bolehkah pembolehubah Akhir dianggap sebagai pemalar?

Memandangkan kita tidak akan dapat memberikan nilai baharu kepada pembolehubah akhir, nampaknya ini adalah pembolehubah malar. Tetapi ini hanya pada pandangan pertama. Jika jenis data yang dirujuk oleh pembolehubah ialah immutable, maka ya, ia adalah pemalar. Tetapi jika jenis data mutableboleh berubah, menggunakan kaedah dan pembolehubah adalah mungkin untuk menukar nilai objek yang finaldirujuk oleh pembolehubah, dan dalam kes ini ia tidak boleh dipanggil pemalar. Jadi, contoh menunjukkan bahawa beberapa pembolehubah akhir adalah benar-benar pemalar, tetapi ada yang tidak, dan ia boleh diubah.

public class FinalExample {

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

   // mutable filter variables
   final List<String> addresses = new ArrayList();
   final StringBuilder finalStringBuilder = new StringBuilder("constant?");
}

Pembolehubah akhir tempatan

Apabila finalpembolehubah dicipta di dalam kaedah, ia dipanggil local finalpembolehubah:

public class FinalExample {

   public static void main(String[] args) {
       // This is how you can
       final int minAgeForDriveCar = 18;

       // or you can do it this way, in the foreach loop:
       for (final String arg : args) {
           System.out.println(arg);
       }
   }

}

Kita boleh menggunakan kata kunci finaldalam gelung lanjutan forkerana selepas melengkapkan lelaran gelung, forpembolehubah baharu dicipta setiap kali. Tetapi ini tidak terpakai kepada gelung untuk biasa, jadi kod di bawah akan membuang ralat masa kompilasi.

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

Kelas akhir

Anda tidak boleh melanjutkan kelas yang diisytiharkan sebagai final. Ringkasnya, tiada kelas boleh mewarisi daripada kelas ini. Contoh hebat finalkelas dalam JDK ialah String. Langkah pertama untuk mencipta kelas tidak berubah adalah menandakannya sebagai final, supaya ia tidak dapat dilanjutkan:

public final class FinalExample {
}

// Compilation error here
class WantsToInheritFinalClass extends FinalExample {
}

Kaedah akhir

Apabila kaedah ditanda muktamad, ia dipanggil kaedah akhir (logik, bukan?). Kaedah Akhir tidak boleh ditindih dalam kelas keturunan. By the way, kaedah dalam kelas Object - wait() dan notify() - adalah muktamad, jadi kami tidak mempunyai peluang untuk mengatasinya.

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

class ChildOfFinalExample extends FinalExample {

   // compile error here
   @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;
• buat pembolehubah akhir untuk objek apabila anda tidak mahu ia diubah suai. Contohnya, sifat khusus objek yang boleh kita gunakan untuk tujuan pembalakan;
• jika anda tidak mahu kelas dilanjutkan, tandakannya sebagai muktamad;
• jika anda perlu mencipta kelas tidak berubah<, anda perlu menjadikannya muktamad;
• jika anda mahu pelaksanaan kaedah tidak berubah dalam keturunannya, tetapkan kaedah itu sebagai final. Ini amat penting bagi memastikan pelaksanaan tidak berubah.

23. Apakah yang boleh berubah tidak berubah?

Boleh ubah

Boleh ubah ialah objek yang keadaan dan pembolehubahnya boleh diubah selepas penciptaan. Sebagai contoh, kelas seperti StringBuilder, 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());

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

tidak berubah

Tidak boleh ubah ialah objek yang keadaan dan pembolehubahnya tidak boleh diubah selepas objek dicipta. Mengapa bukan kunci yang bagus untuk HashMap, bukan?) Contohnya, String, Integer, Double dan sebagainya. Contoh:

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

   //remove the setter

   public static void main(String[] args) {

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

       // Therefore, do not change this field in any way, so this is an immutable object
       // obj.setName("new address");
       // System.out.println(obj.getName());

   }
}

24. Bagaimana untuk menulis kelas tidak berubah?

Selepas anda mengetahui apakah objek yang boleh berubah dan tidak berubah, soalan seterusnya adalah semula jadi - bagaimana untuk menulisnya? Untuk menulis kelas tidak berubah tidak berubah, anda perlu mengikuti langkah mudah:

• membuat kelas akhir.
• jadikan semua medan peribadi dan buat hanya getter untuknya. Setter, tentu saja, tidak diperlukan.
• Jadikan semua medan boleh ubah muktamad supaya nilai hanya boleh ditetapkan sekali.
• mulakan semua medan melalui pembina, melakukan salinan dalam (iaitu, menyalin objek itu sendiri, pembolehubahnya, pembolehubah pembolehubah, dan sebagainya)
• mengklon objek boleh ubah boleh ubah dalam getter untuk mengembalikan hanya salinan nilai, bukan rujukan kepada objek sebenar.

Contoh:

/**
* An example of creating an immutable object.
*/
public final class FinalClassExample {

   private final int age;

   private final String name;

   private final HashMap<String, String> addresses;

   public int getAge() {
       return age;
   }


   public String getName() {
       return name;
   }

   /**
    * Clone the object before returning it.
    */
   public HashMap<String, String> getAddresses() {
       return (HashMap<String, String>) addresses.clone();
   }

   /**
    * In the constructor, deep copy the mutable objects.
    */
   public FinalClassExample(int age, String name, HashMap<String, String> addresses) {
       System.out.println("Performing a deep copy in the constructor");
       this.age = age;
       this.name = name;
       HashMap<String, String> temporaryMap = new HashMap<>();
       String key;
       Iterator<String> iterator = addresses.keySet().iterator();
       while (iterator.hasNext()) {
           key = iterator.next();
           temporaryMap.put(key, addresses.get(key));
       }
       this.addresses = temporaryMap;
   }
}

• Profil GitHub saya
• 50 Soalan dan Jawapan Temuduga Teras Java Teratas. Bahagian 2