பொருள்கள் மற்றும் கட்டமைப்பாளர்கள்

1. ஒரு பொருளை உருவாக்குதல்

சரி, நாங்கள் பொருட்களை உருவாக்குவதற்கு வந்துவிட்டோம். நீங்கள் ஏற்கனவே இதை எதிர்கொண்டீர்கள், ஆனால் இப்போது இந்த தலைப்பை இன்னும் விரிவாக ஆராய்வோம். உண்மையில் பொருட்களை உருவாக்குவது மிகவும் எளிது.

ஒரு பொருளை உருவாக்க, நீங்கள் புதிய ஆபரேட்டரைப் பயன்படுத்த வேண்டும். ஒரு பொருளை உருவாக்குவது தோராயமாக இப்படி இருக்கும்:

new Class(arguments)

ஒரு பொருளை உருவாக்கிய பிறகு, அதைப் பற்றிய குறிப்பை ஒரு மாறியில் உடனடியாகச் சேமிக்கிறோம், இது உருவாக்கப்பட்ட பொருளின் அதே வகையைப் பகிர்ந்து கொள்கிறது. அதாவது ஒரு பொருளை உருவாக்கும் போது, ​​நீங்கள் வழக்கமாக இது போன்ற குறியீட்டைப் பார்க்கிறீர்கள்:

Class name = new Class(arguments)

ஒரு புதிய மாறியின் உருவாக்கம் எங்கே , மற்றும் சமமான அடையாளத்தின் வலதுபுறத்தில் உள்ள குறியீடு என்பது ஒரு புதிய பொருளின் உருவாக்கம், அதன் வகை .Class nameClass

எடுத்துக்காட்டுகள்:

Object o = new Object();

Cat pet = new Cat();

Scanner console = new Scanner(System.in)

புரோகிராமர்கள் பெரும்பாலும் மாறிகளுக்கு அவர்களின் வகுப்புகளுக்குப் பிறகு பெயரிடுகிறார்கள், ஆனால் ஒரு சிறிய எழுத்துடன். ஒரு புதிய புரோகிராமருக்கு, அத்தகைய குறியீடு குழப்பமாக இருக்கலாம்:

BufferedReader bufferedReader = new BufferedReader( reader );

Cat cat = new Cat();

PersonInfo personInfo = new PersonInfo()

இந்தக் குறியீட்டில் எந்தத் தவறும் இல்லை - இது மிகவும் சாதாரண குறியீடு, இதில் ஒரு மாறி உருவாக்கப்பட்டு, அதன் அதே வகைப் பொருளால் உடனடியாக துவக்கப்படும்.

சம அடையாளத்தின் இடதுபுறத்தில் ஒரு மாறியை உருவாக்குகிறோம். வலதுபுறம், ஒரு பொருளின் உருவாக்கம். அவ்வளவுதான்.

2. கட்டமைப்பாளர்

ஒரு பொருளை உருவாக்கும் போது சில வாதங்கள் அடிக்கடி அனுப்பப்படுவதை நீங்கள் பார்த்திருக்கலாம். மேலும் என்னவென்றால், சில பொருட்களுக்கு வாதங்கள் அனுப்பப்படுகின்றன, ஆனால் மற்றவை அல்ல. வாதங்களுடன் கூடிய இந்த முழு பொறிமுறையும் எவ்வாறு செயல்படுகிறது?

இங்கே எல்லாம் எளிமையானது: ஒவ்வொரு வகுப்பிற்கும் ஒரு சிறப்பு முறை (அல்லது முறைகள்) உள்ளது, அவை ஒரு பொருளை உருவாக்கும் போது அனுப்பப்பட்ட வாதங்களைக் கையாள்வதற்கு பொறுப்பாகும். இந்த முறைகள் கட்டமைப்பாளர்கள் என்று அழைக்கப்படுகின்றன . அல்லது நாம் ஒன்றைப் பற்றி பேசும்போது: கட்டமைப்பாளர் .

வழக்கமான முறையிலிருந்து ஒரு கட்டமைப்பாளர் முறையை வேறுபடுத்துவது எளிது. இந்த முறை இரண்டு தனித்துவமான அம்சங்களைக் கொண்டுள்ளது:

• ஒரு கட்டமைப்பாளரின் பெயர் அதன் வகுப்பின் பெயரைப் போன்றது (மேலும் ஒரு பெரிய எழுத்தில் தொடங்குகிறது)
• ஒரு கட்டமைப்பாளரிடம் திரும்பும் வகை இல்லை.

பொதுவாக, இது பொதுவாக எப்படி இருக்கும் என்பது இங்கே:

modifiers Class(arguments)
{
   Code
}

உதாரணமாக:

public class Point
{
   public int x;
   public int y;

   Point(int x, int y)
   {
      this.x = x;
      this.y = y;
   }
}

public class Solution
{
   public static void main(String[] args)
   {
      Point point = new Point(5, 10);
   }
}

கன்ஸ்ட்ரக்டர் எப்படி இருக்கும் என்பதைக் கவனியுங்கள்: அதில் திரும்பும் வகை இல்லை மற்றும் அதன் பெயர் வகுப்புப் பெயரைப் போலவே உள்ளது.

மேலும் ஒரு விஷயம்: கட்டமைப்பாளரின் உள்ளே உள்ள குறியீட்டைப் பாருங்கள். கட்டமைப்பாளரின் அளவுருக்கள் வகுப்பின் புலங்களின் அதே பெயர்களைக் கொண்டுள்ளன: x மற்றும் y. நாவல் அளவுரு பெயர்களை உருவாக்குவதைத் தவிர்ப்பது வழக்கமான நடைமுறை. பெயர்கள் வகுப்பின் புலங்களின் பெயர்களைப் போலவே இருக்கும். இந்த முக்கிய சொல்லைப் பயன்படுத்தி பெயர் முரண்பாடு தீர்க்கப்படுகிறது.

3. ஒரு கட்டமைப்பாளரை அழைக்கிறது

புதிய ஆப்ஜெக்ட்டை உருவாக்க புதிய ஆபரேட்டரையும் "புதிய வகுப்பு ( வாதங்கள் )" போன்ற கட்டளையையும் பயன்படுத்தும்போது , ​​இரண்டு விஷயங்கள் நடக்கும்:

• ஜாவா இயந்திரம் ஒரு பொருளை உருவாக்குகிறது, அதன் வகை வகுப்பு
• ஜாவா இயந்திரம் பொருளின் கட்டமைப்பாளரை அழைக்கிறது மற்றும் உங்கள் வாதங்களில் கடந்து செல்கிறது

ஒரு புரோகிராமராக, உங்கள் வகுப்பில் என்ன கன்ஸ்ட்ரக்டர்கள் இருக்க வேண்டும், இந்த கன்ஸ்ட்ரக்டர்களுக்கு என்ன அளவுருக்கள் இருக்க வேண்டும் என்பதை நீங்கள் தீர்மானிக்க வேண்டும்.

ஒரு விலங்கு தங்குமிடத்தில் பூனைகளைக் கண்காணிக்க ஒரு வகுப்பை உருவாக்க நீங்கள் முடிவு செய்கிறீர்கள் என்று வைத்துக்கொள்வோம். உங்கள் Catவகுப்பு இப்படி இருக்கலாம்:

class Cat
{
   public String name;
   public int age;

   public Cat(String name, int age)
   {
      this.name = name;
      this.age = age;
   }
}

Cat cat = new Cat("Whiskers", 2);

Cat cat = new Cat("Whiskers");

Cat cat = new Cat();

வகுப்பில் Catபெயர் மற்றும் வயது அளவுருக்கள் கொண்ட ஒரே ஒரு கட்டமைப்பாளர் மட்டுமே உள்ளார். வேறு கட்டமைப்பாளர்கள் இல்லாததால், ஒரு பொருளை உருவாக்கும்போது பூனையின் பெயர் ( name) மற்றும் வயது ( ) ஆகியவற்றை வாதங்களாக அனுப்ப வேண்டும். ageகட்டமைப்பாளரிடம் வாதங்களை அனுப்புவது விருப்பமானது அல்ல .

4. பல கட்டமைப்பாளர்கள்

ஆனால் உங்களுக்குத் தேவைப்பட்டால், வகுப்பில் பல கட்டமைப்பாளர்களைச் சேர்க்கலாம். கட்டமைப்பாளர்களின் எண்ணிக்கை அல்லது அவற்றின் அளவுருக்கள் மீது வரம்பு இல்லை. நீங்கள் ஒரு பொருளை உருவாக்கும் போது, ​​கம்பைலர் தானாகவே அளவுருக்களுடன் பொருந்தக்கூடிய கட்டமைப்பாளரைத் தேர்ந்தெடுக்கும்

class Cat
{
   public static final int UNKNOWN = -1;
   public String name;
   public int age;

   public Cat(String name, int age)
   {
      this.name = name;
      this.age = age;
   }
   public Cat(String name)
   {
      this.name = name;
      this.age = UNKNOWN; // Unknown
   }
}

Cat cat = new Cat("Whiskers", 2);

Cat cat = new Cat("Whiskers");

Cat cat = new Cat();

பூனையின் வயது தெரியாமல் போகலாம் என்று கணக்கு போட முடிவு செய்தோம். இந்த வழக்கைக் கையாள, ஒரே ஒரு அளவுருவைக் கொண்ட ஒரு கட்டமைப்பாளருடன் சிறப்பு மாறிலியைச் சேர்த்துள்ளோம் UNKNOWN- பூனையின் பெயர்.

இரண்டு கன்ஸ்ட்ரக்டர்களுக்குள்ளும் இரண்டு மாறிகளையும் இன்னும் துவக்குகிறோம் என்பதை நினைவில் கொள்ளவும். தெரியாத/காணாமல் போன அளவுருக்களை மாறிலியுடன் மாற்றுவோம் UNKNOWN.

வயது மாறிக்கு எந்த மதிப்பும் ஒதுக்கப்படவில்லை என்றால், அது 0 இன் இயல்புநிலை மதிப்பைக் கொண்டிருக்கும். எல்லாவற்றிற்கும் மேலாக, தெருவில் காணப்படும் பூனைக்குட்டியின் வயது 0 ஆக இருக்கலாம். அதாவது வயது மாறியில் பூஜ்ஜியம் என்பது "தெரியாத வயது" என்று அர்த்தமல்ல.

5. இயல்புநிலை கட்டமைப்பாளர்

உங்கள் பொருள்கள் எந்த அளவுருவும் இல்லாமல் உடனடியாகத் தொடங்கப்பட வேண்டும் என நீங்கள் விரும்பினால், உங்கள் வகுப்பு வாதம் இல்லாத கட்டமைப்பாளரை அறிவிக்க வேண்டும்.

அளவுருக்கள் இல்லாத ஒரு கன்ஸ்ட்ரக்டர் என்பது குறியீடு இல்லாத ஒரு கட்டமைப்பாளர் என்பது அவசியமில்லை. அத்தகைய ஒரு கட்டமைப்பாளர் தொடக்க மதிப்புகளுடன் மாறிகளை துவக்கும் குறியீட்டைக் கொண்டிருக்கலாம்:

class Cat
{
   public static final int UNKNOWN = -1;
   public String name;
   public int age;

   public Cat(String name, int age)
   {
      this.name = name;
      this.age = age;
   }

   public Cat()
   {
      this.name = "Nameless";
      this.age = UNKNOWN; // Unknown
   }
}

Cat cat = new Cat("Whiskers", 2);

Cat cat = new Cat();

இயல்புநிலை கட்டமைப்பாளர்

நீங்கள் தெரிந்து கொள்ள வேண்டிய மற்றும் நினைவில் கொள்ள வேண்டிய மிக முக்கியமான விஷயம் உள்ளது.

உங்கள் வர்க்கம் ஒரு கன்ஸ்ட்ரக்டர் இல்லை என அறிவித்தால் , கம்பைலர் ஒரு இயல்புநிலை கட்டமைப்பாளரைச் சேர்க்கும், இது பொது மாற்றியமைப்புடன் கூடிய விவாதம் இல்லாத கட்டமைப்பாகும்.

ஆனால் உங்கள் வகுப்பு ஒரு கன்ஸ்ட்ரக்டரைக் கூட அறிவித்தால் , இயல்புநிலை கன்ஸ்ட்ரக்டர் சேர்க்கப்படாது , நீங்கள் விரும்பினால் அதை நீங்களே சேர்க்க வேண்டும்.

class Cat
{
   public String name;
   public int age;
}

Cat cat = new Cat();