Pembina kelas. Java JDK 1.5

Maklumat am tentang pembina

Конструкторialah struktur yang serupa dengan kaedah, yang tujuannya adalah untuk mencipta contoh kelas. Ciri-ciri pereka:

• Nama pembina mesti sepadan dengan nama kelas (mengikut konvensyen, huruf pertama ditulis dengan huruf besar, biasanya kata nama);
• Terdapat pembina dalam mana-mana kelas. Walaupun anda tidak menulis satu, pengkompil Java akan mencipta pembina lalai, yang akan kosong dan tidak melakukan apa-apa selain memanggil pembina superclass.
• Pembina adalah serupa dengan kaedah, tetapi ia bukan kaedah, ia tidak dianggap sebagai ahli kelas. Oleh itu, ia tidak boleh diwarisi atau ditindih dalam subkelas;
• Pembina tidak diwarisi;
• Terdapat beberapa pembina dalam kelas. Dalam kes ini, pembina dikatakan terlebih beban;
• Jika kelas tidak mentakrifkan pembina, pengkompil secara automatik menambah pembina tanpa parameter kepada kod;
• Pembina tidak mempunyai jenis pulangan; ia tidak boleh menjadi jenis void; jika jenis dikembalikan void, maka ia bukan lagi pembina tetapi kaedah, walaupun kebetulan dengan nama kelas.
• Operator dibenarkan dalam constructor return, tetapi hanya kosong, tanpa sebarang nilai pulangan;
• Pembina membenarkan penggunaan pengubah suai akses; anda boleh menetapkan salah satu pengubah suai: public, protected, privateatau tanpa pengubah suai.
• Pembina tidak boleh mempunyai pengubah suai abstract, final, native, staticatau synchronized;
• Kata kunci thismerujuk kepada pembina lain dalam kelas yang sama. Jika digunakan, panggilan kepadanya mestilah baris pertama pembina;
• Kata kunci supermemanggil pembina kelas induk. Jika digunakan, rujukan kepadanya mestilah baris pertama pembina;
• Jika pembina tidak membuat panggilan kepada superpembina kelas nenek moyang (dengan atau tanpa argumen), pengkompil secara automatik menambah kod untuk memanggil pembina kelas nenek moyang tanpa hujah;

Pembina lalai

Terdapat pembina dalam mana-mana kelas. Walaupun anda tidak menulis satu, pengkompil Java akan mencipta pembina lalai. Pembina ini kosong dan tidak melakukan apa-apa selain memanggil pembina superclass. Itu. jika anda menulis:

public class Example {}

maka ini bersamaan dengan menulis:

public class Example
{
     Example()
     {
          super;
     }
}

Dalam kes ini, kelas leluhur tidak dinyatakan secara eksplisit, dan secara lalai, semua kelas Java mewarisi kelas, Objectjadi pembina kelas dipanggil Object. Jika kelas mentakrifkan pembina dengan parameter, tetapi tidak ada pembina terlebih beban tanpa parameter, maka memanggil pembina tanpa parameter adalah ralat. Walau bagaimanapun, dalam Java sejak versi 1.5, adalah mungkin untuk menggunakan pembina dengan argumen panjang berubah-ubah. Dan jika terdapat pembina yang mempunyai hujah panjang berubah-ubah, maka memanggil pembina lalai tidak akan menjadi ralat. Ia tidak akan berlaku kerana hujah panjang boleh ubah boleh kosong. Sebagai contoh, contoh berikut tidak akan dikompil, tetapi jika anda menyahkomen pembina dengan hujah panjang boleh ubah, ia akan menyusun dan berjalan dengan jayanya dan menghasilkan baris kod berjalan DefaultDemo dd = new DefaultDemo(); pembina akan dipanggil DefaultDemo(int ... v). Sememangnya, dalam kes ini adalah perlu untuk menggunakan JSDK 1.5. FailDefaultDemo.java

class DefaultDemo
{
 DefaultDemo(String s)
 {
  System.out.print("DefaultDemo(String)");
 }
 /*
 DefaultDemo(int ... v)
 {
  System.out.println("DefaultDemo(int ...)");
 }
 */

 public static void main(String args[])
 {
  DefaultDemo dd = new DefaultDemo();
 }
}

Hasil keluaran program dengan pembina tidak dikomen:

DefaultDemo(int ...)

Walau bagaimanapun, dalam kes biasa di mana kelas tidak mentakrifkan mana-mana pembina sama sekali, memanggil pembina lalai (tanpa parameter) akan diperlukan, kerana penggantian pembina lalai berlaku secara automatik.

Penciptaan objek dan pembina

Apabila mencipta objek, tindakan berikut dilakukan secara berurutan:

• Kelas objek dicari antara kelas yang telah digunakan dalam program. Jika ia tidak ada, maka ia dicari dalam semua katalog dan perpustakaan yang tersedia untuk program. Setelah kelas ditemui dalam direktori atau perpustakaan, medan statik kelas dibuat dan dimulakan. Itu. Untuk setiap kelas, medan statik dimulakan sekali sahaja.
• Memori diperuntukkan untuk objek.
• Medan kelas sedang dimulakan.
• Pembina kelas melaksanakan.
• Pautan ke objek yang dicipta dan dimulakan terbentuk. Rujukan ini ialah nilai ungkapan yang mencipta objek. Objek juga boleh dibuat dengan memanggil kaedah newInstance()kelas java.lang.Class. Dalam kes ini, pembina tanpa senarai parameter digunakan.

Pembina yang berlebihan

Pembina kelas yang sama boleh mempunyai nama yang sama dan tandatangan yang berbeza. Sifat ini dipanggil gabungan atau lebihan beban. Jika kelas mempunyai berbilang pembina, maka beban lebih pembina hadir.

Pembina Berparameter

Tandatangan pembina ialah bilangan dan jenis parameter, serta urutan jenisnya dalam senarai parameter pembina. Jenis pulangan tidak diambil kira. Pembina tidak mengembalikan sebarang parameter. Pernyataan ini menerangkan, dalam erti kata lain, bagaimana Java membezakan antara pembina atau kaedah yang terlebih beban. Java membezakan kaedah terlebih beban bukan dengan jenis pemulangannya, tetapi dengan bilangan, jenis, dan urutan jenis parameter input. Pembina tidak boleh memulangkan type void, jika tidak ia akan bertukar menjadi kaedah biasa, walaupun ia serupa dengan nama kelas. Contoh berikut menunjukkan ini. FailVoidDemo.java

class VoidDemo
{
 /**
  * Это конструктор
  */
 VoidDemo()
 {
  System.out.println("Constructor");
 }

 /**
  * А это уже обычный метод, даже не смотря на сходство с
  * именем класса, поскольку имеется возвращаемый тип void
  */
 void VoidDemo()
 {
  System.out.println("Method");
 }

 public static void main(String s[])
 {
  VoidDemo m = new VoidDemo();
 }
}

Akibatnya, program akan mengeluarkan:

Constructor

Ini sekali lagi membuktikan bahawa pembina adalah kaedah tanpa parameter pulangan. Walau bagaimanapun, pembina boleh diberikan satu daripada tiga pengubah public, , privateatau protected. Dan contoh sekarang akan kelihatan seperti ini: FileVoidDemo2.java

class VoidDemo2
{
 /**
  * Это конструктор
  */
 public VoidDemo2()
 {
  System.out.println("Constructor");
 }

 /**
  * А это уже обычный метод, даже не смотря на сходство с
  * именем класса, поскольку имеется возвращаемый тип void
  */
 private void VoidDemo2()
 {
  System.out.println("Method");
 }

 public static void main(String s[])
 {
  VoidDemo2 m = new VoidDemo2();
 }
}

Ia dibenarkan untuk menulis operator dalam constructor return, tetapi hanya satu kosong, tanpa sebarang nilai pulangan. FailReturnDemo.java

class ReturnDemo
{
 /**
  * В конструкторе допускается использование оператора
  * return без параметров.
  */
 public ReturnDemo()
 {
  System.out.println("Constructor");
  return;
 }

 public static void main(String s[])
 {
  ReturnDemo r = new ReturnDemo();
 }
}

Pembina diparameterkan dengan argumen panjang boleh ubah

Java SDK 1.5 memperkenalkan alat yang telah lama ditunggu-tunggu - hujah pembolehubah panjang untuk pembina dan kaedah. Sebelum ini, bilangan dokumen yang berubah-ubah telah diproses dalam dua cara yang menyusahkan. Yang pertama daripada mereka direka untuk memastikan bilangan maksimum hujah dihadkan kepada bilangan yang kecil dan diketahui terlebih dahulu. Dalam kes ini, adalah mungkin untuk mencipta versi lebihan kaedah, satu untuk setiap versi senarai argumen yang dihantar kepada kaedah. Kaedah kedua direka untuk sesuatu yang tidak diketahui terlebih dahulu dan sejumlah besar hujah. Dalam kes ini, hujah diletakkan dalam tatasusunan, dan tatasusunan ini dihantar kepada kaedah. Argumen panjang pemboleh ubah paling kerap terlibat dalam manipulasi berikutnya dengan permulaan pembolehubah. Adalah mudah untuk menggantikan ketiadaan beberapa hujah pembina atau kaedah yang dijangkakan dengan nilai lalai. Argumen panjang boleh ubah ialah tatasusunan, dan dianggap sebagai tatasusunan. Sebagai contoh, pembina untuk kelas Checkingdengan bilangan argumen yang berubah-ubah akan kelihatan seperti ini:

class Checking
{
 public Checking(int ... n)
 {
 }
}

Gabungan aksara ... memberitahu pengkompil bahawa bilangan pembolehubah argumen akan digunakan dan argumen ini akan disimpan dalam tatasusunan yang nilai rujukannya terkandung dalam pembolehubah n. Pembina boleh dipanggil dengan bilangan argumen yang berbeza, termasuk tiada hujah sama sekali. Argumen diletakkan secara automatik dalam tatasusunan dan melalui n. Jika tiada argumen, panjang tatasusunan ialah 0. Senarai parameter, bersama-sama dengan argumen panjang berubah-ubah, juga boleh termasuk parameter mandatori. Dalam kes ini, parameter yang mengandungi bilangan pembolehubah argumen mestilah yang terakhir dalam senarai parameter. Sebagai contoh:

class Checking
{
 public Checking(String s, int ... n)
 {
 }
}

Had yang sangat jelas melibatkan bilangan parameter panjang berubah-ubah. Mesti ada hanya satu parameter panjang ubah dalam senarai parameter. Memandangkan dua parameter panjang berubah-ubah, adalah mustahil untuk pengkompil menentukan di mana satu parameter berakhir dan yang lain bermula. Sebagai contoh:

class Checking
{
 public Checking(String s, int ... n, double ... d) //ОШИБКА!
 {
 }
}

Fail Checking.java Sebagai contoh, terdapat peralatan yang mampu mengecam plat lesen kereta dan mengingati nombor petak kawasan yang dilawati oleh setiap kereta pada siang hari. Ia adalah perlu untuk memilih daripada jumlah jisim kereta yang direkodkan yang pada siang hari melawat dua petak yang diberikan, katakan 22 dan 15, mengikut peta kawasan. Adalah wajar bahawa kereta boleh melawat banyak dataran pada siang hari, atau mungkin hanya satu. Jelas sekali, bilangan petak yang dilawati dihadkan oleh kelajuan fizikal kereta. Mari kita buat program kecil di mana pembina kelas akan mengambil sebagai hujah nombor kereta sebagai parameter wajib dan bilangan petak yang dilawati bagi kawasan itu, yang bilangannya boleh berubah-ubah. Pembina akan menyemak sama ada kereta telah muncul dalam dua petak; jika ada, maka paparkan nombornya pada skrin.

Menghantar parameter kepada pembina

Terdapat dua jenis parameter dalam bahasa pengaturcaraan:

• jenis asas (primitif);
• rujukan kepada objek.

Istilah panggilan mengikut nilai bermakna pembina menerima nilai yang dihantar kepadanya oleh modul panggilan. Sebaliknya, panggilan melalui rujukan bermakna pembina menerima alamat pembolehubah daripada pemanggil. Java menggunakan panggilan mengikut nilai sahaja. Mengikut nilai parameter dan mengikut nilai pautan parameter. Java tidak menggunakan panggilan melalui rujukan untuk objek (walaupun ramai pengaturcara dan pengarang beberapa buku mendakwa ini). Apabila menghantar objek ke Java, parameter dihantar bukan melalui rujukan , tetapi dengan nilai rujukan objek ! Dalam kedua-dua kes, pembina menerima salinan nilai semua parameter. Pembina tidak boleh lakukan dengan parameter inputnya:

• pembina tidak boleh mengubah nilai parameter input jenis utama (primitif);
• pembina tidak boleh menukar rujukan parameter input;
• pembina tidak boleh menetapkan semula rujukan parameter input kepada objek baharu.

Pembina boleh lakukan dengan parameter inputnya:

• menukar keadaan objek yang diluluskan sebagai parameter input.

Contoh berikut membuktikan bahawa dalam Java, parameter input kepada pembina diluluskan oleh nilai rujukan objek. Contoh ini juga menggambarkan bahawa pembina tidak boleh menukar rujukan parameter input, tetapi sebenarnya menukar rujukan salinan parameter input. FailEmpoyee.java

class Employee
{
 Employee(String x, String y)
 {
  String temp = x;
  x = y;
  y = temp;
 }
 public static void main(String args[])
 {
  String name1 = new String("Alice");
  String name2 = new String("Mary");
  Employee a = new Employee(name1, name2);
  System.out.println("name1="+name1);
  System.out.println("name2="+name2);
 }
}

Output program ialah:

name1=Alice
name2=Mary

Jika Java menggunakan panggilan dengan rujukan untuk menghantar objek sebagai parameter, pembina akan menukar name1dan dalam contoh ini name2. Pembina sebenarnya tidak akan menukar rujukan objek yang disimpan dalam name1dan pembolehubah name2. Ini menunjukkan bahawa parameter pembina dimulakan dengan salinan rujukan ini. Kemudian pembina menukar salinan. Apabila pembina menyelesaikan kerjanya, pembolehubah x dan y dimusnahkan, dan pembolehubah asal name1terus name2merujuk kepada objek sebelumnya.

Menukar parameter yang dihantar kepada pembina.

Pembina tidak boleh mengubah suai parameter yang diluluskan bagi jenis asas. Walau bagaimanapun, pembina boleh mengubah suai keadaan objek yang diluluskan sebagai parameter. Sebagai contoh, pertimbangkan program berikut: FailSalary1.java

class Salary1
{
 Salary1(int x)
 {
  x = x * 3;
  System.out.println("x="+x);
 }
 public static void main(String args[])
 {
  int value = 1000;
  Salary1 s1 = new Salary1(value);
  System.out.println("value="+value);
 }
}

Output program ialah:

x=3000
value=1000

Jelas sekali, kaedah ini tidak akan mengubah parameter jenis utama. Oleh itu, selepas memanggil pembina, nilai pembolehubah valuekekal sama dengan 1000. Pada asasnya tiga perkara berlaku:

1. Pembolehubah xdimulakan dengan salinan nilai parameter value(iaitu, nombor 1000).
2. Nilai pembolehubah xadalah tiga kali ganda - ia kini bersamaan dengan 3000. Walau bagaimanapun, nilai pembolehubah valuekekal sama dengan 1000.
3. Pembina ditamatkan dan pembolehubah xtidak lagi digunakan.

Dalam contoh berikut, gaji pekerja berjaya dinaikkan tiga kali ganda kerana nilai rujukan objek diluluskan sebagai parameter kepada kaedah. FailSalary2.java

class Salary2
{
 int value = 1000;
 Salary2()
 {
 }
 Salary2(Salary2 x)
 {
  x.value = x.value * 3;
 }
 public static void main(String args[])
 {
  Salary2 s1 = new Salary2();
  Salary2 s2 = new Salary2(s1);
  System.out.println("s1.value=" +s1.value);
  System.out.println("s2.value="+s2.value);
 }
}

Output program ialah:

s1.value=3000
s2.value=1000

Nilai rujukan objek digunakan sebagai parameter. Apabila melaksanakan baris Salary2 s2 = new Salary2(s1); pembina Salary2(Salary x)akan memberikan nilai rujukan kepada objek berubah s1, dan pembina akan meningkatkan tiga kali ganda gaji secara berkesan untuk s1.value, memandangkan salinan (Salary x)yang dibuat di dalam pembina menunjuk kepada objek berubah s1.

Pembina diparameterkan oleh primitif.

Jika parameter pembina terlebih beban menggunakan primitif yang boleh disempitkan (contohnya int <- double), maka memanggil kaedah dengan nilai yang disempitkan adalah mungkin, walaupun pada hakikatnya tidak ada kaedah yang terlebih beban dengan parameter sedemikian. Contohnya: FailPrimitive.java

class Primitive
{
 Primitive(double d)
 {
  d = d + 10;
  System.out.println("d="+d);
 }
 public static void main(String args[])
 {
  int i = 20;
  Primitive s1 = new Primitive(i);
 }
}

Output program ialah:

d=30.0

Walaupun kelas Primitivetidak mempunyai pembina yang mempunyai parameter jenis int, pembina dengan parameter input akan berfungsi double. Sebelum memanggil pembina, pembolehubah iakan dikembangkan dari jenis intke jenis double. Pilihan yang bertentangan, apabila pembolehubah iakan jenis double, dan pembina hanya akan mempunyai parameter int, dalam keadaan ini akan membawa kepada ralat kompilasi.

Panggilan dan pengendali pembinanew

Pembina sentiasa dipanggil oleh operator new. Apabila pembina dipanggil dengan operator new, pembina sentiasa menjana rujukan kepada objek baharu. Adalah mustahil untuk memaksa pembina untuk membentuk rujukan kepada objek yang sudah sedia ada dan bukannya rujukan kepada objek baru, kecuali dengan menggantikan objek yang dinyahsiri. Dan dengan pengendali baharu, bukannya rujukan kepada objek baharu, adalah mustahil untuk membentuk rujukan kepada objek yang sudah sedia ada. Contohnya: FailSalary3.java

class Salary3
{
 int value = 1000;
 Salary3()
 {
 }
 Salary3(Salary3 x)
 {
  x.value = x.value * 3;
 }
 public static void main(String args[])
 {
  Salary3 s1 = new Salary3();
  System.out.println("First object creation: "+s1.value);

  Salary3 s2 = new Salary3(s1);
  System.out.println("Second object creation: "+s2.value);
  System.out.println("What's happend with first object?:"+s1.value);

  Salary3 s3 = new Salary3(s1);
  System.out.println("Third object creation: "+s3.value);
  System.out.println("What's happend with first object?:"+s1.value);
 }
}

Output program ialah:

First object creation: 1000
Second object creation: 1000
What's happend with first object?: 3000
Third object creation: 1000
What's happend with first object?: 9000

Pertama, menggunakan baris Salary3 s1 = new Salary3(); objek baru dicipta. Seterusnya, jika menggunakan baris Salary3 s2 = new Salary3(s1); atau rentetan Salary3 s3 = new Salary3(s1); adalah mungkin untuk membuat pautan ke objek yang sedia ada, kemudian s1.value s2.valuemereka s3.valueakan menyimpan nilai yang sama 1000. Sebenarnya dalam talian Salary3 s2 = new Salary3(s1); objek baru untuk pembolehubah akan dibuat s2dan keadaan objek untuk pembolehubah akan berubah s1dengan menghantar nilai rujukannya kepada objek dalam parameter pembina. Ini boleh disahkan oleh hasil keluaran. Dan apabila melaksanakan baris Salary3 s3 = new Salary3(s1); objek BARU untuk pembolehubah akan dicipta s3dan keadaan objek untuk pembolehubah akan berubah semula s1.

Pembina dan blok permulaan, urutan tindakan apabila memanggil pembina

Bahagian Mencipta Objek dan Pembina menyenaraikan tindakan umum yang dilakukan semasa mencipta objek. Antaranya ialah proses memulakan medan kelas dan menyusun pembina kelas, yang seterusnya juga mempunyai susunan dalaman:

1. Semua medan data dimulakan kepada nilai lalainya (0, palsu atau nol).
2. Semua pemula medan dan blok pemulaan dilaksanakan mengikut susunan yang disenaraikan dalam perisytiharan kelas.
3. Jika pembina lain dipanggil pada baris pertama pembina, maka pembina yang dipanggil dilaksanakan.
4. Badan pembina dilaksanakan.

Pembina berkaitan dengan permulaan kerana di Jawa terdapat tiga cara untuk memulakan medan dalam kelas:

• tetapkan nilai dalam pengisytiharan;
• tetapkan nilai dalam blok permulaan;
• tetapkan nilainya dalam pembina.

Sememangnya, anda perlu menyusun kod permulaan supaya mudah difahami. Kelas berikut diberikan sebagai contoh:

class Initialization
{
 int i;
 short z = 10;
 static int x;
 static float y;
 static
 {
  x = 2000;
  y = 3.141;
 }
 Initialization()
 {
  System.out.println("i="+i);
  System.out.println("z="+z);
  z = 20;
  System.out.println("z="+z);
 }
}

Dalam contoh di atas, pembolehubah dimulakan dalam susunan berikut: pembolehubah statik dimulakan dahulu xdengan ynilai lalai. Seterusnya, blok permulaan statik dilaksanakan. Kemudian pembolehubah dimulakan ikepada nilai lalai dan pembolehubah dimulakan z. Seterusnya, pereka mula bekerja. Memanggil pembina kelas tidak seharusnya bergantung pada susunan medan diisytiharkan. Ini boleh membawa kepada ralat.

Pembina dan warisan

Pembina tidak diwarisi. Sebagai contoh:

public class Example
{
 Example()
 {
 }
 public void sayHi()
 {
  system.out.println("Hi");
 }
}

public class SubClass extends Example
{
}

Kelas SubClasssecara automatik mewarisi kaedah sayHi()yang ditakrifkan dalam kelas induk. Pada masa yang sama, pembina Example()kelas induk tidak diwarisi oleh keturunannya SubClass.

Kata kunci thisdalam pembina

Pembina digunakan thisuntuk merujuk kepada pembina lain dalam kelas yang sama, tetapi dengan senarai parameter yang berbeza. Jika pembina menggunakan kata kunci this, maka ia mesti berada pada baris pertama; mengabaikan peraturan ini akan mengakibatkan ralat pengkompil. Contohnya: FailThisDemo.java

public class ThisDemo
{
 String name;
 ThisDemo(String s)
 {
  name = s;
     System.out.println(name);
 }
 ThisDemo()
 {
  this("John");
 }
 public static void main(String args[])
 {
  ThisDemo td1 = new ThisDemo("Mary");
  ThisDemo td2 = new ThisDemo();
 }
}

Output program ialah:

Mary
John

Dalam contoh ini terdapat dua pembina. Yang pertama menerima hujah rentetan. Yang kedua tidak menerima sebarang hujah, ia hanya memanggil pembina pertama menggunakan nama lalai "John". Oleh itu, anda boleh menggunakan pembina untuk memulakan nilai medan secara eksplisit dan secara lalai, yang selalunya diperlukan dalam program.

Kata kunci superdalam pembina

Pembina digunakan superuntuk memanggil pembina superclass. Jika pembina menggunakan super, maka panggilan ini mesti berada pada baris pertama, jika tidak, pengkompil akan membuang ralat. Di bawah ialah contoh: FailSuperClassDemo.java

public class SuperClassDemo
{
 SuperClassDemo()
 {
 }
}

class Child extends SuperClassDemo
{
 Child()
 {
  super();
 }
}

Dalam contoh mudah ini, pembina Child()mengandungi panggilan super()yang mencipta instance class SuperClassDemo, sebagai tambahan kepada class Child. Kerana superia mestilah pernyataan pertama yang dilaksanakan dalam pembina subkelas, pesanan ini sentiasa sama dan tidak bergantung pada sama ada super(). Jika ia tidak digunakan, maka pembina lalai (tiada parameter) setiap superclass, bermula dengan kelas asas, akan dilaksanakan terlebih dahulu. Program berikut menunjukkan apabila pembina dilaksanakan. FailCall.java

//Создать суперкласс A
class A
{
 A()
 {
  System.out.println("Inside A constructor.");
 }
}

//Создать подкласс B, расширяющий класс A
class B extends A
{
 B()
 {
  System.out.println("Inside B constructor.");
 }
}

//Создать класс (C), расширяющий класс В
class C extends B
{
 C()
 {
  System.out.println("Inside C constructor.");
 }
}

class Call
{
 public static void main(String args[])
 {
  C c = new C();
 }
}

Output daripada program ini:

Inside A constructor.
Inside B constructor.
Inside C constructor.

Pembina dipanggil mengikut susunan subordinasi kelas. Ini masuk akal. Memandangkan superclass tidak mempunyai pengetahuan tentang mana-mana subkelas, sebarang permulaan yang perlu dilakukan adalah berasingan. Jika boleh, ia harus mendahului sebarang permulaan yang dilakukan oleh subkelas. Sebab tu kena buat dulu.

Pembina yang boleh disesuaikan

Mekanisme pengenalpastian jenis masa jalan ialah salah satu prinsip teras yang berkuasa bagi bahasa Java yang melaksanakan polimorfisme. Walau bagaimanapun, mekanisme sedemikian tidak melindungi pembangun daripada pemutus jenis yang tidak serasi dalam beberapa kes. Kes yang paling biasa ialah manipulasi sekumpulan objek, pelbagai jenis yang tidak diketahui terlebih dahulu dan ditentukan pada masa berjalan. Memandangkan ralat yang dikaitkan dengan ketidakserasian jenis hanya boleh muncul pada peringkat masa jalan, ini menjadikannya sukar untuk dicari dan dihapuskan. Pengenalan jenis tersuai dalam Java 2 5.0 mengalihkan beberapa ralat ini daripada masa jalan ke masa menyusun dan menyediakan beberapa keselamatan jenis yang hilang. Tidak ada keperluan untuk tuangan jenis eksplisit apabila bergerak dari jenis Objectkepada jenis konkrit. Perlu diingat bahawa alat penyesuaian jenis berfungsi hanya dengan objek dan tidak digunakan pada jenis data primitif yang terletak di luar pepohon warisan kelas. Dengan jenis tersuai, semua lakonan dilakukan secara automatik dan di belakang tabir. Ini membolehkan anda melindungi daripada ketidakpadanan jenis dan menggunakan semula kod dengan lebih kerap. Jenis tersuai boleh digunakan dalam pembina. Pembina boleh diperibadikan walaupun kelas mereka bukan jenis tersuai. Sebagai contoh:

class GenConstructor
{
 private double val;
 <T extends Number> GenConstructor(T arg)
 {
   val = arg.doubleValue();
 }

 void printValue()
 {
  System.out.println("val: "+val);
 }
}

class GenConstructorDemo
{
 public static void main(String args[])
 {
  GenConstructor gc1 = new GenConstructor(100);
  GenConstructor gc2 = new GenConstructor(123.5F);

  gc1.printValue();
  gc2.printValue();
 }
}

Oleh kerana pembina GenConstructormenentukan parameter jenis tersuai yang mesti merupakan kelas terbitan daripada class Number, ia boleh dipanggil dari mana-mana