Hai! Anda telah pun mengetahui tentang membuat kelas anda sendiri dengan medan dan kaedah. Sekarang kita akan membincangkan kaedah.
Sudah tentu, kami telah melakukan ini lebih daripada sekali dalam pelajaran kami, tetapi kami telah merangkumi perkara umum. Hari ini, kita akan membedah kaedah, dan mengkaji bahan pembuatannya, pelbagai cara untuk menciptanya, dan cara mengurus semuanya. :) Mari pergi!
Pengisytiharan kaedah
Semua kod yang mentakrifkan kaedah dipanggil pengisytiharan kaedah . Bentuk umum pengisytiharan kaedah boleh diterangkan seperti berikut:
access modifier, return type, method name (parameter list) {
// method body
}
Sebagai contoh, lihat pengisytiharan pelbagai kaedah kelas Dog.
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. Pengubah suai akses
Pengubah suai akses sentiasa ditunjukkan dahulu. Semua Dogkaedah kelas ditandakan dengan pengubah suai awam . Ini bermakna kita boleh memanggil mereka dari mana-mana kelas lain:
public class Main {
public static void main(String[] args) {
Dog butch = new Dog("Butch");
butch.run(100);
}
}
Seperti yang anda lihat, Dogkaedah kelas mudah diakses dalam Mainkelas. Ini mungkin disebabkan oleh pengubahsuai awam . Di Jawa, terdapat pengubahsuai lain. Mereka tidak semua membenarkan kaedah digunakan dalam kelas lain. Kami akan bercakap tentang mereka dalam pelajaran lain. Perkara utama yang perlu diingati ialah tanggungjawab pengubah suai: sama ada kaedah boleh diakses dalam kelas lain :)
2. kata kunci statik
Salah satu Dogkaedah, main(), ditandakan dengan kata kunci statik . Ia juga sebahagian daripada pengisytiharan kaedah, dan kita sudah tahu maksudnya. Kami tidak menyebutnya dalam templat pengisytiharan kaedah yang diberikan pada permulaan pelajaran, kerana ia adalah pilihan. Jika ia dinyatakan, maka ia mesti datang selepas pengubah suai akses. Ingat bahawa dalam pelajaran baru-baru ini kita bercakap tentang pembolehubah statik (kelas)? Apabila digunakan pada kaedah, kata kunci ini mempunyai maksud yang hampir sama. Jika kaedah adalah static , maka ia boleh digunakan tanpa merujuk kepada objek tertentu kelas. Dan sememangnya, anda tidak memerlukan Dogobjek untuk menjalankan main()kaedah statik dalamDogkelas. Ia akan berjalan dengan baik tanpa satu. Jika kaedah ini tidak statik, maka kita perlu mencipta objek terlebih dahulu untuk menjalankannya.
3. Nilai pulangan
Jika kaedah kami harus mengembalikan sesuatu, maka kami menentukan jenis nilai pulangan. Ini terbukti daripada contoh pengambil getName():
public String getName() {
return name;
}
Ia mengembalikan Stringobjek. Jika kaedah tidak mengembalikan apa-apa, maka kata kunci void sebaliknya digunakan, seperti dalam woof()kaedah:
public void woof() {
System.out.println("A dog named " + name + " says \"Woof, woof!\"");
}
Kaedah dengan nama yang sama
Terdapat situasi apabila kita mahu beberapa cara berbeza untuk memanggil kaedah. Mengapa tidak mencipta kecerdasan buatan kita sendiri? Amazon mempunyai Alexa, Apple mempunyai Siri, jadi mengapa kita tidak perlu memilikinya? :) Dalam filem Iron Man, Tony Stark mencipta kecerdasan buatannya yang luar biasa, Jarvis. Mari kita beri penghormatan kepada watak hebat itu dan namakan AI kita sebagai penghormatan kepadanya. :) Perkara pertama yang perlu kita lakukan ialah mengajar Jarvis bertanya khabar kepada orang yang memasuki bilik (alangkah peliknya jika intelek yang luar biasa itu ternyata tidak sopan).
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");
}
}
Keluaran konsol: Selamat malam, Tony Stark. Apa khabar? Sangat bagus! Jarvis kini boleh menyambut tetamu. Sudah tentu, lebih kerap daripada tuannya, Tony Stark. Tetapi bagaimana jika dia tidak datang sendiri! Tetapi sayHi()kaedah kami hanya menerima satu hujah. Jadi ia hanya boleh menyambut seorang yang memasuki bilik, dan akan mengabaikan yang lain. Tidak begitu sopan, setuju? :/ Dalam kes ini, kita boleh menyelesaikan masalah dengan hanya menulis 2 kaedah dengan nama yang sama, tetapi parameter yang berbeza:
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?");
}
}
Ini dipanggil kaedah overloading . Kaedah lebihan beban membolehkan program kami menjadi lebih fleksibel dan menampung pelbagai cara kerja. Mari kita semak cara ia berfungsi:
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");
}
}
Keluaran konsol: Selamat malam, Tony Stark. Apa khabar? Selamat malam, Tony Stark dan Captain America. Apa khabar? Hebat, kedua-dua versi berfungsi. :) Tetapi kami tidak menyelesaikan masalah! Bagaimana jika ada tiga tetamu? Kami boleh, sudah tentu, membebankan sayHi()kaedah sekali lagi, supaya ia menerima tiga nama tetamu. Tetapi mungkin ada 4 atau 5. Sepanjang jalan ke infiniti. Tidakkah terdapat cara yang lebih baik untuk mengajar Jarvis mengendalikan sebarang bilangan nama, tanpa membebankan sayHi()kaedah sejuta kali ()? :/ Sudah tentu ada! Jika tiada, adakah anda fikir Java akan menjadi bahasa pengaturcaraan paling popular di dunia? ;)
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");
}
}
Apabila ( String... names ) digunakan sebagai parameter, ia menunjukkan bahawa koleksi String akan dihantar kepada kaedah. Kami tidak perlu menyatakan terlebih dahulu berapa banyak yang akan ada, jadi sekarang kaedah kami adalah lebih fleksibel:
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");
}
}
Keluaran konsol: Selamat malam, Tony Stark. Apa khabar? Selamat malam, Kapten Amerika. Apa khabar? Selamat petang, Black Widow. Apa khabar? Selamat petang, Hulk. Apa khabar? Di dalam kaedah, kami mengulangi semua hujah dan memaparkan frasa yang diformatkan dengan nama. Di sini kami menggunakan for-eachgelung yang dipermudahkan (yang telah anda lihat sebelum ini). Ia sempurna di sini, kerana notasi ( String... names ) sebenarnya bermaksud bahawa pengkompil meletakkan semua hujah yang diluluskan ke dalam tatasusunan. Akibatnya, kita boleh bekerja dengan nama pembolehubahkerana kita akan bekerja dengan tatasusunan, termasuk dengan melelaran melaluinya dalam gelung. Selain itu, ia akan berfungsi dengan sebarang bilangan rentetan yang diluluskan! Dua, sepuluh, malah seribu—kaedah ini akan berfungsi dengan baik dengan sebarang bilangan tetamu. Jauh lebih mudah daripada membebankan kaedah untuk semua kemungkinan, bukankah anda fikir? :) Berikut ialah satu lagi contoh kaedah terlebih beban. Mari beri Jarvis printInfoFromDatabase()kaedah. Ia akan memaparkan maklumat tentang seseorang daripada pangkalan data. Jika pangkalan data menunjukkan bahawa seseorang itu adalah superhero atau supervillain, kami akan memaparkan maklumat tersebut:
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");
}
}
Keluaran: Laura Palmer. Tarikh lahir: 22 Julai 1972. Twin Peaks, Washington Max Eisenhardt. Tinggi: 15.6 kaki. Berat: 189 lbs. Juga dikenali sebagai supervillain Magneto Jadi, tingkah laku kaedah kami bergantung pada data yang kami hantar kepadanya. Inilah satu lagi perkara penting: susunan hujah itu penting! Katakan kaedah kami mengambil String dan nombor:
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!
}
}
Jika kaedah Personkelas sayYourAge()mengambil rentetan dan nombor sebagai input, maka ini adalah tertib bahawa argumen ini mesti dihantar kepada kaedah! Jika kita menghantarnya dalam susunan yang berbeza, maka pengkompil akan menghasilkan ralat dan orang itu tidak akan dapat menyatakan umurnya. Dengan cara ini, pembina, yang kami bincangkan dalam pelajaran lepas, juga merupakan kaedah! Anda juga boleh membebankannya (iaitu mencipta beberapa pembina dengan set parameter yang berbeza) dan susunan hujah yang diluluskan pada asasnya penting untuk mereka juga. Mereka kaedah sebenar! :)
Bagaimana untuk menggunakan kaedah dengan parameter yang serupa
Seperti yang anda tahu, nulladalah kata kunci dalam Java. Adalah sangat penting untuk memahami bahawa nullitu bukan objek mahupun jenis data . Bayangkan kita mempunyai Personkelas dan introduce()kaedah, yang mengumumkan nama dan umur orang itu. Tambahan pula, umur boleh dilalui sebagai teks atau nombor.
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);
}
}
Kami sudah biasa dengan lebihan beban, jadi kami tahu bahawa kedua-dua kaedah akan bertindak seperti yang sepatutnya: Nama saya Alex. Umur saya dua puluh satu Nama saya Mary. Umur saya 32 Tetapi apa yang akan berlaku jika kita lulus nullsebagai parameter kedua dan bukannya rentetan atau nombor?
public static void main(String[] args) {
Person victor = new Person();
victor.introduce("Victor", null);// Ambiguous method call!
}
Kami akan mendapat ralat kompilasi! Apakah yang menyebabkan ini dan apakah sebenarnya "kekaburan" itu? Sebenarnya, semuanya sangat mudah. Masalahnya ialah kita mempunyai dua versi kaedah: satu dengan a Stringsebagai hujah kedua, dan satu dengan Integersebagai hujah kedua. Tetapi a Stringdan an Integerboleh kedua-duanya null! Kerana ia adalah jenis rujukan, nulladalah nilai lalai untuk kedua-duanya. Itulah sebabnya dalam keadaan ini pengkompil tidak dapat mengetahui versi kaedah yang harus dipanggil. Penyelesaian kepada masalah ini agak mudah. Nullboleh ditukar secara eksplisit kepada jenis rujukan tertentu. Oleh itu, apabila anda memanggil kaedah, anda boleh menunjukkan dalam kurungan jenis data yang anda inginkan untuk hujah kedua! Pengkompil akan memahami "petunjuk" anda dan akan memanggil kaedah yang betul:
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: Kaedah dengan dua rentetan! Nama saya Victor. Umur saya adalah batal Ambil perhatian bahawa jika parameter nombor adalah primitive int, dan bukannya contoh jenis rujukan Integer, ralat sedemikian tidak akan berlaku.
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);
}
}
Boleh teka kenapa? Jika anda meneka mengapa, syabas! :) Kerana primitif tidak boleh null. Sekarang pengkompil hanya mempunyai satu pilihan, iaitu memanggil introduce()kaedah dengan dua rentetan. Ini adalah versi kaedah yang akan dijalankan setiap kali kaedah dipanggil.
GO TO FULL VERSION