ஜாவாவில் முறைகள்

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

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

sayMeow() மற்றும் jump() ஆகியவை எங்கள் வகுப்பின் முறைகள். இந்த முறைகளை இயக்குவது பின்வரும் கன்சோல் வெளியீட்டில் விளைகிறது:

Meow!
Pounce!

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

public class Truck {

    int length;
    int width;
    int height;
    int weight;

    public int getVolume() {
        int volume = length * width * height;
        return volume;
    }
}

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

ஜாவா முறை அளவுருக்கள்

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

public class BridgeOfficer {

    int maxWeight;

    public BridgeOfficer(int normalWeight) {
        this.maxWeight = normalWeight;
    }

    public boolean checkTruck(Truck truck) {
        if (truck.weight > maxWeight) {
            return false;
        } else {
            return true;
        }
    }
}

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

public static void main(String[] args) {
    Truck first = new Truck();
    first.weight = 10000;
    Truck second = new Truck();
    second.weight = 20000;

    BridgeOfficer officer = new BridgeOfficer(15000);
    System.out.println("Truck 1! Can I go, officer?");
    boolean canFirstTruckGo = officer.checkTruck(first);
    System.out.println(canFirstTruckGo);

    System.out.println();

    System.out.println("Truck 2! And can I?");
    boolean canSecondTruckGo = officer.checkTruck(second);
    System.out.println(canSecondTruckGo);
}

10,000 மற்றும் 20,000 சுமைகளுடன் இரண்டு லாரிகளை உருவாக்குகிறோம். மேலும் அதிகாரி பணிபுரியும் பாலம் அதிகபட்சமாக 15,000 எடை கொண்டது. நிரல் அதிகாரி.checkTruck(முதல்) முறையை அழைக்கிறது. இந்த முறை எல்லாவற்றையும் கணக்கிட்டு உண்மை என்று திரும்பும் , அதை நிரல் பூலியன் மாறி canFirstTruckGo இல் சேமிக்கிறது . இப்போது நீங்கள் அதை வைத்து என்ன வேண்டுமானாலும் செய்யலாம் (கணக்காளர் கொடுத்த பணத்தைப் போல). நாள் முடிவில், குறியீடு

boolean canFirstTruckGo = officer.checkTruck(first);

வரை கொதிக்கிறது

boolean canFirstTruckGo =  true;

இங்கே ஒரு மிக முக்கியமான விஷயம்: ரிட்டர்ன் ஸ்டேட்மென்ட், முறையின் ரிட்டர்ன் மதிப்பை மட்டும் தருவதில்லை, அது முறை இயங்குவதையும் நிறுத்துகிறது! ரிட்டர்ன் ஸ்டேட்மென்ட்டுக்குப் பிறகு வரும் எந்தக் குறியீடும் செயல்படுத்தப்படாது!

public boolean checkTruck(Truck truck) {

    if (truck.weight > maxWeight) {
        return false;
        System.out.println("Turn around, you're overweight!");
    } else {
        return true;
        System.out.println("Everything looks good, go ahead!");
    }
}

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

Avengers: Parameter War

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

public class Jarvis {

    public void sayHi(String name) {
        System.out.println("Good evening, " + name + ". How are you?");
    }

    public static void main(String[] args) {
        Jarvis jarvis = new Jarvis();
        jarvis.sayHi("Tony Stark");
    }
}

கன்சோல் வெளியீடு:

Good evening, Tony Stark. How are you?

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

ஜாவா முறை ஓவர்லோடிங்

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

public class Jarvis {

    public void sayHi(String firstGuest) {
        System.out.println("Good evening, " + firstGuest + ". How are you?");
    }

    public void sayHi(String firstGuest, String secondGuest) {
        System.out.println("Good evening, " + firstGuest + " and " + secondGuest + ". How are you?");
    }
}

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

public class Jarvis {

    public void sayHi(String firstGuest) {
        System.out.println("Good evening, " + firstGuest + ". How are you?");
    }

    public void sayHi(String firstGuest, String secondGuest) {
        System.out.println("Good evening, " + firstGuest + " and " + secondGuest + ". How are you?");
    }

    public static void main(String[] args) {
        Jarvis jarvis = new Jarvis();
        jarvis.sayHi("Tony Stark");
        jarvis.sayHi("Tony Stark", "Captain America");
    }
}

கன்சோல் வெளியீடு:

Good evening, Tony Stark. How are you?
Good evening, Tony Stark and Captain America. How are you?

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

public void sayHi(String...names) {

    for (String name: names) {
        System.out.println("Good evening, " + name + ". How are you?");
    }
}

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

public class Jarvis {

    public void sayHi(String...names) {
        for (String name: names) {
            System.out.println("Good evening, " + name + ". How are you?");
        }
    }

    public static void main(String[] args) {
        Jarvis jarvis = new Jarvis();
        jarvis.sayHi("Tony Stark", "Captain America", "Black Widow", "Hulk");
    }
}

கன்சோல் வெளியீடு:

Good evening, Tony Stark. How are you?
Good evening, Captain America. How are you?
Good evening, Black Widow. How are you?
Good evening, Hulk. How are you?

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

public class Person {

    public static void sayYourAge(String greeting, int age) {
        System.out.println(greeting + " " + age);
    }

    public static void main(String[] args) {
        sayYourAge("My age is ", 33);
        sayYourAge(33, "My age is "); // Error!
    }
}

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

மீண்டும் அளவுருக்கள் பற்றி

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

public class TimeMachine {

    public void goToFuture(int currentYear) {
        currentYear = currentYear+10;
    }

    public void goToPast(int currentYear) {
        currentYear = currentYear-10;
    }

    public static void main(String[] args) {
        TimeMachine timeMachine = new TimeMachine();
        int currentYear = 2018;

        System.out.println("What year is it?");
        System.out.println(currentYear);

        timeMachine.goToPast(currentYear);
        System.out.println("How about now?");
        System.out.println(currentYear);
    }
}

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

What year is it?
2018
How about now?
2018

நடப்பு ஆண்டு மாறியை goToPast() முறைக்கு அனுப்பினோம் , ஆனால் அதன் மதிப்பு மாறவில்லை. நாங்கள் 2018 இல் இருந்தோம், இங்கே நாங்கள் தங்கியுள்ளோம். ஆனால் ஏன்? :/ ஏனெனில் ஜாவாவில் உள்ள பழமையானவை மதிப்பு மூலம் முறைகளுக்கு அனுப்பப்படுகின்றன. அதற்கு என்ன பொருள்? நாம் goToPast() முறையை அழைத்து , அதற்கு int variable currentYear (=2018) ஐ அனுப்பும்போது , ​​அந்த முறை தற்போதைய ஆண்டு மாறியைப் பெறாது , மாறாக அதன் நகலைப் பெறுகிறது. நிச்சயமாக, இந்த நகலின் மதிப்பு 2018 ஆகும், ஆனால் நகலில் ஏற்படும் மாற்றங்கள் எங்களின் அசல் நடப்பு ஆண்டு மாறியை எந்த வகையிலும் பாதிக்காது! எங்கள் குறியீட்டை இன்னும் தெளிவாக்குவோம் மற்றும் நடப்பு ஆண்டில் என்ன நடக்கிறது என்பதைப் பார்ப்போம்:

public class TimeMachine {

    public void goToFuture(int currentYear) {
        currentYear = currentYear+10;
    }

    public void goToPast(int currentYear) {
        System.out.println("The goToPast method has started running!");
        System.out.println("currentYear inside the goToPast method (at the beginning) = " + currentYear);
        currentYear = currentYear-10;
        System.out.println("currentYear inside the goToPast method (at the end) = " + currentYear);
    }

    public static void main(String[] args) {
        TimeMachine timeMachine = new TimeMachine();
        int currentYear = 2018;

        System.out.println("What was the year when the program started?");
        System.out.println(currentYear);

        timeMachine.goToPast(currentYear);
        System.out.println("And what year is it now?");
        System.out.println(currentYear);
    }
}

கன்சோல் வெளியீடு:

What was the year when the program started?
2018
The goToPast method has started running!
currentYear inside the goToPast method (at the beginning) = 2018
currentYear inside the goToPast method (at the end) = 2008
And what year is it now?
2018

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

public class Cat {

    int age;

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

இப்போது எங்கள் நேர இயந்திரத்தின் உதவியுடன் உலகின் முதல் நேரத்தைப் பயணிக்கும் பூனையான ஸ்மட்ஜை கடந்த காலத்திற்கும் எதிர்காலத்திற்கும் அனுப்புவோம் ! டைம்மெஷின் வகுப்பை மாற்றுவோம் , அது பூனைப் பொருட்களுடன் வேலை செய்யும்;

public class TimeMachine {

    public void goToFuture(Cat cat) {
        cat.age += 10;
    }

    public void goToPast(Cat cat) {
        cat.age -= 10;
    }
}

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

public static void main(String[] args) {

    TimeMachine timeMachine = new TimeMachine();
    Cat smudge = new Cat(5);

    System.out.println("How old was Smudge when the program started?");
    System.out.println(smudge.age);

    timeMachine.goToFuture(smudge);
    System.out.println("How about now?");
    System.out.println(smudge.age);

    System.out.println("Holy smokes! Smudge has aged 10 years! Back up quickly!");
    timeMachine.goToPast(smudge);
    System.out.println("Did it work? Have we returned the cat to its original age?");
    System.out.println(smudge.age);
}

கன்சோல் வெளியீடு:

How old was Smudge when the program started running?
5
How about now?
15
Holy smokes! Smudge has aged 10 years! Back up quickly!
Did it work? Have we returned the cat to its original age?
5

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

public class TimeMachine {

    public void goToFuture(Cat cat) {
        cat = new Cat(cat.age);
        cat.age += 10;
    }

    public void goToPast(Cat cat) {
        cat = new Cat(cat.age);
        cat.age -= 10;
    }

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

        System.out.println("How old was Smudge when the program started?");
        System.out.println(smudge.age);

        timeMachine.goToFuture(smudge);
        System.out.println ("Smudge went to the future! Has his age changed?");
        System.out.println(smudge.age);

        System.out.println ("And if you try going back?");
        timeMachine.goToPast(smudge);
        System.out.println(smudge.age);
    }
}

கன்சோல் வெளியீடு:

How old was Smudge when the program started running?
5
Smudge went to the future! Has his age changed?
5
And if you try going back?
5

அது மீண்டும் வேலை செய்யாது! О_О என்ன நடந்தது என்பதைக் கண்டுபிடிப்போம். :) இது goToPast / goToFuture முறைகள் மற்றும் குறிப்புகள் எவ்வாறு செயல்படுகின்றன என்பதற்கான அனைத்தையும் கொண்டுள்ளது . இப்போது, ​​உங்கள் கவனம், தயவுசெய்து! குறிப்புகள் மற்றும் முறைகள் எவ்வாறு செயல்படுகின்றன என்பதைப் புரிந்து கொள்ள இது மிக முக்கியமான விஷயம். உண்மை என்னவென்றால், goToFuture(Cat cat) முறையை நாம் அழைக்கும் போது, ​​அது கடந்து செல்லும் பூனைப் பொருளைப் பற்றிய குறிப்பின் நகலாகும், அது குறிப்பு அல்ல. இவ்வாறு, ஒரு பொருளை ஒரு முறைக்கு அனுப்பும்போது, ​​​​பொருளுக்கு இரண்டு குறிப்புகள் உள்ளன. என்ன நடக்கிறது என்பதைப் புரிந்துகொள்வதற்கு இது மிகவும் முக்கியமானது. எங்கள் கடைசி எடுத்துக்காட்டில் பூனையின் வயது ஏன் மாறவில்லை என்பது இதுதான். முந்தைய எடுத்துக்காட்டில், வயதை மாற்றும்போது, ​​goToFuture() க்கு அனுப்பப்பட்ட குறிப்பை நாங்கள் எடுத்துக் கொண்டோம்.முறை, மற்றும் நினைவகத்தில் உள்ள பொருளைக் கண்டுபிடித்து அதன் வயதை மாற்ற இதைப் பயன்படுத்தியது ( cat.age += 10 ). ஆனால் இப்போது, ​​goToFuture() முறைக்குள், நாங்கள் ஒரு புதிய பொருளை உருவாக்குகிறோம் ( cat = new Cat(cat.age) ), மேலும் இந்த பொருளுக்கு அந்த முறைக்கு அனுப்பப்பட்ட அதே குறிப்பு நகல் ஒதுக்கப்பட்டுள்ளது. அதன் விளைவாக:

• முதல் குறிப்பு ( Cat smudge = new Cat (5) ) அசல் பூனையை (வயது 5 உடன்) சுட்டிக்காட்டுகிறது
• அதன் பிறகு, cat மாறி goToPast() முறையைக் கடந்து , அதற்கு ஒரு புதிய பொருளை ஒதுக்கியபோது, ​​குறிப்பு நகலெடுக்கப்பட்டது.

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

cat.age += 10;

நிச்சயமாக, பிரதான() முறையில் பூனையின் வயது, smudge.age , மாறவில்லை என்பதை கன்சோலில் பார்க்கலாம். எல்லாவற்றிற்கும் மேலாக, ஸ்மட்ஜ் என்பது ஒரு குறிப்பு மாறி, இது இன்னும் 5 வயதிற்குட்பட்ட பழைய அசல் பொருளைக் குறிக்கிறது, மேலும் அந்த பொருளை நாங்கள் எதுவும் செய்யவில்லை. எங்கள் வயது மாற்றங்கள் அனைத்தும் புதிய பொருளில் செய்யப்பட்டன. எனவே, பொருள்கள் குறிப்பு மூலம் முறைகளுக்கு அனுப்பப்படுகின்றன என்று மாறிவிடும். பொருட்களின் நகல்கள் தானாக உருவாக்கப்படுவதில்லை. நீங்கள் ஒரு பூனை பொருளை ஒரு முறைக்கு அனுப்பி அதன் வயதை மாற்றினால், நீங்கள் அதன் வயதை மாற்றுவீர்கள். ஆனால் மதிப்புகள் மற்றும்/அல்லது அழைப்பு முறைகளை ஒதுக்கும்போது குறிப்பு மாறிகள் நகலெடுக்கப்படுகின்றன! ப்ரிமிடிவ்களை கடந்து செல்வது பற்றி நாம் சொன்னதை இங்கே மீண்டும் கூறுவோம்: " மாற்றம்Int() முறையை அழைத்து , எண்ணை கடக்கும்போதுமாறி x (=15) , இந்த முறையானது x மாறியைப் பெறவில்லை , மாறாக அதன் நகலைப் பெறுகிறது. எனவே, நகலில் செய்யப்படும் மாற்றங்கள் எங்களின் அசல் xஐப் பாதிக்காதுஜாவாவில் (அனுபவம் வாய்ந்த டெவலப்பர்கள் மத்தியில் கூட) வாதங்கள் எவ்வாறு அனுப்பப்படுகின்றன என்பதைப் பற்றி இன்னும் ஒன்றுக்கு மேற்பட்ட முறை வாதிடுவேன். ஆனால், அது எவ்வாறு செயல்படுகிறது என்பதை இப்போது நீங்கள் அறிவீர்கள். பழக்கப்படுத்தி கொள் அல்லது மேம்படுத்திக்கொள்! :) நீங்கள் கற்றுக்கொண்டதை வலுப்படுத்த, எங்கள் ஜாவா பாடத்திட்டத்திலிருந்து வீடியோ பாடத்தைப் பார்க்க பரிந்துரைக்கிறோம்