בוני כיתות. Java JDK 1.5

מידע כללי על בנאים

Конструкторהוא מבנה הדומה למתודה, שמטרתה ליצור מופע של מחלקה. מאפייני המעצב:

• שם הבנאי חייב להתאים לשם המחלקה (על פי מוסכמה, האות הראשונה היא באות רישיות, בדרך כלל שם עצם);
• יש בנאי בכל מחלקה. גם אם לא תכתוב אחד, מהדר ג'אווה יצור בנאי ברירת מחדל, שיהיה ריק ולא יעשה דבר מלבד לקרוא לבנאי ה- superclass.
• בנאי דומה למתודה, אבל הוא לא שיטה, הוא אפילו לא נחשב לחבר במחלקה. לכן, לא ניתן לעבור בירושה או לעקוף אותו בתת-מחלקה;
• הבנאים אינם עוברים בירושה;
• יכולים להיות כמה בנאים במחלקה. במקרה זה, אומרים שהקונסטרוקטורים עמוסים יתר על המידה;
• אם מחלקה לא מגדירה בנאי, המהדר מוסיף באופן אוטומטי בנאי חסר פרמטרים לקוד;
• לבנאי אין סוג החזרה; הוא אפילו לא יכול להיות טיפוס void; אם סוג מוחזר void, אז זה כבר לא בנאי אלא שיטה, למרות צירוף המקרים עם שם המחלקה.
• האופרטור מותר בבנאי return, אך רק ריק, ללא ערך החזרה כלשהו;
• הבנאי מאפשר שימוש במדיפי גישה; אתה יכול להגדיר את אחד מהמשנים: public, protected, privateאו ללא משנה.
• בנאי לא יכול לכלול את המשתנים abstract, final, native, staticאו synchronized;
• מילת המפתח thisמתייחסת לבנאי אחר באותה מחלקה. אם נעשה בו שימוש, הקריאה אליו חייבת להיות השורה הראשונה של הבנאי;
• מילת המפתח superקוראת לבנאי של מחלקת האב. אם נעשה בו שימוש, ההתייחסות אליו חייבת להיות השורה הראשונה של הבנאי;
• אם הבנאי לא מבצע קריאה לבנאי superהמחלקה הקדמונית (עם או בלי ארגומנטים), המהדר מוסיף אוטומטית קוד כדי לקרוא לבנאי המחלקה הקדמונית ללא ארגומנטים;

בנאי ברירת מחדל

יש בנאי בכל מחלקה. גם אם לא תכתוב אחד, מהדר Java יצור בנאי ברירת מחדל. הבנאי הזה ריק ולא עושה דבר מלבד לקרוא לבנאי מחלקת העל. הָהֵן. אם אתה כותב:

public class Example {}

אז זה שווה ערך לכתיבה:

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

במקרה זה, המחלקה הקדמונית אינה מצוינת במפורש, וכברירת מחדל, כל מחלקות Java יורשות את המחלקה, Objectכך שבנאי המחלקה נקרא Object. אם מחלקה מגדירה בנאי עם פרמטרים, אבל אין בנאי עמוס מדי ללא פרמטרים, אז הקריאה לבנאי ללא פרמטרים היא שגיאה. עם זאת, ב-Java מאז גרסה 1.5, ניתן להשתמש בבונים עם ארגומנטים של אורך משתנה. ואם יש בנאי שיש לו ארגומנט אורך משתנה, אז הקריאה לבנאי ברירת המחדל לא תהיה שגיאה. זה לא יקרה כי הארגומנט אורך משתנה יכול להיות ריק. לדוגמה, הדוגמה הבאה לא תעשה קומפילציה, אבל אם תבטל את ההערה לבנאי עם ארגומנט אורך משתנה, הוא יקמפל וירוץ בהצלחה ויגרום לשורת קוד שפועלת DefaultDemo dd = new DefaultDemo(); הקונסטרוקטור ייקרא DefaultDemo(int ... v). באופן טבעי, במקרה זה יש צורך להשתמש ב-JSDK 1.5. קוֹבֶץDefaultDemo.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();
 }
}

התוצאה של פלט התוכנית עם הבנאי ללא הערות:

DefaultDemo(int ...)

עם זאת, במקרה הנפוץ בו המחלקה אינה מגדירה בנאי כלל, יהיה צורך לקרוא לבנאי ברירת המחדל (ללא פרמטרים), שכן החלפת בנאי ברירת מחדל מתרחשת באופן אוטומטי.

יצירת אובייקטים ובנאים

בעת יצירת אובייקט, הפעולות הבאות מבוצעות ברצף:

• מחלקת האובייקט מתבצעת חיפוש בין המחלקות שכבר נמצאות בשימוש בתוכנית. אם זה לא קיים, אזי הוא נחפש בכל הקטלוגים והספריות הזמינות לתוכנית. ברגע שמחלקה מתגלה בספריה או בספריה, השדות הסטטיים של המחלקה נוצרים ומאותחלים. הָהֵן. עבור כל מחלקה, שדות סטטיים מאותחלים פעם אחת בלבד.
• זיכרון מוקצה לאובייקט.
• שדות המחלקה עוברים אתחול.
• בנאי המחלקה מבצע.
• נוצר קישור לאובייקט שנוצר ואותחל. הפניה זו היא הערך של הביטוי שיוצר את האובייקט. ניתן ליצור אובייקט גם על ידי קריאה למתודה newInstance()מחלקה java.lang.Class. במקרה זה, נעשה שימוש בבנאי ללא רשימת פרמטרים.

עומס יתר על בנאים

לבנאים מאותה כיתה יכולים להיות אותו שם וחתימה שונה. מאפיין זה נקרא שילוב או עומס יתר. אם למחלקה יש מספר בנאים, אזי יש עומס יתר של בנאים.

בנאים עם פרמטרים

החתימה של בנאי היא מספר וסוגי הפרמטרים, כמו גם רצף הסוגים שלהם ברשימת הפרמטרים של הבנאי. סוג ההחזרה אינו נלקח בחשבון. הבנאי לא מחזיר פרמטרים. הצהרה זו מסבירה, במובן מסוים, כיצד Java מבדילה בין בנאים או שיטות עמוסים מדי. Java מבדילה בין שיטות עמוסות יתר לא לפי סוג ההחזר שלהן, אלא לפי המספר, הסוגים ורצף סוגי פרמטרי הקלט. בנאי אפילו לא יכול להחזיר סוג void, אחרת הוא יהפוך למתודה רגילה, למרות שהיא דומה לשם המחלקה. הדוגמה הבאה מדגימה זאת. קוֹבֶץVoidDemo.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();
 }
}

כתוצאה מכך, התוכנית תפיק פלט:

Constructor

זה שוב מוכיח שבנאי הוא שיטה ללא פרמטרים להחזרה. עם זאת, ניתן לתת לבנאי אחד משלושה משנים public, , privateאו protected. והדוגמה תיראה כעת כך: קובץVoidDemo2.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();
 }
}

מותר לכתוב אופרטור בקונסטרוקטור return, אבל רק ריק, ללא ערך החזרה. קוֹבֶץReturnDemo.java

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

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

קונסטרוקטורים פרמטרים עם ארגומנטים באורך משתנה

Java SDK 1.5 הציגה כלי המיוחל - ארגומנטים באורך משתנה עבור בנאים ושיטות. בעבר, מספר משתנה של מסמכים טופלו בשתי דרכים לא נוחות. הראשון שבהם נועד להבטיח שמספר הטיעונים המרבי מוגבל למספר קטן וידוע מראש. במקרה זה, ניתן היה ליצור גרסאות עמוסות יתר של השיטה, אחת לכל גרסה של רשימת הארגומנטים שהועברה לשיטה. השיטה השנייה מיועדת למשהו לא ידוע מראש ולמספר רב של טיעונים. במקרה זה, הארגומנטים הוצבו במערך, ומערך זה הועבר לשיטה. ארגומנטים באורך משתנה מעורבים לרוב במניפולציות עוקבות עם אתחולי משתנה. זה נוח להחליף את היעדר חלק מהארגומנטים הצפויים של הבנאי או השיטה בערכי ברירת מחדל. ארגומנט האורך המשתנה הוא מערך, והוא מטופל כמערך. לדוגמה, הבנאי של מחלקה Checkingעם מספר משתנה של ארגומנטים ייראה כך:

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

שילוב התווים ... אומר למהדר שייעשה שימוש במספר משתנה של ארגומנטים, וכי הארגומנטים הללו יאוחסנו במערך שערך ההתייחסות שלו כלול במשתנה n. ניתן לקרוא לבנאי עם מספר שונה של ארגומנטים, כולל ללא ארגומנטים כלל. הארגומנטים ממוקמים אוטומטית במערך ומועברים דרך n. אם אין ארגומנטים, אורך המערך הוא 0. רשימת הפרמטרים, יחד עם ארגומנטים של אורך משתנה, יכולה לכלול גם פרמטרים חובה. במקרה זה, פרמטר המכיל מספר משתנה של ארגומנטים חייב להיות האחרון ברשימת הפרמטרים. לדוגמה:

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

מגבלה ברורה מאוד נוגעת למספר פרמטרי האורך המשתנים. חייב להיות רק פרמטר אחד באורך משתנה ברשימת הפרמטרים. בהינתן שני פרמטרים באורך משתנה, זה בלתי אפשרי עבור המהדר לקבוע היכן פרמטר אחד מסתיים והשני מתחיל. לדוגמה:

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

קובץ Checking.java לדוגמה, יש ציוד המסוגל לזהות לוחיות רישוי לרכב ולזכור את מספרי הריבועים של האזור בו ביקרה כל אחת מהמכוניות במהלך היום. יש צורך לבחור מתוך המסה הכוללת של המכוניות המתועדות את אלו שבמהלך היום ביקרו בשני ריבועים נתונים, נניח 22 ו-15, לפי מפת השטח. זה די טבעי שמכונית יכולה לבקר בכיכרות רבות במהלך היום, או אולי רק באחת. ברור שמספר הריבועים המבקרים מוגבל על ידי המהירות הפיזית של המכונית. בואו ניצור תוכנית קטנה שבה בנאי המחלקה ייקח כארגומנטים את מספר המכונית כפרמטר חובה ואת מספרי הריבועים שבהם ביקרו באזור, שמספרם יכול להיות משתנה. הקונסטרוקטור יבדוק אם מכונית הופיעה בשני ריבועים; אם כן, הצג את מספרה על המסך.

העברת פרמטרים לבנאי

ישנם בעיקר שני סוגים של פרמטרים בשפות תכנות:

• סוגים בסיסיים (פרימיטיביים);
• הפניות לחפצים.

המונח call by value פירושו שהקונסטרוקטור מקבל את הערך שמועבר אליו על ידי מודול הקריאה. לעומת זאת, call by reference פירושו שהקונסטרוקטור מקבל את הכתובת של המשתנה מהמתקשר. Java משתמשת בהתקשרות לפי ערך בלבד. לפי ערך פרמטר ולפי ערך קישור פרמטר. Java אינה משתמשת ב-call by reference עבור אובייקטים (אם כי מתכנתים רבים ומחברי חלק מהספרים טוענים זאת). בעת העברת אובייקטים ל-Java, הפרמטרים מועברים לא על ידי הפניה , אלא על ידי הערך של הפניה לאובייקט ! בכל מקרה, הבנאי מקבל עותקים של הערכים של כל הפרמטרים. הבנאי לא יכול לעשות עם פרמטרי הקלט שלו:

• הבנאי לא יכול לשנות את הערכים של פרמטרי הקלט מהסוגים העיקריים (הפרימיטיביים);
• הבנאי לא יכול לשנות הפניות של פרמטרי קלט;
• הבנאי לא יכול להקצות מחדש הפניות של פרמטרי קלט לאובייקטים חדשים.

הבנאי יכול לעשות עם פרמטרי הקלט שלו:

• לשנות את מצב האובייקט המועבר כפרמטר קלט.

הדוגמה הבאה מוכיחה שב-Java, פרמטרי קלט לבנאי מועברים לפי ערך התייחסות לאובייקט. דוגמה זו משקפת גם שהקונסטרוקטור אינו יכול לשנות הפניות של פרמטרי קלט, אלא משנה למעשה הפניות של עותקים של פרמטרי קלט. קוֹבֶץEmpoyee.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);
 }
}

הפלט של התוכנית הוא:

name1=Alice
name2=Mary

אם Java השתמשה ב-call על ידי הפניה כדי להעביר אובייקטים כפרמטרים, הבנאי יחליף name1ובדוגמה זו name2. הבנאי לא יחליף למעשה את הפניות האובייקט המאוחסנות במשתנים name1ו name2. זה מצביע על כך שהפרמטרים של הבנאי מאותחלים עם עותקים של הפניות אלה. ואז הבנאי מחליף את העותקים. כאשר הבנאי מסיים את עבודתו, משתני x ו-y נהרסים, והמשתנים המקוריים name1ממשיכים name2להתייחס לאובייקטים הקודמים.

שינוי הפרמטרים שהועברו לבנאי.

הבנאי לא יכול לשנות את הפרמטרים שהועברו של סוגים בסיסיים. עם זאת, הבנאי יכול לשנות את מצב האובייקט המועבר כפרמטר. לדוגמה, שקול את התוכנית הבאה: קובץSalary1.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);
 }
}

הפלט של התוכנית הוא:

x=3000
value=1000

ברור, שיטה זו לא תשנה את פרמטר הסוג הראשי. לכן, לאחר קריאה לבנאי, הערך של המשתנה valueנשאר שווה ל 1000. בעצם קורים שלושה דברים:

1. המשתנה xמאותחל עם עותק של ערך הפרמטר value(כלומר, מספר 1000).
2. ערכו של המשתנה xמשולש - הוא שווה כעת ל 3000. עם זאת, הערך של המשתנה valueנשאר שווה ל 1000.
3. הבנאי מסתיים והמשתנה xאינו בשימוש עוד.

בדוגמה הבאה, שכרו של העובד משולש בהצלחה מכיוון שהערך של הפניה לאובייקט מועבר כפרמטר לשיטה. קוֹבֶץSalary2.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);
 }
}

הפלט של התוכנית הוא:

s1.value=3000
s2.value=1000

הערך של הפניה לאובייקט משמש כפרמטר. בעת ביצוע השורה Salary2 s2 = new Salary2(s1); הבנאי Salary2(Salary x)יקבל את הערך של הפניה לאובייקט המשתנה s1, והקונסטרוקטור ישלש למעשה את השכר עבור s1.value, שכן אפילו העותק (Salary x)שנוצר בתוך הבנאי מצביע על האובייקט המשתנה s1.

בנאים מותאמים על ידי פרימיטיבים.

אם הפרמטרים של בנאי עמוס יתר על המידה משתמשים בפרימיטיבי שניתן לצמצם (לדוגמה int <- double), אז אפשר לקרוא למתודה עם ערך מצומצם, למרות העובדה שאין שיטה עמוסה בפרמטר כזה. לדוגמה: קובץPrimitive.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);
 }
}

הפלט של התוכנית הוא:

d=30.0

למרות העובדה שלמחלקה Primitiveאין בנאי שיש לו פרמטר סוג int, בנאי עם פרמטר קלט יעבוד double. לפני הקריאה לבנאי, המשתנה iיורחב מסוג intלסוג double. האפשרות ההפוכה, כאשר המשתנה iיהיה מסוג double, ולקונסטרוקטור יהיה רק ​​פרמטר int, במצב זה תוביל לשגיאת קומפילציה.

קריאת קונסטרוקטור ומפעילהnew

הקונסטרוקטור נקרא תמיד על ידי האופרטור new. כאשר בנאי נקרא עם האופרטור new, הבנאי תמיד יוצר הפניה לאובייקט חדש. אי אפשר להכריח את הקונסטרוקטור ליצור הפניה לאובייקט שכבר קיים במקום הפניה לאובייקט חדש, אלא על ידי החלפת האובייקט המועבר לסידריאליזציה. ועם האופרטור החדש, במקום קישור לאובייקט חדש, אי אפשר ליצור קישור לאובייקט שכבר קיים. לדוגמא: קובץSalary3.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);
 }
}

הפלט של התוכנית הוא:

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

ראשית, באמצעות הקו Salary3 s1 = new Salary3(); נוצר אובייקט חדש. לאחר מכן, אם משתמשים בקו Salary3 s2 = new Salary3(s1); או מחרוזות Salary3 s3 = new Salary3(s1); ניתן יהיה ליצור קישור לאובייקט שכבר קיים, ואז s1.value s2.valueהם s3.valueיאחסנו את אותו ערך 1000. בעצם בתור Salary3 s2 = new Salary3(s1); יווצר אובייקט חדש עבור המשתנה s2ומצב האובייקט עבור המשתנה ישתנה s1על ידי העברת ערך ההתייחסות שלו לאובייקט בפרמטר הבנאי. ניתן לאמת זאת על ידי תוצאות הפלט. וכאשר מבצעים את השורה Salary3 s3 = new Salary3(s1); יווצר אובייקט חדש עבור המשתנה s3ומצב האובייקט עבור המשתנה ישתנה שוב s1.

קונסטרוקטורים ובלוקי אתחול, רצף פעולות בעת קריאה לבנאי

הסעיף יצירת אובייקט ובנאים מפרט את הפעולות הכלליות שמתבצעות בעת יצירת אובייקט. ביניהם ניתן למצוא את התהליכים של אתחול שדות מחלקה ועיבוד בונה המחלקה, שבתורם יש גם סדר פנימי:

1. כל שדות הנתונים מאותחלים לערכי ברירת המחדל שלהם (0, false או null).
2. כל אתחולי השדות ובלוקי האתחול מבוצעים בסדר שהם מופיעים בהצהרת המחלקה.
3. אם נקרא בנאי אחר בשורה הראשונה של בנאי, אזי הבנאי שנקרא מבוצע.
4. גוף הקונסטרוקטור מבוצע.

הבנאי קשור לאתחול מכיוון שב-Java יש שלוש דרכים לאתחל שדה במחלקה:

• להקצות ערך בהצהרה;
• הקצה ערכים בבלוק האתחול;
• קבע את הערך שלו בקונסטרוקטור.

באופן טבעי, עליך לארגן את קוד האתחול כך שיהיה קל להבנה. המחלקה הבאה ניתנת כדוגמה:

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

בדוגמה שלמעלה, המשתנים מאותחלים בסדר הבא: משתנים סטטיים מאותחלים תחילה xעם yערכי ברירת מחדל. לאחר מכן, בלוק האתחול הסטטי מבוצע. לאחר מכן המשתנה מאותחל iלערך ברירת המחדל והמשתנה מאותחל z. לאחר מכן, המעצב מתחיל לעבודה. קריאה לבוני מחלקות לא צריכה להיות תלויה בסדר שבו מוצהרים שדות. זה עלול להוביל לטעויות.

בנאים וירושה

הבנאים אינם עוברים בירושה. לדוגמה:

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

public class SubClass extends Example
{
}

המחלקה SubClassיורשת אוטומטית את השיטה sayHi()שהוגדרה במחלקת האב. יחד עם זאת, הבנאי Example()של מחלקת האב אינו עובר בירושה מהצאצא שלה SubClass.

מילת מפתח thisבבנאים

הבנאים משמשים thisלהתייחסות לבנאי אחר באותה מחלקה, אך עם רשימה שונה של פרמטרים. אם הבנאי משתמש במילת המפתח this, היא חייבת להיות בשורה הראשונה; התעלמות מכלל זה תגרום לשגיאת מהדר. לדוגמה: קובץThisDemo.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();
 }
}

הפלט של התוכנית הוא:

Mary
John

בדוגמה זו יש שני בנאים. הראשון מקבל ארגומנט מחרוזת. השני אינו מקבל ארגומנטים, הוא פשוט קורא לבנאי הראשון באמצעות שם ברירת המחדל "ג'ון". לפיכך, אתה יכול להשתמש בבנאים כדי לאתחל ערכי שדות באופן מפורש וכברירת מחדל, דבר הכרחי לעתים קרובות בתוכניות.

מילת מפתח superבבנאים

משתמשים בקונסטרוקטורים superכדי לקרוא לבנאי מחלקה על. אם הבנאי משתמש super, אז הקריאה הזו חייבת להיות בשורה הראשונה, אחרת המהדר יזרוק שגיאה. להלן דוגמה: קובץSuperClassDemo.java

public class SuperClassDemo
{
 SuperClassDemo()
 {
 }
}

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

בדוגמה פשוטה זו, הבנאי Child()מכיל קריאה super()שיוצרת מופע של המחלקה SuperClassDemo, בנוסף למחלקה Child. מכיוון superשהיא חייבת להיות ההצהרה הראשונה שמבוצעת בבנאי תת-מחלקה, סדר זה תמיד זהה ואינו תלוי אם super(). אם לא נעשה בו שימוש, אזי הבנאי ברירת המחדל (ללא פרמטרים) של כל מחלקת על, החל ממחלקת הבסיס, יתבצע תחילה. התוכנית הבאה מדגימה מתי מבוצעים בנאים. קוֹבֶץCall.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();
 }
}

פלט מתוכנית זו:

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

הבנאים נקראים לפי סדר כפיפות הכיתה. זה קצת הגיוני. מכיוון שלמחלקת העל אין ידע על תת-מחלקה כלשהי, כל אתחול שהיא צריכה לבצע היא נפרדת. במידת האפשר, זה צריך להקדים כל אתחול המבוצע על ידי תת המחלקה. לכן צריך לעשות את זה קודם.

בנאים הניתנים להתאמה אישית

מנגנון זיהוי הסוג בזמן ריצה הוא אחד מעקרונות הליבה החזקים של שפת Java המיישמת פולימורפיזם. עם זאת, מנגנון כזה אינו מגן על המפתח מפני יציקה מסוג לא תואם במקרים מסוימים. המקרה הנפוץ ביותר הוא מניפולציה של קבוצת אובייקטים, שסוגיהם השונים אינם ידועים מראש ונקבעים בזמן הריצה. מכיוון ששגיאות הקשורות לאי התאמה של סוגים יכולות להופיע רק בשלב זמן הריצה, הדבר מקשה על איתור וביטולן. הצגת סוגים מותאמים אישית ב-Java 2 5.0 מעבירה חלק מהשגיאות הללו מזמן ריצה לזמן קומפילציה ומספקת חלק מהסוגים החסרים. אין צורך ביציקת סוג מפורשת במעבר מטיפוס Objectלסוג בטון. יש לזכור שכלי התאמה אישית של סוג עובדים רק עם אובייקטים ואינם חלים על סוגי נתונים פרימיטיביים שנמצאים מחוץ לעץ הירושה של המחלקה. עם סוגים מותאמים אישית, כל הליהוקים מבוצעים באופן אוטומטי ומאחורי הקלעים. זה מאפשר לך להגן מפני אי התאמה של סוגים ולהשתמש בקוד לעתים קרובות יותר. ניתן להשתמש בסוגים מותאמים אישית בבנאים. בונים יכולים להיות מותאמים אישית גם אם הכיתה שלהם אינה מסוג מותאם אישית. לדוגמה:

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

מכיוון שהקונסטרוקטור GenConstructorמציין פרמטר מסוג מותאם אישית שחייב להיות מחלקה נגזרת ממחלקה Number, ניתן לקרוא לו מכל