Gandingan di Jawa

Gandingan dalam JAVA ialah penunjuk a. pergantungan kelas dengan kelas lain dalam persekitaran berorientasikan objek, b. tahap fleksibiliti pembangun dalam menukar kod merentas pelbagai kelas untuk memenuhi keperluan pengguna akhir, c. cara kefungsian kelas digunakan oleh kelas lain: secara langsung atau dengan bantuan antara muka luaran, d. usaha yang diperlukan dalam mengekalkan kod post-go-live, e. cara teknik perisian inovatif seperti Inversion of Control and Dependency Injection digunakan untuk menyuntik lebih fleksibiliti dalam pengekodan dan ujian kod.

Mulakan Kursus Pembangunan Perisian Percuma Anda

Pembangunan web, bahasa pengaturcaraan, ujian perisian & lain-lain

Jenis Gandingan di Jawa

Terdapat dua gandingan utama di Jawa, dan mari kita menganalisisnya secara terperinci.

1. Gandingan Ketat

Dalam reka bentuk aplikasi berorientasikan objek, sentiasa ada keperluan untuk menggunakan logik yang dibangunkan dalam kelas dalam beberapa kelas lain untuk menggunakan semula usaha yang telah dilaburkan dan mengelakkan mencipta semula roda.

Kerjasama Langsung antara kelas membawa kepada gandingan yang ketat, dan ciri-cirinya ialah

• Logik perniagaan yang tersedia dalam kelas yang dipanggil dicipta sebagai objek di dalam kelas panggilan.
• Objek yang dicipta itu dilaksanakan dalam kelas panggilan untuk mencapai fungsi yang diperlukan. Oleh itu program panggilan mengetahui fungsi penuh logik perniagaan yang tersedia dalam kelas yang dipanggil.
• Sebarang perubahan dalam logik perniagaan yang dikodkan dalam kelas yang dipanggil memberi kesan kepada keputusan kelas yang dipanggil
• Jika perubahan tidak dapat dielakkan dalam kelas yang dipanggil, perubahan yang sesuai juga perlu dilakukan dalam kelas panggilan.
• Oleh itu Kelas sangat bergantung antara satu sama lain

Contoh Gandingan Ketat

Dua kelas yang bekerjasama dalam contoh ini, "Nilai Pesanan" dan "pesanan", adalah saling bergantung. Kelas panggilan "Nilai Pesanan" mengetahui logik perniagaan yang dikodkan dalam kelas yang dipanggil "pesanan" sewajarnya, kod dalam kelas panggilan berstruktur dan sebarang perubahan dalam kelas yang dipanggil akan mengganggu keputusan program.

Oleh itu boleh disimpulkan bahawa Kelas "Nilai Pesanan" dan "Pesanan" digandingkan rapat.

Kod:

// Tight Coupling - Sample program
public class ordervalue // Calling class
{
public static void main(String args[]) // method in the class
{
order b = new order(600,5); // creating object for the called class
System.out.println("value of the order is");
// order and execute it
System.out.println(b.value); // Prints the order value computed by
} // the called class
}
class order // Called class
{
public int value; // method in the class
order(int orderquantity, int rate) // business logic
{
this.value = orderquantity * rate; // computing the value
}
}

Output:

2. Gandingan Longgar

Dalam konsep ini, kelas yang perlu bekerjasama untuk berkongsi logik perniagaan dan fungsi biasa dalam OOPS digabungkan melalui sumber luaran. Oleh itu, mereka disambungkan secara longgar atau tidak langsung.

Atribut utama gandingan longgar ialah

• Pergantungan antara Kelas, komponen Kod dan modul adalah rendah.
• Jika pergantungan tidak dapat dielakkan, maka ia disambungkan melalui komponen luaran seperti antara muka.
• Kesambungan menggunakan antara muka dikekalkan minimum untuk meraih faedah gandingan longgar.
• Tidak akan ada keperluan untuk mentakrifkan objek di sekeliling kelas lain dalam kelas dan objek akan bebas.
• Setiap kelas akan mengetahui sedikit maklumat tentang kelas lain dalam gandingan ini. Paling baik, setiap kelas akan mengetahui antara muka modul lain yang terdedah.
• Sebarang perubahan dalam kod dalam kelas tidak akan memberi kesan kepada kelas lain dan mereka tidak perlu dikemas kini.
• Ia memberikan fleksibiliti yang sempurna kepada pembangun untuk menukar kod dengan mudah dan menampung perubahan perniagaan baharu.
• Masa dan usaha untuk mengekalkan program dikurangkan secara drastik
• Konsep rangka kerja Spring seperti Penyongsangan kawalan dan suntikan Ketergantungan sedang digunakan untuk mengatasi gandingan yang ketat.

Penyongsangan Kawalan (IOC)

Ia adalah konsep di mana kawalan modul atau objek program dipindahkan ke rangka kerja kontena. Konsep ini digunakan dalam OOPS dengan kerap. Daripada kod program membuat panggilan ke perpustakaan, rangka kerja kontena mengambil alih kawalan dan kod panggilan. Kebergantungan disuntik ke dalam objek berbanding dengan objek yang mencipta kebergantungan.

Konsep ini memudahkan gandingan longgar dan modulariti dalam pengaturcaraan.

Suntikan Kebergantungan (DI)

DI ialah kenderaan yang melaluinya konsep IOC digunakan, dan pemindahan kawalan berlaku dalam menyediakan kebergantungan objek.

Contoh Gandingan Longgar

In the example, three Classes, “month1”, “month2”, “month3” are independent modules, and they collaborate little with each other through an interface “iface”. As a result, these classes have very little knowledge of the other classes on what they are doing. They only know that all the classes are interacting with an interface.

There is no object created using the other classes in any of these classes, and they are the typical examples of loose coupling.

Code:

// Loose Coupling in JAVA - Sample Program
interface Iface //Interface is defined
{
public void monthname(); //module within the interface
}
class month1 implements Iface { // Class interacts through
public void monthname() // interface
{
System.out.println("January");
}
}
class month2 implements Iface { // Class interacts through
public void monthname() // interface
{
System.out.println("Feburary");
}
}
class month3 implements Iface { // Class interacts through
public void monthname() // interface
{
System.out.println("March");
}
}
public class Subject { // Execution starts here
public static void main(String[] args)
{
Iface t = new month1(); // First class called thru
t.monthname(); // interface
Iface tx = new month2(); // Second class called thru
tx.monthname(); // interface
Iface tx2 = new month3(); // Third class called thru
tx2.monthname(); } // interface
}

Output:

Conclusion

As far as possible, applications will have to be designed to hold only loose couplings for better maintainability and serviceability and keep interdependence between program components very minimal. However, if interdependence is a must, the components will have to be connected only through the interface.

Atas ialah kandungan terperinci Gandingan di Jawa. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!