జావా తరగతులు: మీ స్వంత తరగతులను వ్రాయడం, కన్స్ట్రక్టర్లు

హాయ్! ఈ రోజు మనం జావాలో తరగతుల గురించి మాట్లాడుతాము. జావా ప్రోగ్రామింగ్‌కు తరగతులు మూలస్తంభంగా ఉన్నాయని మీరు చెప్పవచ్చు. మీరు ప్రోగ్రామర్ అయినప్పుడు, దాదాపు మీ మొత్తం ఉద్యోగం వివిధ విధులను కలిగి ఉన్న మీ స్వంత తరగతులను వ్రాయడం. దీని అర్థం ఏమిటి మరియు అది ఎలా పనిచేస్తుందో చూద్దాం. :) మీకు తెలిసినట్లుగా, జావా అనేది ఆబ్జెక్ట్-ఓరియెంటెడ్ ప్రోగ్రామింగ్ లాంగ్వేజ్. అన్ని ప్రోగ్రామ్‌లు ఒకదానికొకటి సంబంధం ఉన్న వస్తువులను కలిగి ఉంటాయి. తరగతి అనేది ఒక వస్తువు కోసం ఒక టెంప్లేట్. ఇది ఆబ్జెక్ట్ ఎలా ఉంటుందో మరియు అది ఏ విధులను కలిగి ఉంటుందో నిర్ణయిస్తుంది. ప్రతి వస్తువు ఏదో ఒక తరగతికి చెందిన వస్తువు. ఈ చాలా సులభమైన ఉదాహరణను పరిగణించండి:

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() మరియు జంప్() పద్ధతులను పిలుస్తున్నాము . కన్సోల్‌ను చూద్దాం: మియావ్! దూకు! నిజమైన పిల్లి! :)

మీ స్వంత తరగతులను సృష్టించడం. సంగ్రహణ

భవిష్యత్తులో, మీరు మీ స్వంత తరగతులను వ్రాయవలసి ఉంటుంది. మీరు వాటిని వ్రాసేటప్పుడు మీరు ఏమి చూడాలి? మేము వేరియబుల్స్ గురించి మాట్లాడుతున్నట్లయితే, మీరు సంగ్రహణ అని పిలవబడే దాన్ని ఉపయోగించాలి. ఆబ్జెక్ట్-ఓరియెంటెడ్ ప్రోగ్రామింగ్ యొక్క నాలుగు ప్రాథమిక సూత్రాలలో సంగ్రహణ ఒకటి. దీని అర్థం ఒక అంశం యొక్క అత్యంత ముఖ్యమైన మరియు ముఖ్యమైన లక్షణాలను సంగ్రహించడం మరియు దీనికి విరుద్ధంగా, చిన్నవి లేదా అంతగా లేని వాటిని పక్కన పెట్టడం. ఉదాహరణకు, కంపెనీ ఉద్యోగుల కోసం ఫైలింగ్ క్యాబినెట్‌ని క్రియేట్ చేద్దాం. ఉద్యోగి వస్తువులను సృష్టించడానికి, మేము ఒక ఉద్యోగిని వ్రాసాముతరగతి. మా కంపెనీ ఫైలింగ్ క్యాబినెట్ కోసం ఉద్యోగి యొక్క ముఖ్యమైన వివరణలు ఏమిటి? పేరు, పుట్టిన తేదీ, SSN మరియు ఉద్యోగి ID. కానీ కంపెనీ ఉద్యోగి రికార్డు కోసం మాకు ఉద్యోగి ఎత్తు, కంటి రంగు లేదా జుట్టు రంగు అవసరం అయ్యే అవకాశం లేదు. కంపెనీలకు ఈ సమాచారం అవసరం లేదు. కాబట్టి, ఎంప్లాయీ క్లాస్‌లో, మేము ఈ క్రింది వేరియబుల్స్‌ను ప్రకటిస్తాము: స్ట్రింగ్ పేరు , పూర్ణాంక వయస్సు , పూర్ణ సామాజిక భద్రత సంఖ్య , మరియు పూర్ణాంక ఉద్యోగి ఐడి. మరియు మేము అనవసరమైన సమాచారాన్ని వదిలివేస్తాము (కంటి రంగు వంటివి). మరో మాటలో చెప్పాలంటే, మేము ఒక సంగ్రహణను సృష్టిస్తాము. అయితే, మేము మోడలింగ్ ఏజెన్సీల కోసం ఫైలింగ్ క్యాబినెట్‌ను రూపొందిస్తున్నట్లయితే, పరిస్థితి ఒక్కసారిగా మారుతుంది. మోడల్ యొక్క ఎత్తు, కంటి రంగు మరియు జుట్టు రంగు ముఖ్యమైన లక్షణాలు, కానీ ఆమె 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, "అజ్టెక్").
   మూడవ రకం కోసం, క్రమ సంఖ్య, దానిని సృష్టించిన సంస్కృతి మరియు అది సృష్టించబడిన శతాబ్దం (ఉదాహరణకు: 212121, "అజ్టెక్", 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) {
           
       }
   }
   

మీరు నేర్చుకున్న వాటిని బలోపేతం చేయడానికి, మా జావా కోర్సు నుండి వీడియో పాఠాన్ని చూడమని మేము మీకు సూచిస్తున్నాము