Mga pamamaraan sa Java

Hello ulit! Sa huling aralin nakilala namin ang mga klase at konstruktor, at natutunan kung paano lumikha ng sarili namin. Ngayon ay mas makikilala natin ang Java Methods, isang mahalagang bahagi ng mga klase. Ang Mga Paraan sa Java ay isang hanay ng mga utos na nagbibigay-daan sa iyong magsagawa ng isang partikular na operasyon sa isang programa. Sa madaling salita, ang isang pamamaraan ay isang function; isang bagay na kayang gawin 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 mas karaniwan. :) Kung natatandaan mo, sa huling aralin gumawa kami ng mga simpleng pamamaraan para sa klase ng Cat , upang ang aming mga pusa ay makapagsabi ng meow at tumalon:

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() at jump() ay mga pamamaraan ng aming klase. At ang pagpapatakbo ng mga pamamaraang ito ay nagreresulta sa sumusunod na output ng console:

Meow!
Pounce!

Ang aming mga pamamaraan ay medyo simple: naglalabas lamang sila ng teksto sa console. Ngunit sa Java, ang mga pamamaraan ay may mahalagang gawain: nagsasagawa sila ng mga aksyon sa data ng isang bagay. Binabago nila ang data ng bagay, binabago ito, ipinapakita ito, at gumagawa ng iba pang bagay dito. Ang aming mga kasalukuyang pamamaraan ay walang ginagawa sa data ng object ng Cat . Tingnan natin ang isang mas nakapagpapakitang halimbawa:

public class Truck {

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

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

Halimbawa, dito mayroon kaming klase na kumakatawan sa isang Truck . Ang semi truck ay may haba, lapad, taas, at timbang (na kakailanganin natin mamaya). Sa pamamaraang getVolume() , nagsasagawa kami ng mga kalkulasyon, na nagko-convert ng data ng aming object sa isang numero na kumakatawan sa volume nito (minu-multiply namin ang haba, lapad, at taas). Ang bilang na ito ang magiging resulta ng pamamaraan. Tandaan na ang deklarasyon ng pamamaraan ay nakasulat bilang public int getVolume . Nangangahulugan iyon na ang pamamaraang ito ay dapat magbalik ng int . Kinakalkula namin ang halaga ng pagbabalik ng pamamaraan, at ngayon ay dapat naming ibalik ito sa programa na tumawag sa aming pamamaraan. Upang ibalik ang resulta ng isang pamamaraan sa Java, ginagamit namin ang keyword return. dami ng pagbabalik;

Mga Parameter ng Pamamaraan ng Java

Maaari naming ipasa ang mga halaga na tinatawag na "mga argumento" sa isang paraan kapag tinatawag ito. Kasama sa deklarasyon ng isang paraan ang isang listahan ng mga variable na nagsasabi sa amin ng uri at pagkakasunud-sunod ng mga variable na maaaring tanggapin ng pamamaraan. Ang listahang ito ay tinatawag na "parameter ng pamamaraan". Ang pamamaraang getVolume() ng aming Truck class ay hindi kasalukuyang tumukoy ng anumang mga parameter, kaya't subukan nating palawigin ang aming halimbawa ng trak. Lumikha ng bagong klase na tinatawag na BridgeOfficer . Ito ay isang pulis na naka-duty sa isang tulay, na sinusuri ang lahat ng dumadaan na trak upang makita kung ang kanilang kargada ay lumampas sa pinapayagang 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 paraan ng checkTruck ay tumatanggap ng isang argumento, isang Truck object, at tinutukoy kung papayagan o hindi ng opisyal ang trak sa tulay. Sa loob ng pamamaraan, ang lohika ay sapat na simple: kung ang bigat ng trak ay lumampas sa maximum na pinapayagan, ang pamamaraan ay nagbabalik ng false . Kakailanganin nitong maghanap ng isa pang kalsada :( Kung ang timbang ay mas mababa sa o katumbas ng maximum, maaari itong pumasa, at ang pamamaraan ay nagbabalik ng totoo. Kung hindi mo pa lubos na nauunawaan ang mga pariralang "return" o "the method returns a value", magpahinga muna tayo sa programming at isaalang-alang ang mga ito gamit ang isang simpleng halimbawa mula sa totoong buhay. :) Sabihin nating magkakasakit ka at manatili sa bahay mula sa trabaho ng ilang araw. Pumunta ka sa accounting department dala ang tala ng iyong doktor, dahil ang sick leave ay dapat bayaran. Kung ihahambing natin ang sitwasyong ito sa mga pamamaraan, ang accountant ay mayroong paySickLeave()paraan. Nagpasa ka ng tala ng doktor bilang argumento sa pamamaraang ito (kung wala ito, hindi gagana ang pamamaraan at hindi ka mababayaran!). Pagkatapos ang mga kinakailangang kalkulasyon ay ginawa sa loob ng pamamaraan gamit ang iyong tala (ginagamit ito ng accountant upang kalkulahin kung magkano ang dapat bayaran ng kumpanya sa iyo), at ang resulta ng iyong trabaho (isang halaga ng pera) ay ibabalik sa iyo. Ang aming programa ay gumagana sa katulad na paraan. Tumatawag ito ng isang pamamaraan, nagpapasa ng data dito, at sa huli ay tumatanggap ng resulta. Narito ang pangunahing() pamamaraan ng aming BridgeOfficer program :

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

Gumagawa kami ng dalawang trak na may load na 10,000 at 20,000. At ang tulay na pinagtatrabahuan ng opisyal ay may pinakamataas na timbang na 15,000. Tinatawag ng programa ang officer.checkTruck(first) method. Ang pamamaraan ay kinakalkula ang lahat at pagkatapos ay nagbabalik ng true , kung saan ang programa ay nagse-save sa boolean variable na canFirstTruckGo . Ngayon ay maaari mong gawin ang anumang gusto mo dito (tulad ng magagawa mo sa perang ibinigay sa iyo ng accountant). Sa pagtatapos ng araw, ang code

boolean canFirstTruckGo = officer.checkTruck(first);

Nagtatapos sa

boolean canFirstTruckGo =  true;

Narito ang isang napakahalagang punto: hindi lang ibinabalik ng return statement ang return value ng method, pinipigilan din nito ang pagtakbo ng method! Ang anumang code na darating pagkatapos ng return statement ay hindi isasagawa!

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!");
    }
}

Ang mga komento ng opisyal ay hindi ipapakita, dahil ang pamamaraan ay nagbalik na ng resulta at natapos na! Ang programa ay bumalik sa lugar kung saan tinawag ang pamamaraan. Hindi mo kailangang bantayan ito: ang Java compiler ay sapat na matalino upang makabuo ng isang error kapag sinubukan mong magsulat ng code pagkatapos ng isang return statement.

Avengers: Parameter War

May mga sitwasyon kung kailan gugustuhin natin ang ilang paraan ng pagtawag sa isang paraan. Bakit hindi lumikha ng sarili nating artificial intelligence? Ang Amazon ay may Alexa, ang Apple ay may Siri, kaya bakit hindi tayo magkakaroon nito? :) Sa pelikulang Iron Man, lumikha si Tony Stark ng sarili niyang hindi kapani-paniwalang artificial intelligence, si Jarvis. Magbigay pugay tayo sa kahanga-hangang karakter na iyon at pangalanan ang ating AI sa kanyang karangalan. :) Ang unang bagay na kailangan nating gawin ay turuan si Jarvis na kumustahin ang mga taong pumapasok sa silid (magiging kakaiba kung ang gayong kamangha-manghang talino ay naging walang galang).

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

Output ng console:

Good evening, Tony Stark. How are you?

Napakahusay! Nagagawa na ni Jarvis na tanggapin ang mga bisita. Siyempre, mas madalas kaysa sa hindi ito ang kanyang master, si Tony Stark. Pero paano kung hindi siya dumating mag-isa! Ang aming sayHi() na pamamaraan ay tumatanggap lamang ng isang argumento. At kaya maaari lamang nitong batiin ang isang tao na pumapasok sa silid, at hindi papansinin ang isa pa. Hindi masyadong magalang, hindi ka ba sumasang-ayon? :/

Overloading ng Java Method

Sa kasong ito, malulutas natin ang problema sa pamamagitan lamang ng pagsulat ng 2 pamamaraan na may parehong pangalan, ngunit magkaibang mga parameter:

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?");
    }
}

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

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

Output ng console:

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

Mahusay, gumana ang parehong bersyon. :) Ngunit hindi namin nalutas ang problema! Paano kung may tatlong bisita? Siyempre, maaari naming i-overload muli ang paraan ng sayHi() , nang sa gayon ay tumanggap ito ng tatlong pangalan ng bisita. Ngunit maaaring mayroong 4 o 5. Hanggang sa infinity. Wala bang mas mahusay na paraan upang turuan si Jarvis na pangasiwaan ang anumang bilang ng mga pangalan, nang hindi na-overload ang paraan ng sayHi() nang isang milyong beses? :/ Syempre meron! Kung wala, sa tingin mo ba ang Java ang magiging pinakasikat na programming language sa mundo? ;)

public void sayHi(String...names) {

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

Kapag ( String... names ) ay ginamit bilang isang parameter, ito ay nagpapahiwatig na ang isang koleksyon ng mga Strings ay ipapasa sa pamamaraan. Hindi namin kailangang tukuyin nang maaga kung ilan ang magkakaroon, kaya ngayon ang aming pamamaraan ay mas nababaluktot:

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

Output ng console:

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?

Ang ilang code dito ay hindi pamilyar sa iyo, ngunit huwag mag-alala tungkol dito. Ito ay simple sa core nito: ang pamamaraan ay tumatagal ng bawat pangalan at binabati ang bawat bisita! Dagdag pa, gagana ito sa anumang bilang ng mga naipasa na mga string! Dalawa, sampu, kahit isang libo—ang pamamaraan ay gagana nang maayos sa anumang bilang ng mga bisita. Paraan na mas maginhawa kaysa sa labis na karga ng pamamaraan para sa lahat ng mga posibilidad, sa tingin mo ba? :) Narito ang 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:

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

Kung ang paraan ng sayYourAge ng klase ng Tao ay tumatagal ng isang string at isang numero bilang mga input, kung gayon ang programa ay dapat na ipasa ang mga ito sa partikular na pagkakasunud-sunod na iyon! Kung ipapasa natin ang mga ito sa ibang pagkakasunud-sunod, bubuo ng error ang compiler at hindi masasabi ng tao ang kanyang edad. Sa pamamagitan ng paraan, ang mga konstruktor, na aming tinalakay sa huling aralin, ay mga pamamaraan din! Maaari mo ring overload ang mga ito (ibig sabihin, lumikha ng ilang mga konstruktor na may iba't ibang hanay ng mga parameter) at ang pagkakasunud-sunod ng mga naipasa na argumento ay sa panimula ay mahalaga din para sa kanila. Ang mga ito ay tunay na pamamaraan! :)

Muli tungkol sa mga parameter

Yep, sorry, hindi pa namin sila tapos. :) Napakahalaga ng topic na pag-aaralan natin ngayon. Mayroong 90% na pagkakataon na tatanungin ka tungkol dito sa bawat panayam sa hinaharap! Pag-usapan natin ang pagpasa ng mga argumento sa mga pamamaraan. Isaalang-alang 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 = 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);
    }
}

Ang time machine ay may dalawang paraan. Pareho nilang kinukuha ang bilang na kumakatawan sa kasalukuyang taon bilang input, at alinman sa pagtaas o pagbaba ng halaga nito (depende sa kung gusto nating pumunta sa nakaraan o sa hinaharap). Ngunit, tulad ng nakikita mo mula sa output ng console, ang pamamaraan ay hindi gumagana! Output ng console:

What year is it?
2018
How about now?
2018

Ipinasa namin ang currentYear variable sa goToPast() method, ngunit hindi nagbago ang value nito. Noong 2018 kami, at dito kami nanatili. Pero bakit? :/ Dahil ang mga primitive sa Java ay ipinapasa sa mga pamamaraan ayon sa halaga. Anong ibig sabihin niyan? Kapag tinawag namin ang goToPast() na pamamaraan at ipinasa ang int variable currentYear (=2018) dito, hindi nakukuha ng pamamaraan ang currentYear variable mismo, ngunit isang kopya nito. Siyempre, ang halaga ng kopyang ito ay 2018 din, ngunit ang anumang mga pagbabago sa kopya ay hindi makakaapekto sa aming orihinal na kasalukuyangYear variable sa anumang paraan! Gawin nating mas malinaw ang ating code at panoorin 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 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);
    }
}

Output ng console:

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

Malinaw nitong ipinapakita na ang variable na ipinasa sa pamamaraang goToPast() ay isang kopya lamang ng currentYear . At ang pagpapalit ng kopya ay hindi makakaapekto sa "orihinal" na halaga. Ang ibig sabihin ng "Pass by reference" ay ang eksaktong kabaligtaran. Magsanay tayo sa mga pusa! Ibig kong sabihin, tingnan natin kung ano ang hitsura ng passing by reference gamit ang isang halimbawa ng pusa. :)

public class Cat {

    int age;

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

Ngayon sa tulong ng aming time machine ipapadala namin ang Smudge , ang unang naglalakbay na pusa sa mundo, sa nakaraan at sa hinaharap! Baguhin natin ang klase ng TimeMachine upang gumana ito sa mga bagay na Cat ;

public class TimeMachine {

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

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

Ngayon ang mga pamamaraan ay hindi lamang binabago ang naipasa na numero. Sa halip, binabago nila ang partikular na field ng edad ni Cat . Matatandaan mo na hindi ito gumana para sa amin sa mga primitive, dahil hindi nagbago ang orihinal na numero. Tingnan natin kung ano ang mangyayari!

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

Output ng console:

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

Wow! Ngayon ang pamamaraan ay gumawa ng ibang bagay: ang aming pusa ay tumanda nang husto, ngunit pagkatapos ay naging bata muli! :) Subukan nating alamin kung bakit. Hindi tulad ng halimbawa na may mga primitive, kapag ang mga bagay ay ipinasa sa isang pamamaraan, sila ay ipinasa sa pamamagitan ng sanggunian. Ang isang reference sa orihinal na smudge object ay ipinasa sa changeAge() na paraan. Kaya, kapag binago namin ang smudge.age sa loob ng pamamaraan, tinutukoy namin ang parehong lugar ng memorya kung saan naka-imbak ang aming bagay. Ito ay isang reference sa parehong Smudge na ginawa namin sa simula. Ito ay tinatawag na "passing by reference"! Gayunpaman, hindi lahat ng may mga sanggunian ay ganoon kadali. :) Subukan nating baguhin ang ating halimbawa:

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

Output ng console:

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

Hindi na ito gumana ulit! О_О Alamin natin kung ano ang nangyari. :) May kinalaman ito sa mga pamamaraan ng goToPast / goToFuture at kung paano gumagana ang mga sanggunian. Ngayon, ang iyong pansin, mangyaring! Ito ang pinakamahalagang bagay na dapat maunawaan kung paano gumagana ang mga sanggunian at pamamaraan. Ang katotohanan ay, kapag tinawag natin ang pamamaraang goToFuture(Cat cat) , ito ay isang kopya ng reference sa object ng pusa ang naipapasa, hindi ang reference mismo. Kaya, kapag ipinasa namin ang isang bagay sa isang pamamaraan, mayroong dalawang sanggunian sa bagay. Napakahalaga nito para maunawaan kung ano ang nangyayari. Ito ang eksaktong dahilan kung bakit hindi nagbago ang edad ng pusa sa aming huling halimbawa. Sa nakaraang halimbawa, kapag binabago ang edad, kinuha lang namin ang reference na ipinasa sa goToFuture()paraan, at ginamit ito upang mahanap ang bagay sa memorya at baguhin ang edad nito ( cat.age += 10 ). Ngunit ngayon, sa loob ng pamamaraang goToFuture() , gumagawa kami ng bagong object ( cat = new Cat(cat.age) ), at ang object na ito ay itinalaga ng parehong reference na kopya na ipinasa sa pamamaraan. Ang resulta:

• Ang unang sanggunian ( Cat smudge = bagong Pusa (5) ) ay tumuturo sa orihinal na pusa (na may edad na 5)
• Pagkatapos noon, kapag naipasa namin ang variable ng pusa ang goToPast() method at itinalaga ito ng bagong object, kinopya ang reference.

At ito ang nagdala sa amin sa huling kinalabasan: dalawang sanggunian na tumuturo sa dalawang magkaibang bagay. Ngunit binago lamang namin ang edad ng isa sa kanila (ang nilikha sa loob ng pamamaraan).

cat.age += 10;

At siyempre, sa main() na paraan makikita natin sa console na ang edad ng pusa, smudge.age , ay hindi nagbago. Pagkatapos ng lahat, ang smudge ay isang reference na variable na tumuturo pa rin sa luma, orihinal na bagay na may edad na 5, at wala kaming ginawa sa bagay na iyon. Ang lahat ng aming mga pagbabago sa edad ay isinagawa sa 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 ipapasa mo ang isang bagay ng pusa sa isang pamamaraan at babaguhin ang edad nito, babaguhin mo ang edad nito. Ngunit ang mga reference na variable ay kinopya kapag nagtatalaga ng mga halaga at/o mga paraan ng pagtawag! Ulitin natin dito ang sinabi natin tungkol sa pagpasa ng mga primitive: "Kapag tinawag natin ang changeInt() na paraan at ipasa ang intvariable x (=15) , hindi nakukuha ng pamamaraan ang x variable mismo, sa halip ay isang kopya nito. Samakatuwid, ang anumang mga pagbabagong ginawa sa kopya ay hindi makakaapekto sa aming orihinal na xMagtatapos pa rin ang pagtatalo ng higit sa isang beses tungkol sa kung paano ipinapasa ang mga argumento sa Java (kahit sa mga may karanasang developer). Ngunit, ngayon alam mo nang eksakto kung paano ito gumagana. Ipagpatuloy mo yan! :) Upang palakasin ang iyong natutunan, iminumungkahi naming manood ka ng isang video lesson mula sa aming Java Course