Mga pamamaraan, ang kanilang mga parameter, pakikipag-ugnayan at labis na karga

Hello ulit! Sa huling lecture, nakilala namin ang mga klase at konstruktor, at natutunan kung paano lumikha ng sarili namin. Ngayon ay titingnan natin ang isang mahalagang bahagi ng mga klase bilang mga pamamaraan. Ang isang pamamaraan ay isang hanay ng mga utos na nagbibigay-daan sa iyong magsagawa ng ilang operasyon sa isang programa. Sa madaling salita, ang isang pamamaraan ay isang function; isang bagay na magagawa ng iyong klase. Sa iba pang mga programming language, ang mga pamamaraan ay madalas na tinatawag na "mga function," ngunit sa Java ang salitang "pamamaraan" ay naging mas popular :) Sa huling lecture, kung naaalala mo, gumawa kami ng mga simpleng pamamaraan para sa klase ng Cat upang ang aming mga pusa ay makapag-meow. at tumalon:

public class Cat {

    String name;
    int age;

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

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

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

        barsik.sayMeow();
        barsik.jump();
    }
}

sayMeow()at jump()mga pamamaraan ng aming klase. Ang resulta ng kanilang trabaho ay ang output sa console:

Мяу!
Прыг-скок!

Ang aming mga pamamaraan ay medyo simple: nagpi-print lang sila ng teksto sa console. Ngunit sa Java, ang mga pamamaraan ay may pangunahing gawain - dapat silang magsagawa ng mga aksyon sa data ng isang bagay . Baguhin ang halaga ng data ng isang bagay, i-transform ito, i-output ito sa console, o gumawa ng iba pa dito. Ang aming mga kasalukuyang pamamaraan ay walang ginagawa sa data ng object Cat. Tingnan natin ang isang mas malinaw na halimbawa:

public class Truck {

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

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

Halimbawa, mayroon kaming klase na kumakatawan sa isang trak - Truck. Ang isang trailer ng trak ay may haba, lapad at taas, at may timbang (kakailanganin ito sa ibang pagkakataon). Sa pamamaraan, getVolume()nagsasagawa kami ng mga kalkulasyon - binago namin ang data ng aming bagay sa isang numero na nagpapahiwatig ng lakas ng tunog (pinarami namin ang haba, lapad at taas). Ito ang bilang na magiging resulta ng pamamaraan. Pakitandaan - sa paglalarawan ng paraan na ito ay nakasulat public int getVolume. Nangangahulugan ito na ang resulta ng pamamaraang ito ay dapat na isang numero sa form int. Kinakalkula namin ang resulta ng pamamaraan, at ngayon ay dapat naming ibalik ito sa aming programa na tinatawag na pamamaraan. Upang ibalik ang resulta ng isang pamamaraan sa Java, ginagamit ang keyword return.

return volume;

Mga parameter ng pamamaraan

Ang mga pamamaraan ay maaaring tumanggap ng mga halaga bilang input, na tinatawag na "parameter ng pamamaraan". Ang aming kasalukuyang pamamaraan getVolume()sa klase Truckay hindi tumatanggap ng anumang mga parameter, kaya subukan nating palawakin ang halimbawa sa mga trak. Gumawa tayo ng bagong klase - BridgeOfficer. Ang isang pulis ay naka-duty sa tulay at sinusuri ang lahat ng dumadaan na trak upang matiyak na ang kanilang mga kargamento ay hindi lalampas sa pinahihintulutang limitasyon sa timbang.

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

Ang pamamaraan checkTruckay tumatagal ng isang parameter bilang input - isang bagay sa trak Truck, at tinutukoy kung papayagan ng opisyal ang trak papunta sa tulay o hindi. Ang lohika sa loob ng pamamaraan ay medyo simple: kung ang bigat ng trak ay lumampas sa maximum na pinapayagan, ang pamamaraan ay babalik false. Kakailanganin mong maghanap ng ibang kalsada :( Kung ang timbang ay mas mababa sa o katumbas ng maximum, maaari kang makapasa, at ang pamamaraan ay babalik true. Kung hindi mo pa rin lubos na nauunawaan ang mga pariralang "bumalik", "paraan ay nagbabalik ng halaga ” - magpahinga muna tayo sa programming at tingnan ito gamit ang isang simpleng halimbawa mula sa totoong buhay sa mundo :) Sabihin nating nagkasakit ka at wala sa trabaho ng ilang araw. Pumunta ka sa departamento ng accounting dala ang iyong sick leave, na dapat mong bayaran. Kung gumuhit kami ng isang pagkakatulad sa mga pamamaraan, kung gayon ang accountant ay may isang pamamaraan paySickLeave()("pay sick leave"). Nagpasa ka ng sertipiko ng sick leave sa pamamaraang ito bilang isang parameter (kung wala ito, hindi gagana ang pamamaraan at wala kang babayaran!). Sa loob ng paraan ng worksheet, ang mga kinakailangang kalkulasyon ay ginawa (ginagamit ito ng accountant upang kalkulahin kung magkano ang dapat bayaran ng kumpanya sa iyo), at ang resulta ng trabaho ay ibinalik sa iyo - isang kabuuan ng pera. Ang programa ay gumagana sa parehong paraan. Tumatawag ito ng isang pamamaraan, nagpapasa ng data doon, at sa wakas ay natatanggap ang resulta. Narito ang pamamaraan main()para sa aming programa 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 number 1! May I pass, officer?");
    boolean canFirstTruckGo = officer.checkTruck(first);
    System.out.println(canFirstTruckGo);

    System.out.println();

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

Gumagawa kami ng dalawang trak na may kargada na 10,000 at 20,000. Kasabay nito, ang maximum na timbang para sa tulay kung saan naka-duty ang opisyal ay 15,000. Ang programa ay tinatawag na pamamaraan officer.checkTruck(first), kinakalkula ng pamamaraan ang lahat at ibinalik ang resulta sa programa - true, at nai-save ito ng program sa variable boolean canFirstTruckGo. Ngayon ay maaari na niyang gawin ang anumang gusto niya dito (tulad mo sa perang natanggap mo mula sa accountant). Sa huli ang code

boolean canFirstTruckGo = officer.checkTruck(first);

bumaba sa

boolean canFirstTruckGo = true;

Isang napakahalagang punto: returnhindi lamang ibinabalik ng operator ang resulta ng pamamaraan, ngunit tinatapos din ang gawain nito ! Ang lahat ng code na nakasulat pagkatapos ng pagbabalik ay hindi isasagawa!

public boolean checkTruck(Truck truck) {

    if (truck.weight > maxWeight) {
        return false;
        System.out.println("Turn around, overweight!");
    } else {
        return true;
        System.out.println("Alright, move on!");
    }
}

Ang mga parirala na sinasabi ng opisyal ay hindi ilalabas sa console, dahil ang pamamaraan ay nagbalik na ng resulta at natapos ang gawain nito! Bumalik ang programa sa punto kung saan tinawag ang pamamaraan. Hindi mo kailangang mag-alala tungkol dito sa iyong sarili - ang Java compiler ay sapat na matalino upang magtapon ng isang error kung susubukan mong magsulat ng code pagkatapos ng return.

Avengers: Options War

May mga sitwasyon kung kailan ang aming programa ay nangangailangan ng ilang mga opsyon para sa kung paano gumagana ang isang pamamaraan. Bakit hindi tayo gumawa ng sarili nating artificial intelligence? Ang Amazon ay may Alexa, ang Yandex ay may Alice, kaya bakit tayo mas masahol pa? :) Sa pelikula tungkol sa Iron Man, si Tony Stark ay lumikha ng kanyang sariling natatanging artificial intelligence - JARVIS Magbigay pugay tayo sa kahanga-hangang karakter at pangalanan ang ating AI sa kanyang karangalan :) Ang unang bagay na dapat nating ituro kay Jarvis - batiin ang mga taong pumapasok sa silid (kakaiba kung ang gayong mahusay na talino ay naging walang galang).

public class Jarvis {

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

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

Output ng console:

Добрый вечер, Тони Старк, How ваши дела?

Malaki! Marunong bumati si Jarvis sa papasok. Kadalasan, siyempre, ito ang magiging may-ari niya - si Tony Stark. Ngunit hindi siya maaaring dumating nang mag-isa! At ang aming pamamaraan sayHi()ay tumatagal lamang ng isang argumento bilang input. At, nang naaayon, isa lamang sa mga darating ang magagawa niyang batiin, at hindi papansinin ang isa pa. Hindi masyadong magalang, sang-ayon? :/ Sa kasong ito, upang malutas ang problema, maaari lamang tayong magsulat ng 2 pamamaraan sa klase na may parehong pangalan, ngunit may iba't ibang mga parameter:

public class Jarvis {

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

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

Ito ay tinatawag na method overloading . Ang overloading ay nagbibigay-daan sa aming programa na maging mas flexible at tumanggap ng iba't ibang opsyon sa trabaho. Suriin natin kung paano ito gumagana:

public class Jarvis {

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

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

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

Output ng console:

Добрый вечер, Тони Старк, How ваши дела?
Добрый вечер, Тони Старк, Капитан Америка, How ваши дела?

Mahusay, gumana ang parehong mga pagpipilian :) Gayunpaman, hindi namin nalutas ang problema! Paano kung may tatlong bisita? Siyempre, maaari naming i-overload muli ang paraan sayHi()upang tanggapin ang mga pangalan ng tatlong bisita. Ngunit maaaring mayroong 4 o 5 sa kanila. At iba pa ang ad infinitum. Mayroon bang ibang paraan upang turuan si Jarvis na magtrabaho sa anumang bilang ng mga pangalan, nang walang isang milyong overload na pamamaraan sayHi()? :/ Syempre meron! Kung hindi, ang Java ba ang pinakasikat na programming language sa mundo? ;)

public void sayHi(String...names) {

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

Ang record ( String...names) na ipinasa bilang isang parameter ay nagbibigay-daan sa amin na ipahiwatig na ang isang tiyak na bilang ng mga string ay ipinasa sa pamamaraan. Hindi namin tinukoy nang maaga kung ilan ang dapat, kaya ang pagpapatakbo ng aming pamamaraan ngayon ay nagiging mas nababaluktot:

public class Jarvis {

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

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

Output ng console:

Добрый вечер, Тони Старк, How ваши дела?
Добрый вечер, Капитан Америка, How ваши дела?
Добрый вечер, Черная Вдова, How ваши дела?
Добрый вечер, Халк, How ваши дела?

Ang ilan sa mga code dito ay hindi pamilyar sa iyo, ngunit huwag pansinin iyon. Ang kakanyahan nito ay simple - ang pamamaraan ay dumaan sa lahat ng mga pangalan at binabati ang bawat isa sa mga bisita! Bukod dito, gagana ito para sa anumang bilang ng mga inilipat na linya! Dalawa, sampu, kahit isang libo - ang pamamaraan ay gagana nang mapagkakatiwalaan sa anumang bilang ng mga bisita. Higit na mas maginhawa kaysa sa paggawa ng mga overload para sa lahat ng posibleng opsyon, hindi ka ba sumasang-ayon? :) Isa pang mahalagang punto: ang pagkakasunud-sunod ng mga argumento ay mahalaga! Sabihin nating ang aming pamamaraan ay tumatagal ng isang string at isang numero bilang input:

public class Man {

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

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

Kung ang isang paraan ng sayYourAgeklase Manay tumatagal ng isang string at isang numero bilang input, ito ang pagkakasunud-sunod kung saan kailangan nilang maipasa sa programa! Kung ipapasa namin ang mga ito sa ibang pagkakasunud-sunod, ang compiler ay magtapon ng isang error at hindi masasabi ng tao ang kanyang edad. Sa pamamagitan ng paraan, ang mga konstruktor na aming natalakay sa huling panayam ay mga pamamaraan din! Maaari din silang ma-overload (lumikha ng ilang mga konstruktor na may iba't ibang hanay ng mga argumento) at para sa kanila ang pagkakasunud-sunod ng pagpasa ng mga argumento ay mahalaga din sa panimula. Mga totoong pamamaraan! :)

At muli tungkol sa mga parameter

Oo, oo, hindi pa tayo tapos sa kanila :) Napakahalaga ng paksang isasaalang-alang natin ngayon. Mayroong 90% na pagkakataon na magtanong sila tungkol dito sa lahat ng iyong mga panayam sa hinaharap! Pag-uusapan natin ang tungkol sa pagpasa ng mga parameter sa mga pamamaraan. Tingnan natin ang isang simpleng halimbawa:

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 = 2020;

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

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

Ang time machine ay may dalawang pamamaraan. Parehong kumukuha bilang input ng isang numero na kumakatawan sa kasalukuyang taon at alinman sa pagtaas o pagbaba ng halaga (depende sa kung gusto nating bumalik sa nakaraan o sa hinaharap). Ngunit, tulad ng makikita mula sa output ng console, ang pamamaraan ay hindi gumana! Output ng console:

Какой сейчас год?
2020
А сейчас?
2020

Nagpasa kami ng variable currentYearsa method goToPast(), ngunit hindi nagbago ang halaga nito. Tulad noong 2020, nananatili itong ganoon. Pero bakit? :/ Dahil ang mga primitive sa Java ay ipinapasa sa mga pamamaraan ayon sa halaga. Ano ang ibig sabihin nito? Kapag tumawag tayo ng isang pamamaraan goToPast()at ipinasa ang ating variable doon int currentYear = 2020, hindi ang variable mismo ang pumapasok sa pamamaraan currentYear, ngunit isang kopya nito . Ang halaga ng kopyang ito, siyempre, ay katumbas din ng 2020, ngunit ang lahat ng pagbabagong nagaganap sa kopya ay hindi sa anumang paraan makakaapekto sa aming orihinal na variablecurrentYear ! Gawin nating mas verbose ang ating code at tingnan kung ano ang mangyayari sa currentYear:

public class TimeMachine {

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

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

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

        System.out.println("What is the year at the very beginning of the program?");
        System.out.println(currentYear);

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

Output ng console:

Какой год в самом начале работы программы?
2020
Метод goToPast начал работу!
Значение currentYear внутри метода goToPast (в начале) = 2020
Значение currentYear внутри метода goToPast (в конце) = 2010
А сейчас Howой год?
2020

Ito ay malinaw na nagpapakita na ang variable na ipinasa sa pamamaraan goToPast()ay isang kopya lamang currentYear. At ang pagbabago ng kopya ay walang epekto sa kahulugan ng "orihinal". Ang " passing by reference " ay may eksaktong kabaligtaran na kahulugan. Magsanay tayo sa mga pusa! Ibig kong sabihin, tingnan natin kung ano ang hitsura ng pagdaan sa link gamit ang mga pusa bilang isang halimbawa :)

public class Cat {

    int age;

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

Ngayon, sa tulong ng aming time machine, ilulunsad namin ang Barsik, ang kauna-unahang cat-time traveler sa mundo, sa nakaraan at hinaharap! Baguhin natin ang klase TimeMachineupang ang makina ay gumana sa mga bagay Cat;

public class TimeMachine {

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

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

Binabago na ngayon ng mga pamamaraan hindi lamang ang naipasa na numero, ngunit ang field ageng isang partikular na bagay Cat. Sa kaso ng mga primitive, gaya ng naaalala mo, hindi kami nagtagumpay: hindi nagbago ang orihinal na numero. Tingnan natin kung ano ang mangyayari dito!

public static void main(String[] args) {

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

    System.out.println("How old is Barsik at the very beginning of the program?");
    System.out.println(barsik.age);

    timeMachine.goToFuture(barsik);
    System.out.println("And now?");
    System.out.println(barsik.age);

    System.out.println("Firs-sticks! Barsik has aged 10 years! Drive back quickly!");
    timeMachine.goToPast(barsik);
    System.out.println("Did it work? Have we returned the cat to its original age?");
    System.out.println(barsik.age);
}

Output ng console:

Сколько лет Барсику в самом начале работы программы?
5
А теперь?
15
Елки-палки! Барсик постарел на 10 лет! Живо гони назад!
Получилось? Мы вернули коту его изначальный возраст?
5

Wow! Ngayon ang pamamaraan ay gumana nang iba: ang aming pusa ay biglang tumanda, at pagkatapos ay mukhang mas bata muli! :) Subukan nating alamin kung bakit. Hindi tulad ng halimbawa na may mga primitive, sa kaso ng mga bagay, ang isang sanggunian sa bagay ay ipinasa sa pamamaraan. Ang isang sanggunian sa aming orihinal na bagay ay ipinasa goToFuture(barsik)sa mga pamamaraan . Samakatuwid, kapag binago natin ang inside method , ina-access natin ang mismong memory area kung saan naka-imbak ang ating object. Ito ay isang link sa parehong Barsik na ginawa namin sa pinakadulo simula. Ito ay tinatawag na "passing by reference"! Gayunpaman, sa mga link na ito ang lahat ay hindi gaanong simple :) Subukan nating baguhin ang ating halimbawa: goToPast(barsik)barsikbarsik.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 barsik = new Cat(5);

        System.out.println("How old is Barsik at the very beginning of the program?");
        System.out.println(barsik.age);

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

        System.out.println("And if you try in the past?");
        timeMachine.goToPast(barsik);
        System.out.println(barsik.age);
    }
}

Output ng console:

Сколько лет Барсику в самом начале работы программы?
5
Барсик отправился в будущее! Его возраст изменился?
5
А если попробовать в прошлое?
5

Hindi na gumana ulit! O_O Alamin natin kung ano ang nangyari :) Ito ay tungkol sa mga pamamaraan goToPast/ goToFutureat ang mekanika ng kung paano gumagana ang mga link. Ngayon pansin!Ang puntong ito ang pinakamahalaga sa pag-unawa kung paano gumagana ang mga link at pamamaraan. Sa katunayan, kapag tinawag namin ang isang pamamaraan, goToFuture(Cat cat)hindi ang object reference mismo ang ipinapasa dito cat, ngunit isang kopya ng reference na ito. Iyon ay, kapag ipinasa namin ang isang bagay sa isang pamamaraan, mayroong dalawang sanggunian sa bagay na ito . Napakahalaga nito para maunawaan kung ano ang nangyayari. Pagkatapos ng lahat, ito ang dahilan kung bakit hindi binago ng aming huling halimbawa ang edad ng pusa. Sa nakaraang halimbawa sa pagbabago ng edad, kinuha lang namin ang naipasa na sanggunian sa loob ng pamamaraan goToFuture(), natagpuan ang bagay sa memorya gamit ito at binago ang edad nito ( cat.age += 10). Ngayon sa loob ng pamamaraan goToFuture()lumikha kami ng isang bagong bagay

(cat = new Cat(cat.age)),

at ang parehong link ng kopya na ipinasa sa pamamaraan ay nakatalaga sa bagay na ito. Ang resulta:

• Ang unang link ( Cat barsik = new Cat(5)) ay tumuturo sa orihinal na pusa (na may edad na 5)
• Pagkatapos naming ipasa ang variable catsa pamamaraan goToPast(Cat cat)at italaga ito sa isang bagong bagay, ang sanggunian ay kinopya.

Pagkatapos nito, mayroon na tayong huling sitwasyon: dalawang link ang tumuturo sa dalawang magkaibang bagay. Ngunit binago namin ang edad ng isa lamang sa kanila - ang nilikha namin sa loob ng pamamaraan.

cat.age += 10;

At natural, kapag inilabas natin ito main()sa console sa pamamaraan barsik.age, nakikita natin na hindi nagbago ang edad nito. Pagkatapos ng lahat barsik, ito ay isang reference variable na tumuturo pa rin sa luma, orihinal na bagay na may edad na 5, kung saan walang nangyari. Ang lahat ng aming mga manipulasyon na may edad ay ginanap sa isang bagong bagay. Kaya, lumalabas na ang mga bagay ay ipinasa sa mga pamamaraan sa pamamagitan ng sanggunian. Ang mga kopya ng mga bagay ay hindi kailanman awtomatikong nagagawa. Kung ipinasa mo ang isang bagay ng pusa sa isang pamamaraan at binago mo ang edad nito, matagumpay itong mababago. Ngunit ang mga halaga ng mga sanggunian na variable ay kinopya kapag nagtatalaga at/o mga pamamaraan ng pagtawag! Ulitin natin dito ang talata tungkol sa pagpasa ng mga primitive: "Kapag tumawag tayo ng isang pamamaraan changeInt()at ipinasa ang ating variable doon int x = 15, hindi ang variable mismo ang pumapasok sa pamamaraan x, ngunit ang kopya nito . Pagkatapos ng lahat, ang lahat ng mga pagbabago na nangyayari sa kopya ay hindi makakaapekto sa aming orihinal na variable sa anumang paraan x." Sa pagkopya ng mga link, lahat ay gumagana nang eksakto pareho! Ipasa mo ang object ng pusa sa pamamaraan. Kung gumawa ka ng isang bagay sa pusa mismo (iyon ay, kasama ang bagay sa memorya), lahat ng mga pagbabago ay matagumpay na dadaan - mayroon lamang kaming isang bagay at mayroon pa rin ito. Ngunit kung sa loob ng isang pamamaraan ay lumikha ka ng isang bagong bagay at i-save ito sa isang reference variable, na isang parameter ng pamamaraan, mula ngayon mayroon kaming dalawang bagay at dalawang reference variable. Iyon lang! Hindi ganoon kadali, maaaring kailanganin mong mag-lecture nang ilang beses. Ngunit ang pangunahing bagay ay natutunan mo ang napakaimportanteng paksang ito. Madalas kang makakatagpo ng mga hindi pagkakaunawaan (kahit sa mga may karanasang developer) tungkol sa kung paano ipinapasa ang mga argumento sa Java. Ngayon alam mo na kung paano ito gumagana. Ipagpatuloy mo yan! :)