ஜாவா வகுப்புகள்: உங்கள் சொந்த வகுப்புகளை எழுதுதல், கட்டமைப்பாளர்கள்

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

public class Cat {

    String name;
    int age;

}

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

public class Cat {

    String name;
    int age;

    public static void main(String[] args) {
        Cat smudge = new Cat();
        smudge.age = 3;
        smudge.name = "Smudge";

        System.out.println("We created a cat named " + smudge.name + ". His age is " + smudge.age);
    }

}

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

public class Cat {

    String name;
    int age;

    static int count = 0;

    public static void main(String[] args) {
        Cat smudge = new Cat();
        smudge.age = 3;
        smudge.name = "Smudge";
        count++;

        Cat fluffy = new Cat();
        fluffy.age = 5;
        fluffy.name = "Fluffy";
        count++;

        System.out.println("We created a cat named " + smudge.name + ". His age is " + smudge.age);
        System.out.println("We created a cat named " + fluffy.name + ". His age is " + fluffy.age);

        System.out.println("Total number of cats = " + count);
    }
}

கன்சோல் வெளியீடு: ஸ்மட்ஜ் என்ற பூனையை உருவாக்கினோம். அவரது வயது 3 நாங்கள் ஃப்ளஃபி என்ற பூனையை உருவாக்கினோம். அவரது வயது 5 பூனைகளின் மொத்த எண்ணிக்கை = 2 இப்போது எங்கள் வகுப்பில் எண்ணிக்கை என்ற புதிய மாறி உள்ளது. உருவாக்கப்பட்ட பூனைகளை எண்ணுவதற்கு இது பொறுப்பு. ஒவ்வொரு முறையும் நாம் முக்கியமாக ஒரு பூனையை உருவாக்குகிறோம்முறை, இந்த மாறியை 1 ஆல் அதிகரிக்கிறோம். இந்த மாறி நிலையான முக்கிய சொல்லைப் பயன்படுத்தி அறிவிக்கப்படுகிறது. அதாவது அது வகுப்பைச் சேர்ந்தது, வகுப்பின் குறிப்பிட்ட பொருளுக்கு அல்ல. நிச்சயமாக, இது அர்த்தமுள்ளதாக இருக்கிறது: ஒவ்வொரு பூனையின் பெயரும் குறிப்பிட்ட பூனைக்கு சொந்தமானது, ஆனால் அவை அனைத்திற்கும் பொருந்தக்கூடிய ஒரு பூனை கவுண்டர் நமக்குத் தேவை. நிலையான முக்கிய சொல் இதைத்தான் துல்லியமாகச் செய்கிறது: இது அனைத்து பூனைகளுக்கும் எண்ணிக்கை மாறியை ஒற்றை மாறியாக மாற்றுகிறது. குறிப்பு: நாம் மாறியைக் காண்பிக்கும் போது, ​​நாங்கள் smudge.count அல்லது fluffy.count ஐப் பயன்படுத்துவதில்லை. இது ஸ்மட்ஜ் அல்லது பஞ்சுபோன்ற இரண்டிற்கும் சொந்தமானது அல்ல; இது முழு பூனை வகுப்பிற்கும் சொந்தமானது. அதனால்தான் இது வெறுமனே எண்ணப்படுகிறது. நீங்கள் Cat.count என்று எழுதலாம். அதுவும் சரியாக இருக்கும். பெயர் மாறியைக் காட்டும்போது, ​​பின்வருவனவற்றைச் செய்ய மாட்டோம்:

public class Cat {

    String name;
    int age;

    static int count = 0;

    public static void main(String[] args) {
        Cat smudge = new Cat();
        smudge.age = 3;
        smudge.name = "Smudge";
        count++;

        System.out.println("We created a cat named " + name + ". His age is " + smudge.age);

        System.out.println("Total number of cats = " + count);
    }
}

இது ஒரு பிழை! ஒவ்வொரு பூனைக்கும் அதன் சொந்த பெயர் உண்டு. கம்பைலர் இங்கே குழப்பமடைகிறது. "கன்சோலுக்கு ஒரு பெயரை வெளியிடு? யாருடைய பெயர்?" :/"

முறைகள்

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

public class Cat {

    String name;
    int age;

    public void sayMeow() {
        System.out.println("Meow!");
    }

    public void jump() {
        System.out.println("Pounce!");
    }

    public static void main(String[] args) {
        Cat smudge = new Cat();
        smudge.age = 3;
        smudge.name = "Smudge";

        smudge.sayMeow();
        smudge.jump();

    }
}

அதைப் பாருங்கள்! இப்போது எங்கள் வகுப்பு பூனையை ஒத்திருக்கிறது! இப்போது எங்களிடம் ஒரு பெயர் ("ஸ்மட்ஜ்") மற்றும் வயது (3) உள்ள பூனை இல்லை. மியாவ் சொல்லி குதிக்கவும் முடியும்! அந்த "செயல்பாடு" இல்லாமல் அது என்ன வகையான பூனையாக இருக்கும்? :) நாம் ஒரு குறிப்பிட்ட பொருளை (ஸ்மட்ஜ்) எடுத்து அதன் sayMeow() மற்றும் jump() முறைகளை அழைக்கிறோம். கன்சோலைப் பார்ப்போம்: மியாவ்! பாய்ச்சல்! ஒரு உண்மையான பூனை! :)

உங்கள் சொந்த வகுப்புகளை உருவாக்குதல். சுருக்கம்

எதிர்காலத்தில், நீங்கள் உங்கள் சொந்த வகுப்புகளை எழுத வேண்டும். அவற்றை எழுதும்போது நீங்கள் கவனிக்க வேண்டியது என்ன? நாம் மாறிகளைப் பற்றி பேசுகிறோம் என்றால், நீங்கள் சுருக்கம் எனப்படும் ஒன்றைப் பயன்படுத்த வேண்டும். பொருள் சார்ந்த நிரலாக்கத்தின் நான்கு அடிப்படைக் கொள்கைகளில் சுருக்கம் ஒன்றாகும். இதன் பொருள் ஒரு பொருளின் மிக முக்கியமான மற்றும் குறிப்பிடத்தக்க பண்புகளை பிரித்தெடுப்பது மற்றும் மாறாக, சிறிய அல்லது முக்கியமற்றவற்றை ஒதுக்கி வைப்பதாகும். எடுத்துக்காட்டாக, நிறுவன ஊழியர்களுக்கான தாக்கல் அமைச்சரவையை உருவாக்குவோம். பணியாளர் பொருட்களை உருவாக்க, நாங்கள் ஒரு பணியாளரை எழுதியுள்ளோம்வர்க்கம். எங்கள் நிறுவனத்தின் தாக்கல் அமைச்சரவைக்கு ஒரு பணியாளரின் முக்கிய விவரக்குறிப்புகள் என்ன? பெயர், பிறந்த தேதி, SSN மற்றும் பணியாளர் ஐடி. ஆனால் நிறுவனத்தின் ஊழியர் பதிவுக்கு பணியாளரின் உயரம், கண் நிறம் அல்லது முடி நிறம் தேவைப்படுவது சாத்தியமில்லை. நிறுவனங்களுக்கு இந்தத் தகவல் தேவையில்லை. எனவே, பணியாளர் வகுப்பில், பின்வரும் மாறிகளை நாங்கள் அறிவிக்கிறோம்: சரத்தின் பெயர் , முழு வயது , முழு சமூகப் பாதுகாப்பு எண் , மற்றும் முழு ஊழியர் ஐடி. மேலும் தேவையற்ற தகவல்களை (கண் நிறம் போன்றவை) விட்டுவிடுகிறோம். வேறு வார்த்தைகளில் கூறுவதானால், நாம் ஒரு சுருக்கத்தை உருவாக்குகிறோம். இருப்பினும், மாடலிங் ஏஜென்சிகளுக்கு நாங்கள் தாக்கல் செய்யும் அமைச்சரவையை உருவாக்கினால், நிலைமை வியத்தகு முறையில் மாறுகிறது. ஒரு மாடலின் உயரம், கண் நிறம் மற்றும் முடி நிறம் ஆகியவை முக்கியமான குணாதிசயங்கள், ஆனால் அவளுடைய SSN எங்களுக்கு முற்றிலும் பொருத்தமற்றது. எனவே, மாதிரி வகுப்பில், நாம் பின்வரும் மாறிகளை உருவாக்க வேண்டும்: சரம் உயரம் , சரம் முடி , சரம் கண்கள் . சுருக்கம் இப்படித்தான் செயல்படுகிறது - இது எளிதானது! :)

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

எங்கள் பூனை உதாரணத்திற்கு திரும்புவோம்.

public class Cat {

    String name;
    int age;

    public static void main(String[] args) {
        Cat smudge = new Cat();

        System.out.println("Here the program does something for 2 hours...");

        smudge.age = 3;
        smudge.name = "Smudge";

    }
}

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

public class Cat {

    String name;
    int age;

    // Constructor for the Cat class
    public Cat(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public static void main(String[] args) {

        Cat smudge = new Cat("Smudge", 5);
    }
}

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

public class Cat {

    String name;
    int age;

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

    public static void main(String[] args) {

        Cat smudge = new Cat(); // Error!
    }
}

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

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

இந்த பூனையின் பெயர் (நாம் உருவாக்குவது) = கட்டமைப்பாளரின் பெயர் அளவுருவிற்கு அனுப்பப்பட்ட வாதம். இந்த பூனையின் வயது (நாம் உருவாக்குவது) = கட்டமைப்பாளருக்கான வாதம் வயது அளவுரு." கட்டமைப்பாளர் இயங்கிய பிறகு, தேவையான அனைத்து மதிப்புகளும் எங்கள் பூனைக்கு ஒதுக்கப்பட்டுள்ளன என்பதை நீங்கள் சரிபார்க்கலாம்:

public class Cat {

    String name;
    int age;

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

    public static void main(String[] args) {

        Cat smudge = new Cat("Smudge", 5);
        System.out.println(smudge.name);
        System.out.println(smudge.age);
    }
}

கன்சோல் வெளியீடு: ஸ்மட்ஜ் 5 கட்டமைப்பாளர் அழைக்கப்பட்ட போது:

Cat smudge = new Cat("Smudge", 5);

இது உண்மையில் உள்நாட்டில் நடந்தது:

this.name = "Smudge";
this.age = 5;

கட்டமைப்பாளருக்கு அனுப்பப்பட்ட வாதங்களின் மதிப்புகள் ஸ்மட்ஜ் பொருளுக்கு ஒதுக்கப்பட்டன (இந்த விஷயத்தில் இது குறிக்கிறது). உண்மையில், நீங்கள் ஒரு வகுப்பில் எந்த கன்ஸ்ட்ரக்டர்களையும் அறிவிக்காவிட்டாலும், அது கன்ஸ்ட்ரக்டரை அழைக்கும்! ஆனால் அது எப்படி சாத்தியம்? О_О ஏனெனில், அனைத்து ஜாவா வகுப்புகளும் இயல்புநிலை கட்டமைப்பாளர் என்று அழைக்கப்படும். இது எந்த வாதங்களையும் எடுக்காது, ஆனால் எந்த வகுப்பின் எந்தவொரு பொருளையும் நீங்கள் உருவாக்கும் ஒவ்வொரு முறையும் இது செயல்படுத்தப்படுகிறது.

public class Cat {

    public static void main(String[] args) {

        Cat smudge = new Cat(); // The default constructor is invoked here
    }
}

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

public class Cat {

    public Cat() {
        System.out.println("A cat has been created!");
    }

    public static void main(String[] args) {

        Cat smudge = new Cat(); // The default constructor is invoked here
    }
}

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

public class Cat {

    String name;
    int age;

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

    public static void main(String[] args) {

        Cat smudge = new Cat(); // Error!
    }
}

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

public class Cat {

    String name;
    int age;

    // For cats with owners
    public Cat(String name, int age) {
        this.name = name;
        this.age = age;
    }

    // For street cats
    public Cat() {
    }

    public static void main(String[] args) {
        
        Cat smudge = new Cat("Smudge", 5);
        Cat streetCat = new Cat();
    }
}

இப்போது வெளிப்படையான இயல்புநிலை கட்டமைப்பாளரைக் குறிப்பிட்டுள்ளோம், இரண்டு வகையான பூனைகளையும் உருவாக்கலாம். கட்டமைப்பாளரில், நீங்கள் நேரடியாக மதிப்புகளை ஒதுக்கலாம். நீங்கள் எப்போதும் அவற்றை வாதங்களில் இருந்து எடுக்க வேண்டியதில்லை. எடுத்துக்காட்டாக, "தெரு பூனை எண். <count>" என்பதை டெம்ப்ளேட்டாகப் பயன்படுத்தி தரவுத்தளத்தில் உள்ள அனைத்து தெரு பூனைகளையும் லேபிளிடலாம். :

public class Cat {

    String name;
    int age;

    static int count = 0;

    public Cat() {
        count++;
        this.name = "Street cat No. " + count;
    }

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

    public static void main(String[] args) {

        Cat streetCat1 = new Cat();
        Cat streetCat2 = new Cat();
        System.out.println(streetCat1.name);
        System.out.println(streetCat2.name);
    }
}

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

public class Cat {

    String name;
    int age;

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

    public static void main(String[] args) {

        Cat smudge = new Cat("Smudge", 10); // Error!
    }
}

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

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

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

இவை இரண்டும் முற்றிலும் வேறுபட்ட கட்டமைப்பாளர்கள்! இப்போது, ​​பொருள் பற்றிய உங்கள் புரிதலை உறுதிப்படுத்த இரண்டு பணிகளை முடிக்கவும். :)

1. பழங்கால அருங்காட்சியகம்.

   ஒரு கலைப்பொருள் வகுப்பை வடிவமைப்பதே உங்கள் பணி .
   அருங்காட்சியகத்தில் மூன்று வகையான கலைப்பொருட்கள் வைக்கப்பட்டுள்ளன.
   அருங்காட்சியகத்தால் ஒதுக்கப்பட்ட வரிசை எண்ணைத் தவிர முதல் வகையைப் பற்றி எங்களுக்கு எதுவும் தெரியாது (உதாரணமாக: 212121).
   இரண்டாவது வகைக்கு, வரிசை எண் மற்றும் அதை உருவாக்கிய கலாச்சாரம் நமக்குத் தெரியும் (உதாரணமாக: 212121, "Aztecs").
   மூன்றாவது வகைக்கு, வரிசை எண், அதை உருவாக்கிய கலாச்சாரம் மற்றும் அது உருவாக்கப்பட்ட நூற்றாண்டு (உதாரணமாக: 212121, "Aztecs", 12) ஆகியவற்றை நாங்கள் அறிவோம்.

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

   
   public class Artifact {
       
       // Write your code here
   
       public static void main(String[] args) {
           // Write your code here
       }
   }
   

2. டேட்டிங் இணையதளம்

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

   
   public class User {
   
       String name;
       short age;
       int height;
   
       // Write your code here
   
       public static void main(String[] args) {
           
       }
   }
   

நீங்கள் கற்றுக்கொண்டதை வலுப்படுத்த, எங்கள் ஜாவா பாடத்திட்டத்திலிருந்து வீடியோ பாடத்தைப் பார்க்க பரிந்துரைக்கிறோம்