ڪلاس تعمير ڪندڙ. جاوا JDK 1.5

تعمير ڪندڙن بابت عام معلومات

Конструкторهڪ ڍانچي هڪ طريقي سان ملندڙ جلندڙ آهي، جنهن جو مقصد هڪ طبقي جو مثال ٺاهڻ آهي. ڊزائنر جون خاصيتون:

• تعمير ڪندڙ جو نالو لازمي طور تي ڪلاس جي نالي سان ملندو (ڪنوينشن جي لحاظ کان، پهريون اکر وڏو ٿئي ٿو، عام طور تي هڪ اسم)؛
• ڪنهن به طبقي ۾ هڪ تعمير ڪندڙ آهي. جيتوڻيڪ توهان هڪ نه لکندا آهيو، جاوا ڪمپلر هڪ ڊفالٽ ڪنسٽرڪٽر ٺاهيندو، جيڪو خالي هوندو ۽ سپر ڪلاس تعمير ڪندڙ کي سڏڻ کان سواء ٻيو ڪجهه نه ڪندو.
• هڪ تعمير ڪندڙ هڪ طريقي سان ملندڙ جلندڙ آهي، پر اهو هڪ طريقو ناهي، اهو پڻ طبقي جو ميمبر نه سمجهيو ويندو آهي. تنهن ڪري، اهو هڪ ذيلي ڪلاس ۾ ورثي يا ختم نٿو ڪري سگهجي.
• تعمير ڪندڙ وراثت نه آهن؛
• ھڪڙي طبقي ۾ ڪيترائي ٺاھيندڙ ٿي سگھن ٿا. انهي صورت ۾، تعمير ڪندڙن کي اوورلوڊ چيو ويندو آهي؛
• جيڪڏهن هڪ ڪلاس هڪ تعمير ڪندڙ جي وضاحت نٿو ڪري، مرتب ڪندڙ خودڪار طريقي سان ڪوڊ ۾ هڪ پيٽرولر بغير تعمير ڪندڙ شامل ڪري ٿو؛
• هڪ تعمير ڪندڙ کي واپسي جو قسم نه هوندو آهي؛ اهو هڪ قسم به نه ٿو ٿي سگهي void؛ جيڪڏهن هڪ قسم واپس ڪيو وڃي void، ته پوء اهو هاڻي هڪ تعمير ڪندڙ نه آهي پر هڪ طريقو آهي، طبقاتي نالي سان اتفاق جي باوجود.
• آپريٽر کي تعمير ڪندڙ ۾ اجازت ڏني وئي آهي return، پر صرف خالي، بغير ڪنهن واپسي جي قيمت جي؛
• تعمير ڪندڙ کي رسائي موڊيفائرز جي استعمال جي اجازت ڏئي ٿي؛ توھان مقرر ڪري سگھو ٿا ھڪڙي موڊيفائرز: public, protected, privateيا بغير تبديليءَ جي.
• هڪ تعمير ڪندڙ کي تبديل ڪرڻ وارا نه هوندا abstract, final, native, staticor synchronized;
• لفظ thisساڳئي طبقي ۾ هڪ ٻئي تعمير ڪندڙ ڏانهن اشارو ڪري ٿو. جيڪڏهن استعمال ڪيو وڃي، ان کي ڪال ڪرڻ لازمي آهي تعمير ڪندڙ جي پهرين لائن؛
• لفظ superسڏين ٿا ڪنسٽرڪٽر جي والدين طبقي کي. جيڪڏهن استعمال ڪيو وڃي، ان جو حوالو لازمي طور تي تعمير ڪندڙ جي پهرين لائن هجڻ گهرجي؛
• جيڪڏهن ڪنسٽرڪٽر superائنسٽر ڪلاس جي ڪنسٽرڪٽر کي ڪال نه ٿو ڪري (دلائل سان يا ان کان سواءِ)، ڪمپائلر پاڻمرادو ڪوڊ شامل ڪري ٿو ته ڪنسٽرڪشن ڪلاس جي ڪنسٽرڪٽر کي ڪال ڪرڻ لاءِ دليلن کان سواءِ؛

ڊفالٽ ٺاھيندڙ

ڪنهن به طبقي ۾ هڪ تعمير ڪندڙ آهي. جيتوڻيڪ توهان هڪ نه لکندا آهيو، جاوا ڪمپلر هڪ ڊفالٽ تعمير ڪندڙ ٺاهيندو. هي تعمير ڪندڙ خالي آهي ۽ سپر ڪلاس تعمير ڪندڙ کي سڏڻ کان سواء ٻيو ڪجهه نٿو ڪري. اهي. جيڪڏهن توهان لکندا آهيو:

public class Example {}

پوء اهو لکڻ جي برابر آهي:

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

ان صورت ۾، ائڊريس ڪلاس واضح طور تي بيان نه ڪيو ويو آهي، ۽ ڊفالٽ طور، سڀ جاوا طبقن کي ورثي ۾ ملن ٿا، Objectتنهنڪري ڪلاس تعمير ڪندڙ سڏيو ويندو آهي Object. جيڪڏهن ڪو ڪلاس وضاحت ڪري ٿو هڪ پيراميٽرائزڊ ڪنسٽرڪٽر، پر ڪو به اوورلوڊ ٿيل پيراميٽر بيس ڪنسٽرڪٽر نه آهي، ته پوءِ پيراميٽر بيس ڪنسٽرڪٽر کي سڏڻ هڪ غلطي آهي. جڏهن ته، جاوا ۾ نسخو 1.5 کان وٺي، اهو ممڪن آهي ته تعمير ڪندڙن کي استعمال ڪرڻ سان متغير ڊگهو دليلن سان. ۽ جيڪڏھن ڪو ٺاھيندڙ آھي جنھن ۾ متغير ڊگھي دليل آھي، پوءِ ڊفالٽ ٺاھيندڙ کي سڏڻ ۾ ڪا غلطي نه ٿيندي. اهو نه ٿيندو ڇو ته متغير ڊگهو دليل خالي ٿي سگهي ٿو. مثال طور، هيٺ ڏنل مثال مرتب نه ٿيندو، پر جيڪڏهن توهان ڪنسٽرڪٽر کي variable length argument سان uncomment ڪريو ٿا، ته اهو مرتب ڪندو ۽ ڪاميابيءَ سان هلندو ۽ نتيجي ۾ ڪوڊ جي هڪ قطار ڊوڙندو 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. انهي حالت ۾، هڪ تعمير ڪندڙ بغير پيٽرولر جي فهرست استعمال ڪيو ويندو آهي.

اوورلوڊنگ ٺاهيندڙن

ساڳي طبقي جي تعمير ڪندڙن کي ساڳيو نالو ۽ مختلف دستخط ٿي سگھي ٿو. ھن ملڪيت کي ميلاپ يا اوور لوڊنگ سڏيو ويندو آھي. جيڪڏھن ھڪڙي طبقي ۾ گھڻا ٺاھيندڙ آھن، پوء ٺاھيندڙ اوورلوڊنگ موجود آھي.

Parameterized Constructors

ھڪڙي ٺاھيندڙ جي دستخط آھي پيرا ميٽرن جو تعداد ۽ قسم، ۽ گڏوگڏ انھن جي قسمن جو سلسلو ٺاھيندڙ پيرا ميٽرز جي لسٽ ۾. واپسي جو قسم حساب ۾ نه ورتو ويو آهي. تعمير ڪندڙ ڪنهن به پيراگراف کي واپس نٿو ڪري. هي بيان بيان ڪري ٿو، هڪ لحاظ سان، ڪيئن جاوا اوورلوڊ ٿيل تعمير ڪندڙن يا طريقن جي وچ ۾ فرق ڪري ٿو. جاوا اوورلوڊ ٿيل طريقن کي فرق ڪري ٿو نه انهن جي واپسي جي قسم سان، پر ان پٽ پيٽرولر جي قسمن جي تعداد، قسمن ۽ ترتيب سان. هڪ تعمير ڪندڙ هڪ قسم کي به واپس نه ٿو ڪري سگهي 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 متعارف ڪرايو هڪ ڊگهي انتظار وارو اوزار - تعمير ڪندڙن ۽ طريقن لاءِ متغير-لمبائي دليل. اڳي، دستاويزن جو هڪ متغير تعداد ٻن غير مناسب طريقن سان پروسيس ڪيو ويو. انھن مان پھريون ٺاھيو ويو آھي ان کي يقيني بڻائڻ لاءِ ته دليلن جو وڌ ۾ وڌ تعداد ھڪڙي ننڍڙي تعداد تائين محدود آھي ۽ اڳواٽ ئي معلوم ٿئي ٿو. انهي صورت ۾، اهو ممڪن هو ته طريقي جي اوورلوڊ ٿيل نسخن کي ٺاهيو، هر هڪ نسخي جي لاء دليلن جي لسٽ جو طريقو ڏانهن گذري ويو. ٻيو طريقو اڳ ۾ اڻڄاتل شيء ۽ دليلن جي هڪ وڏي تعداد لاء ٺهيل آهي. هن معاملي ۾، دليلن کي هڪ صف ۾ رکيا ويا هئا، ۽ هن صف کي طريقو ڏانهن منتقل ڪيو ويو. متغير لمبائي جا دليل اڪثر ڪري شامل هوندا آهن ايندڙ ورهاڱي ۾ متغير شروعاتن سان. اهو آسان آهي ته ڪجهه متوقع تعمير ڪندڙ يا طريقي جي دليلن جي غير موجودگي کي ڊفالٽ قدرن سان. variable length argument is a array, and be treated as a array. مثال طور، هڪ طبقي لاءِ تعمير ڪندڙ 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، علائقي جي نقشي جي مطابق. اهو ڪافي قدرتي آهي ته هڪ ڪار ڏينهن دوران ڪيترن ئي چوڪن جو دورو ڪري سگهي ٿو، يا شايد صرف هڪ. ظاهر آهي، دورو ڪيل چوڪن جو تعداد ڪار جي جسماني رفتار سان محدود آهي. اچو ته ھڪڙو ننڍڙو پروگرام ٺاھيو جتي ڪلاس ٺاھيندڙ دليلن جي طور تي ڪار نمبر کي لازمي پيرا ميٽر جي طور تي ۽ علائقي جي دورو ڪيل چوڪن جا انگ، جن جو تعداد متغير ٿي سگھي ٿو. تعمير ڪندڙ چيڪ ڪندو ته ڇا ڪار ٻن چوڪن ۾ ظاهر ٿي آهي؛ جيڪڏهن اهو آهي، پوء ان جو نمبر اسڪرين تي ڏيکاري ٿو.

تعمير ڪندڙ کي پيراگراف پاس ڪرڻ

پروگرامنگ ٻولين ۾ بنيادي طور تي ٻه قسم جا پيرا ميٽر آهن:

• بنيادي قسم (ابتدائي)؛
• شين جي حوالي سان.

اصطلاح ڪال ذريعي قدر جو مطلب آهي ته تعمير ڪندڙ وصول ڪري ٿو قدر ان کي ڪالنگ ماڊل طرفان منظور ڪيو ويو آهي. ان جي ابتڙ، حوالو ذريعي ڪال جو مطلب آهي ته تعمير ڪندڙ ڪالر کان متغير جو پتو وصول ڪري ٿو. جاوا صرف قدر ذريعي ڪال استعمال ڪري ٿو. پيرا ميٽر جي قيمت جي لحاظ سان ۽ پيراميٽر لنڪ جي قيمت جي حساب سان. جاوا استعمال نه ڪندو آهي ڪال ذريعي حوالن جي شين لاءِ (جيتوڻيڪ ڪيترائي پروگرامر ۽ ڪجهه ڪتابن جا ليکڪ اها دعويٰ ڪن ٿا). جڏهن جاوا ڏانهن شيون گذري رهيون آهن، پيرا ميٽرز پاس ڪيا ويندا آهن حوالي سان نه ، پر اعتراض جي حوالن جي قيمت سان ! ٻنهي صورتن ۾، تعمير ڪندڙ سڀني پيراگراف جي قيمتن جي نقل حاصل ڪري ٿو. هڪ تعمير ڪندڙ پنهنجي ان پٽ پيٽرولن سان نٿو ڪري سگهي:

• تعمير ڪندڙ بنيادي (ابتدائي) قسمن جي ان پٽ پيٽرولر جي قيمتن کي تبديل نٿو ڪري سگھي؛
• تعمير ڪندڙ ان پٽ پيٽرولر حوالن کي تبديل نٿو ڪري سگھي؛
• تعمير ڪندڙ ان پٽ پيٽرولر ريفرنس کي نئين شين جي حوالي نٿو ڪري سگهي.

ٺاھيندڙ پنھنجي ان پٽ پيٽرولن سان ڪري سگھي ٿو:

• ان پٽ پيٽرولر جي طور تي منظور ٿيل اعتراض جي حالت کي تبديل ڪريو.

هيٺ ڏنل مثال ثابت ڪري ٿو ته جاوا ۾، هڪ تعمير ڪندڙ کي ان پٽ پيٽرولر اعتراض جي حوالن جي قيمت سان گذري ويا آهن. هي مثال اهو پڻ ظاهر ڪري ٿو ته تعمير ڪندڙ ان پٽ پيٽرولر جي حوالن کي تبديل نٿو ڪري سگهي، پر اصل ۾ ان پٽ پيٽرولر جي نقلن جي حوالن کي تبديل ڪري ٿو. فائل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

جيڪڏهن جاوا استعمال ڪيو ڪال جي حوالي سان شيون پاس ڪرڻ لاءِ پيراميٽر جي طور تي، ٺاهيندڙ بدلائي ڇڏيندو 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)variable اعتراض جي حوالي جي قيمت منظور ڪئي ويندي s1، ۽ ڪنسٽرڪٽر مؤثر طريقي سان تنخواه کي ٽي ڀيرا ڪندو ، ڇو ته ڪنسٽرڪٽر جي اندر ٺاهيل s1.valueڪاپي به variable شئي ڏانهن اشارو ڪري ٿي . (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وڌايو ويندو . سامهون اختيار، جڏهن متغير قسم جو هوندو ، ۽ تعمير ڪندڙ کي صرف هڪ پيٽرولر هوندو ، هن صورتحال ۾ هڪ تاليف جي غلطي کي ڏسندي. intdoubleidoubleint

تعمير ڪندڙ ڪال ۽ آپريٽر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ان جي ريفرنس ويليو کي Constructor parameter ۾ اعتراض ڏانهن منتقل ڪندي. انهي جي تصديق ڪري سگهجي ٿي پيداوار جا نتيجا. ۽ جڏهن لڪير تي عمل ڪندي Salary3 s3 = new Salary3(s1)؛ متغير لاءِ هڪ نئون اعتراض پيدا ڪيو ويندو s3۽ متغير لاءِ اعتراض جي حالت ٻيهر تبديل ٿي ويندي s1.

تعمير ڪندڙ ۽ شروعاتي بلاڪ، عملن جو سلسلو جڏھن ھڪڙي ٺاھيندڙ کي سڏين ٿا

سيڪشن Creating an Object and Constructors انهن عام عملن کي لسٽ ڪري ٿو جيڪي ڪنهن شئي ٺاهڻ وقت ڪيا ويندا آهن. انهن ۾ ڪلاس جي شعبن کي شروع ڪرڻ ۽ ڪلاس ڪنسٽرڪٽر کي ڪم ڪرڻ جا عمل آهن، جن جي نتيجي ۾ هڪ اندروني ترتيب پڻ آهي:

1. سڀ ڊيٽا جا شعبا شروع ڪيا ويا آھن انھن جي ڊفالٽ ويلز (0، غلط، يا نال).
2. سڀني فيلڊ جي شروعات ڪندڙ ۽ شروعاتي بلاڪ ترتيب ڏنل آهن انهي ترتيب ۾ اهي درج ٿيل آهن ڪلاس جي اعلان ۾.
3. جيڪڏهن ڪنهن ٻئي ڪنسٽرڪٽر کي ڪانسٽرڪٽر جي پهرين لائين تي سڏيو وڃي ته پوءِ ڪنسٽرڪٽر کي ڪم ڪيو ويندو.
4. تعمير ڪندڙ جي جسم تي عمل ڪيو ويندو آهي.

تعمير ڪندڙ شروعاتي سان لاڳاپيل آهي ڇاڪاڻ ته جاوا ۾ ڪلاس ۾ فيلڊ کي شروع ڪرڻ جا ٽي طريقا آهن:

• بيان ۾ هڪ قدر مقرر ڪريو؛
• شروعاتي بلاڪ ۾ قدر مقرر ڪريو؛
• ٺاھيندڙ ۾ ان جي قيمت مقرر ڪريو.

قدرتي طور تي، توهان کي شروعاتي ڪوڊ کي ترتيب ڏيڻ جي ضرورت آهي ته جيئن اهو سمجهڻ آسان آهي. هيٺيون ڪلاس مثال طور ڏنو ويو آهي:

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.

thisConstructors ۾ لفظ

Constructors استعمال ڪيا ويندا آهن 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

ھن مثال ۾ ٻه ٺاھيندڙ آھن. پهرين هڪ حاصل ڪري ٿو اسٽرنگ دليل. ٻيو ڪو به دليل حاصل نٿو ڪري، اهو صرف پهريون ٺاهيندڙ کي سڏي ٿو ڊفالٽ نالو "جان" استعمال ڪندي. اهڙيء طرح، توهان تعمير ڪندڙ استعمال ڪري سگهو ٿا فيلڊ ويلز کي شروع ڪرڻ لاء واضح طور تي ۽ ڊفالٽ طور، جيڪو اڪثر پروگرامن ۾ ضروري آهي.

superConstructors ۾ لفظ

ڪنسٽرڪٽرز کي 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.

تعمير ڪندڙن کي طبقاتي ماتحت جي ترتيب ۾ سڏيو ويندو آهي. اهو ڪجهه سمجهه ۾ اچي ٿو. جيئن ته سپر ڪلاس کي ڪنهن به ذيلي ڪلاس جي ڪا به ڄاڻ نه آهي، ان کي انجام ڏيڻ جي ڪا به شروعات الڳ الڳ آهي. جيڪڏهن ممڪن هجي، ان کي ذيلي ڪلاس پاران ڪيل ڪنهن به شروعات کان اڳ ڪرڻ گهرجي. ان ڪري ان کي پهرين ڪرڻ گهرجي.

حسب ضرورت تعمير ڪندڙ

رن-ٽائم قسم جي سڃاڻپ جو طريقو جاوا ٻولي جي طاقتور بنيادي اصولن مان ھڪڙو آھي جيڪو پوليمورفيزم کي لاڳو ڪري ٿو. بهرحال، اهڙي ميڪانيزم ڊولپر کي ڪجهه ڪيسن ۾ غير مطابقت واري قسم جي ڪاسٽنگ کان بچائي نٿو سگهي. سڀ کان وڌيڪ عام ڪيس شين جي هڪ گروهه جي ڦيرڦار آهي، جن جا مختلف قسم اڳ ۾ اڻڄاتل آهن ۽ هلندڙ وقت تي طئي ٿيل آهن. جيئن ته قسم جي غير مطابقت سان لاڳاپيل غلطيون صرف رن ٽائم اسٽيج تي ظاهر ٿي سگهن ٿيون، اهو انهن کي ڳولڻ ۽ ختم ڪرڻ ڏکيو بڻائي ٿو. جاوا 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، ان کي ڪنهن به مان سڏيو وڃي ٿو.