Hi! Alam mo na ang tungkol sa paggawa ng sarili mong mga klase na may mga field at pamamaraan. Ngayon ay tatalakayin natin ang mga pamamaraan.
Siyempre, nagawa na namin ito nang higit sa isang beses sa aming mga aralin, ngunit higit na nasasakupan namin ang mga pangkalahatan. Ngayon, hihimayin natin ang mga pamamaraan, at pag-aaralan kung ano ang ginawa ng mga ito, ang iba't ibang paraan upang likhain ang mga ito, at kung paano pamahalaan ang lahat ng ito. :) Tara na!
Pamamaraan ng deklarasyon
Ang lahat ng code na tumutukoy sa isang pamamaraan ay tinatawag na isang paraan ng deklarasyon . Ang pangkalahatang anyo ng deklarasyon ng pamamaraan ay maaaring ilarawan tulad ng sumusunod:
access modifier, return type, method name (parameter list) {
// method body
}
Bilang mga halimbawa, tingnan ang mga deklarasyon ng iba't ibang pamamaraan ng Dogklase.
public class Dog {
String name;
public Dog(String name) {
this.name = name;
}
public static void main(String[] args) {
Dog max = new Dog("Max");
max.woof();
}
public void woof() {
System.out.println("A dog named " + name + " says \"Woof, woof!\"");
}
public void run(int distanceInFeet) {
System.out.println("A dog named " + name + " ran " + distanceInFeet + " feet!");
}
public String getName() {
return name;
}
}
1. Access modifier
Ang access modifier ay palaging unang ipinahiwatig. Lahat ng Dogmga pamamaraan ng klase ay minarkahan ng pampublikong modifier. Nangangahulugan ito na maaari nating tawagan sila mula sa anumang iba pang klase:
public class Main {
public static void main(String[] args) {
Dog butch = new Dog("Butch");
butch.run(100);
}
}
Tulad ng nakikita mo, ang Dogmga pamamaraan ng klase ay madaling ma-access sa Mainklase. Posible ito dahil sa pampublikong modifier. Sa Java, mayroong iba pang mga modifier. Hindi lahat ng mga ito ay nagpapahintulot na gamitin ang mga pamamaraan sa ibang mga klase. Pag-uusapan natin sila sa iba pang mga aralin. Ang pangunahing bagay na dapat tandaan ay kung ano ang responsable para sa modifier: kung ang isang pamamaraan ay naa-access sa ibang mga klase :)
2. static na keyword
Ang isa sa mga Dogpamamaraan, main(), ay minarkahan ng keyword na static . Bahagi rin ito ng deklarasyon ng pamamaraan, at alam na natin ang kahulugan nito. Hindi namin ito binanggit sa template ng deklarasyon ng pamamaraan na ibinigay sa simula ng aralin, dahil ito ay opsyonal. Kung ito ay tinukoy, dapat itong dumating pagkatapos ng access modifier. Tandaan na sa mga kamakailang aralin ay pinag-usapan natin ang mga static (class) na variable? Kapag inilapat sa mga pamamaraan, ang keyword na ito ay may halos parehong kahulugan. Kung ang isang pamamaraan ay static , maaari itong magamit nang walang reference sa isang partikular na bagay ng klase. At sa katunayan, hindi mo kailangan ng isang Dogbagay upang patakbuhin ang static main()na pamamaraan saDogklase. Ito ay tatakbo nang maayos nang walang isa. Kung ang pamamaraang ito ay hindi static, kailangan muna nating lumikha ng isang bagay upang patakbuhin ito.
3. Ibalik ang halaga
Kung ang aming pamamaraan ay dapat magbalik ng isang bagay, pagkatapos ay tinukoy namin ang uri ng halaga ng pagbabalik. Ito ay maliwanag mula sa halimbawa ng getName()getter:
public String getName() {
return name;
}
Nagbabalik ito ng isang Stringbagay. Kung ang isang pamamaraan ay walang ibinalik na anuman, ang keyword na walang bisa ay gagamitin sa halip, tulad ng sa woof()pamamaraan:
public void woof() {
System.out.println("A dog named " + name + " says \"Woof, woof!\"");
}
Mga pamamaraan na may parehong pangalan
May mga sitwasyon kung kailan gugustuhin namin ang ilang iba't ibang paraan upang tumawag sa isang pamamaraan. 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: Magandang gabi, Tony Stark. Kamusta ka? Napakahusay! Nagagawa na ni Jarvis na tanggapin ang mga bisita. Siyempre, mas madalas kaysa sa kanyang master, si Tony Stark. Pero paano kung hindi siya dumating mag-isa! Ngunit ang aming sayHi()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, sumang-ayon? :/ 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: Magandang gabi, Tony Stark. Kamusta ka? Magandang gabi, Tony Stark at Captain America. Kamusta ka? Mahusay, gumana ang parehong bersyon. :) Ngunit hindi namin nalutas ang problema! Paano kung may tatlong bisita? Maaari naming, siyempre, i-overload sayHi()muli ang pamamaraan, upang matanggap nito ang 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 sayHi()pamamaraan ng isang milyong beses()? :/ Syempre meron! Kung wala, sa tingin mo ba ang Java ang magiging pinakasikat na programming language sa mundo? ;)
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");
System.out.println();
jarvis.sayHi("Tony Stark", "Captain America");
}
}
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: Magandang gabi, Tony Stark. Kamusta ka? Magandang gabi, Captain America. Kamusta ka? Magandang gabi, Black Widow. Kamusta ka? Magandang gabi, Hulk. Kamusta ka? Sa loob ng pamamaraan, inuulit namin ang lahat ng mga argumento at ipinapakita ang mga pariralang naka-format na may mga pangalan. Dito ginagamit namin ang isang pinasimple for-eachna loop (na nakita mo na dati). Ito ay perpekto dito, dahil ang ( String... names ) notation ay talagang nangangahulugan na ang compiler ay naglalagay ng lahat ng mga naipasa na argumento sa isang array. Bilang resulta, maaari tayong magtrabaho sa mga variable na pangalantulad ng gagawin namin sa isang array, kabilang ang sa pamamagitan ng pag-ulit sa pamamagitan nito sa isang loop. 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 palagay mo ba? :) Narito ang isa pang halimbawa ng paraan ng overloading. Bigyan natin ng printInfoFromDatabase()paraan si Jarvis. Magpapakita ito ng impormasyon tungkol sa isang tao mula sa isang database. Kung ang database ay nagsasaad na ang isang tao ay isang superhero o supervillain, ipapakita namin ang impormasyong iyon:
public class Jarvis {
public void printInfoFromDatabase (String bio) {
System.out.println(bio);
}
public void printInfoFromDatabase(String bio, boolean isEvil, String nickname) {
System.out.println(bio);
if (!isEvil) {
System.out.println("Also known as the superhero " + nickname);
} else {
System.out.println("Also known as the supervillain " + nickname);
}
}
public static void main(String[] args) {
Jarvis jarvis = new Jarvis();
jarvis.printInfoFromDatabase("Laura Palmer. Date of birth: July 22, 1972. Twin Peaks, Washington");
System.out.println();
jarvis.printInfoFromDatabase("Max Eisenhardt. Height: 15.6 ft. Weight: 189 lbs. ", true, "Magneto");
}
}
Output: Laura Palmer. Petsa ng kapanganakan: Hulyo 22, 1972. Twin Peaks, Washington Max Eisenhardt. Taas: 15.6 ft. Timbang: 189 lbs. Kilala rin bilang supervillain na Magneto Kaya, ang pag-uugali ng aming pamamaraan ay nakasalalay sa data na ipinapasa namin dito. 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 pamamaraan Personng klase sayYourAge()ay tumatagal ng isang string at isang numero bilang input, ito ang pagkakasunud-sunod na ang mga argumentong ito ay dapat na maipasa sa pamamaraan! 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! :)
Paano mag-invoke ng mga pamamaraan na may katulad na mga parameter
Tulad ng alam mo, nullay isang keyword sa Java. Napakahalagang maunawaan na nullhindi ito bagay o uri ng data . Isipin na mayroon tayong Personklase at introduce()pamamaraan, na nag-aanunsyo ng pangalan at edad ng tao. Higit pa rito, maaaring ipasa ang edad bilang text o numero.
public class Person {
public void introduce(String name, String age) {
System.out.println("My name is " + name + ". My age is " + age);
}
public void introduce(String name, Integer age) {
System.out.println("My name is " + name + ". My age is " + age);
}
public static void main(String[] args) {
Person alex = new Person();
alex.introduce ("Alex", "twenty-one");
Person mary = new Person();
mary.introduce("Mary", 32);
}
}
Pamilyar na kami sa overloading, kaya alam namin na ang parehong mga pamamaraan ay gagana ayon sa nararapat: Ang pangalan ko ay Alex. Ang edad ko ay dalawampu't isang Ang pangalan ko ay Mary. Ang edad ko ay 32 Ngunit ano ang mangyayari kung pumasa tayo nullbilang pangalawang parameter sa halip na isang string o numero?
public static void main(String[] args) {
Person victor = new Person();
victor.introduce("Victor", null);// Ambiguous method call!
}
Makakakuha kami ng error sa compilation! Ano ang sanhi nito at ano nga ba ang "kalabuan"? Sa katunayan, ang lahat ng ito ay napaka-simple. Ang problema ay mayroon tayong dalawang bersyon ng pamamaraan: ang isa ay may a Stringbilang pangalawang argumento, at isa na may isang Integerbilang pangalawang argumento. Ngunit ang isang Stringat isang Integeray maaaring pareho null! Dahil ang mga ito ay mga uri ng sanggunian, nullang default na halaga para sa kanilang dalawa. Iyon ang dahilan kung bakit sa sitwasyong ito ang compiler ay hindi malaman kung aling bersyon ng pamamaraan ang dapat nitong tawagan. Ang solusyon sa problemang ito ay medyo simple. Nullmaaaring tahasang i-convert sa isang partikular na uri ng sanggunian. Kaya, kapag tumawag ka ng isang paraan, maaari mong ipahiwatig sa panaklong ang uri ng data na gusto mo para sa pangalawang argumento! Mauunawaan ng compiler ang iyong "pahiwatig" at tatawagin ang tamang paraan:
public class Person {
public void introduce(String name, String age) {
System.out.println("Method with two strings!");
System.out.println("My name is " + name + ". My age is " + age);
}
public void introduce(String name, Integer age) {
System.out.println("Method with a string and a number!");
System.out.println("My name is " + name + ". My age is " + age);
}
public static void main(String[] args) {
Person victor = new Person();
victor.introduce("Victor", (String) null);
}
}
Output: Paraan na may dalawang string! Victor ang pangalan ko. Ang aking edad ay null Tandaan na kung ang parameter ng numero ay isang primitive int, sa halip na isang halimbawa ng uri ng sanggunian ng Integer, hindi magkakaroon ng ganoong error.
public class Person {
public void introduce(String name, String age) {
System.out.println("Method with two strings!");
System.out.println("My name is " + name + ". My age is " + age);
}
public void introduce(String name, int age) {
System.out.println("Method with a string and a number!!");
System.out.println("My name is " + name + ". My age is " + age);
}
public static void main(String[] args) {
Person victor = new Person();
victor.introduce("Victor", null);
}
}
Maaari mo bang hulaan kung bakit? Kung nahulaan mo kung bakit, magaling! :) Dahil ang mga primitive ay hindi maaaring null. Ngayon ang compiler ay mayroon lamang isang pagpipilian, ibig sabihin, tawagan ang introduce()pamamaraan na may dalawang string. Ito ang bersyon ng pamamaraan na tatakbo sa tuwing tatawagin ang pamamaraan.
GO TO FULL VERSION