Selalu ada antarmuka tertentu antara modul ini. Dari perspektif metode panggilan, mereka dapat dibagi menjadi tiga kategori: panggilan sinkron, panggilan balik dan panggilan asinkron. Berikut ini berfokus pada menjelaskan mekanisme panggilan balik secara rinci.
1. Ikhtisar
Mekanisme panggilan balik di Java adalah mekanisme yang relatif umum, tetapi mungkin lebih sedikit digunakan dalam program Anda, dan mekanisme panggilan balik dapat dilihat di mana -mana dalam beberapa kerangka kerja besar. Artikel ini menggunakan beberapa contoh spesifik untuk perlahan -lahan mendekati mekanisme panggilan balik Java.
2. Callback
Callback yang disebut: itu berarti memanggil metode C di kelas A di kelas B, dan kemudian memanggil metode D di kelas A di kelas B di kelas B. Metode ini D disebut metode panggilan balik. Ketika benar -benar menggunakannya, akan ada formulir panggilan balik yang berbeda, seperti yang berikut.
2.1 panggilan balik sinkron
Di sini saya menganggap situasi seperti itu.
Direktur B Perusahaan A mengatakan kepada bawahannya (Manajer Proyek C) bahwa ia ingin melakukan survei, tetapi C tidak perlu melakukannya sendiri. Manajer C dapat diminta untuk mengatur programmernya D untuk menyelesaikannya. Manajer C menemukan programmer D dan mengatakan kepadanya bahwa tugas penelitian akan selesai sekarang. Dan beri tahu manajer C hasil survei. Jika ada masalah, Anda masih harus melanjutkan. Karena inilah C meminta D untuk melakukan sesuatu, D masih harus mengkomunikasikan hasilnya dengan C setelah itu. Ini adalah model callback. Berikut ini adalah diagram kelas panggilan balik umum:
Pertama kita perlu memiliki antarmuka callback callbackinterface
CallbackInterface.java
antarmuka publik callbackInterface {public boolean check (hasil int);} Di latar belakang, Programmer D ingin mengomunikasikan hasil dengan Manajer Proyek C, sehingga manajer proyek perlu menerapkan antarmuka panggilan balik di atas:
Manajer.java
Manajer kelas publik mengimplementasikan callbackInterface {Programmer Programmer Private = null; manajer publik (programmer _programmer) {this.programmer = _programmer; } / *** Digunakan untuk delegasi yang dikeluarkan oleh bos* / public void owrust () {aturement (); } // Jadwalkan bawahan untuk mempelajari pekerjaan private void mengatur () {System.out.println ("Manajer mengatur pekerjaan untuk programmer"); Programmer.Study (Manager.Ini); System.out.println ("Jadwal kerja untuk programmer telah selesai, dan manajer telah melakukan hal -hal lain."); } @Override public boolean check (hasil int) {if (result == 5) {return true; } return false; }} Untuk Programmer D, ia perlu memegang penawaran dari Manajer C untuk berkomunikasi dengannya. Namun, inilah tugas yang diminta Direktur B untuk mengatur C. Dengan kata lain, manajer lain juga dapat ditanyakan di sini, seperti manajer B1, B2, dll. Karena manajer telah mengimplementasikan antarmuka callback, Anda dapat secara langsung membiarkan programmer D memegang antarmuka ini di sini. sebagai berikut:
Programmer.java
Programmer kelas publik {Studi public void (callbackInterface callback) {int result = 0; lakukan {hasil ++; System.out.println ("th" + hasil + "hasil penelitian"); } while (! callback.check (hasil)); System.out.println ("Survey Task Ends"); }} Bahkan lebih sederhana dan lebih jelas bagi sutradara, karena ini setara dengan tes klien:
Boss.java
bos kelas publik {public static void main (string [] args) {Manager Manager = new Manager (new programmer ()); manajer.entrust (); }} Hasil Menjalankan:
Manajer mengatur pekerjaan untuk programmer. Hasil studi pertama. Hasil studi ke -2. Hasil studi ke -3. Hasil studi ke -4. Hasil studi ke -5. Studi ke -5. Pekerjaan penjadwalan untuk programmer telah selesai. Manajer telah melakukan hal -hal lain.
2.2 Panggilan balik asinkron
Adapun contoh di atas, manajer proyek Anda tidak selalu menunggu hasil penelitian Anda. Tetapi setelah Anda menyerahkan tugas ini kepada Anda, dia akan mengabaikannya. Dia akan melakukan pekerjaannya sendiri, Anda akan melakukan hal Anda sendiri. Oleh karena itu, fungsi callback perlu diproses secara tidak sinkron di sini.
Jadi, di sini kita perlu memodifikasi kode kelas programmer, dan memodifikasinya sebagai berikut:
Programmer.java
Programmer kelas publik {public programmer () {} public void Study (callbackInterface callback) {New StudyThread (callback) .start (); } // --------------------------- Programmer 正在做的工作 --------------------------- Kelas StudyThread memperluas utas {callbackInterface callback = null; StudyThread umum (callbackInterface _callback) {callback = _callback; } @Override public void run () {int result = 0; lakukan {hasil ++; System.out.println ("th" + hasil + "hasil penelitian"); } while (! callback.check (hasil)); System.out.println ("Survey Task Ends"); }}}Hasil Menjalankan:
Manajer sedang menjadwalkan pekerjaan untuk programmer, pekerjaan penjadwalan untuk programmer telah selesai, dan manajer melakukan hal -hal lain.
Hasil hasil studi pertama dari hasil studi ke -2 dari hasil studi ke -3 dari hasil studi ke -4 dari studi ke -5 tugas penelitian berakhir
2.3 Penutupan dan panggilan balik
Penutupan adalah objek yang dapat dipanggil yang mencatat beberapa informasi dari ruang lingkup di mana ia dibuat.
2.3.1 Panggilan normal
Pertama, kita dapat melihat bagaimana panggilan dilakukan dalam keadaan normal.
Bertambah. Java
antarmuka bertambah {void increment ();}Ini adalah antarmuka biasa (ini hanya antarmuka normal dalam panggilan biasa, dan ini adalah antarmuka panggilan balik dalam panggilan balik, yang seharusnya mudah dimengerti).
Callee1.java
kelas callee1 mengimplementasikan bertambah {private int i = 0; @Override public void increment () {i ++; System.out.println (i); }}Callbacks.java
callback kelas publik {public static void main (string [] args) {callee1 callee1 = new callee1 (); callee1.increment (); }}Callbacks adalah kelas klien uji, tidak ada yang bisa dikatakan, lihat saja kode di atas.
2.3.2 Uji Awal Callback
Tidak ada yang bisa dikatakan tentang panggilan biasa di atas, karena untuk programmer Java yang normal, ini harus menjadi sesuatu yang dapat dilakukan tanpa berpikir.
Sekarang jika Anda ingin membentuk panggilan balik, tidak mungkin memiliki hanya satu calle (objek callback callee1) dalam hal struktur atau logika program, dan Anda juga memerlukan objek penelepon. Penelepon dapat menulisnya seperti ini:
Penelepon.java
class caller {private incremement callbackReference; penelepon publik (bertambah _callbackReference) {callbackReference = _callbackReference; } void go () {callbackReference.increment (); }} Di sini penelepon memegang CallbackReference untuk antarmuka panggilan balik, seperti programmer yang disebutkan di atas perlu memegang referensi manajer proyek, sehingga Anda dapat berkomunikasi dengan manajer proyek melalui referensi ini. CallbackReference di sini juga memainkan peran ini.
Sekarang mari kita lihat penulisan kelas tes:
Callbacks.java
callback kelas publik {public static void main (string [] args) {callee1 callee1 = new callee1 (); Penelepon penelepon1 = penelepon baru (callee1); caller1.go (); }}Untuk kode program sejauh ini, kami dapat sepenuhnya membandingkan kode di atas mana manajer proyek mengatur programmer untuk menyelidiki masalah teknis. Itu memiliki efek yang sama.
2.3.3 Callback Penutupan
Dibandingkan dengan callback normal, inti dari callback penutupan secara alami berbaring di penutupan, yaitu kontrol atas ruang lingkup.
Sekarang misalkan pengguna (programmer lain) menyesuaikan kelas myincrement dan menyertakan metode kenaikan. sebagai berikut:
kelas myIncrement {public void increment () {System.out.println ("mycrement.increment"); } static void f (myincrement increment) {increment.increment (); }}Ada kelas lain callee2 yang diwarisi dari kelas di atas:
kelas callee2 memperluas myincrement {private int i = 0; public void increment () {super.increment (); i ++; System.out.println (i); }}Jelas bahwa jika Anda ingin memanggil metode increment () di sini, itu menjadi panggilan fungsi umum. Jadi di sini kita perlu memodifikasi kelas Calle2 di atas. Tujuan dari modifikasi adalah untuk membuat kelas CalleE2 kompatibel dengan metode increment () dari kelas myincrement dan metode increment () dari yang bertambah. Setelah modifikasi:
kelas callee2 memperluas myincrement {private int i = 0; public void increment () {super.increment (); i ++; System.out.println (i); } class private closure mengimplementasikan bertambah {@Override public void increment () {callee2.this.increment (); }} Bertambah getCallbackReference () {return new closure (); }} Perhatikan bahwa kelas penutupan di sini adalah kelas pribadi, yang merupakan elemen penutupan. Karena kelas penutupan bersifat pribadi, harus ada antarmuka terbuka untuk operasi pada objek penutupan. Ini adalah metode getCallbackReference () di atas. Kelas penelepon tidak berubah.
Untuk menguji klien, lihat saja kodenya:
callback kelas publik {public static void main (string [] args) {callee2 callee2 = new calle2 (); Penelepon penelepon2 = penelepon baru (callee2.getCallbackReference ()); penelepon2.go (); }}Di atas adalah semua konten artikel ini. Saya berharap ini akan membantu untuk pembelajaran semua orang dan saya harap semua orang akan lebih mendukung wulin.com.