MotivationWhen we design software a

Motivation

When we design software applications we can consider the low level classes the classes which implement basic and primary operations(disk access, network protocols,...) and high level classes the classes which encapsulate complex logic(business flows, ...). The last ones rely on the low level classes. A natural way of implementing such structures would be to write low level classes and once we have them to write the complex high level classes. Since high level classes are defined in terms of others this seems the logical way to do it. But this is not a flexible design. What happens if we need to replace a low level class?

Let's take the classical example of a copy module which reads characters from the keyboard and writes them to the printer device. The high level class containing the logic is the Copy class. The low level classes are KeyboardReader and PrinterWriter.

In a bad design the high level class uses directly and depends heavily on the low level classes. In such a case if we want to change the design to direct the output to a new FileWriter class we have to make changes in the Copy class. (Let's assume that it is a very complex class, with a lot of logic and really hard to test).

In order to avoid such problems we can introduce an abstraction layer between high level classes and low level classes. Since the high level modules contain the complex logic they should not depend on the low level modules so the new abstraction layer should not be created based on low level modules. Low level modules are to be created based on the abstraction layer.

According to this principle the way of designing a class structure is to start from high level modules to the low level modules:
High Level Classes --> Abstraction Layer --> Low Level Classes
Intent

High-level modules should not depend on low-level modules. Both should depend on abstractions.
Abstractions should not depend on details. Details should depend on abstractions.

Example

Below is an example which violates the Dependency Inversion Principle. We have the manager class which is a high level class, and the low level class called Worker. We need to add a new module to our application to model the changes in the company structure determined by the employment of new specialized workers. We created a new class SuperWorker for this.
Let's assume the Manager class is quite complex, containing very complex logic. And now we have to change it in order to introduce the new SuperWorker. Let's see the disadvantages:

we have to change the Manager class (remember it is a complex one and this will involve time and effort to make the changes).
some of the current functionality from the manager class might be affected.
the unit testing should be redone.

All those problems could take a lot of time to be solved and they might induce new errors in the old functionlity. The situation would be different if the application had been designed following the Dependency Inversion Principle. It means we design the manager class, an IWorker interface and the Worker class implementing the IWorker interface. When we need to add the SuperWorker class all we have to do is implement the IWorker interface for it. No additional changes in the existing classes.

Results (Indonesian) 1:

MotivasiKetika kita merancang aplikasi perangkat lunak kami dapat mempertimbangkan tingkat rendah kelas kelas yang mengimplementasikan operasi dasar dan utama (akses disk, protokol jaringan,...) dan tingkat tinggi kelas kelas yang merangkum kompleks logika (bisnis mengalir,...). Yang terakhir bergantung pada kelas tingkat rendah. Cara alami untuk menerapkan struktur seperti akan menulis kelas tingkat rendah dan sekali kita telah mereka untuk menulis kelas tingkat tinggi yang kompleks. Sejak kelas tingkat tinggi didefinisikan dalam hal lain ini tampaknya cara yang logis untuk melakukannya. Tapi ini bukan desain yang fleksibel. Apa yang terjadi jika kita perlu mengganti kelas tingkat rendah?Mari kita ambil contoh klasik dari modul salinan yang membaca karakter dari keyboard dan menulis mereka ke perangkat printer. Kelas tinggi yang berisi logika adalah salinan kelas. Kelas-kelas tingkat rendah adalah KeyboardReader dan PrinterWriter.Dalam desain yang buruk kelas tingkat tinggi menggunakan langsung dan sangat bergantung pada kelas tingkat rendah. Dalam kasus tersebut jika kita ingin mengubah desain untuk mengarahkan output ke kelas FileWriter baru kita harus membuat perubahan di kelas salinan. (Mari kita asumsikan bahwa itu adalah kelas sangat kompleks, dengan banyak logika dan benar-benar keras untuk menguji).Untuk menghindari masalah seperti itu, kita dapat memperkenalkan lapisan yang abstak antara kelas tingkat tinggi dan rendah tingkat kelas. Karena tingkat tinggi modul berisi logika kompleks mereka seharusnya tidak bergantung pada modul tingkat rendah sehingga lapisan abstraksi baru harus tidak dibuat berdasarkan modul tingkat rendah. Rendah tingkat modul akan dibuat berdasarkan lapisan abstraksi.Menurut prinsip ini cara merancang kelas struktur adalah untuk mulai dari tingkat tinggi modul modul tingkat rendah:Kelas tingkat tinggi--> abstraksi Layer--> kelas tingkat rendahMaksud Tingkat tinggi modul tidak boleh bergantung pada tingkat rendah modul. Keduanya harus bergantung pada abstraksi. Abstraksi seharusnya tidak bergantung pada rincian. Rincian harus bergantung pada abstraksi.ContohBerikut adalah contoh yang melanggar prinsip inversi ketergantungan. Kami memiliki kelas manajer yang merupakan kelas tingkat tinggi, dan disebut tingkat rendah kelas pekerja. Kita perlu menambahkan modul baru untuk aplikasi kita untuk model perubahan dalam struktur perusahaan yang ditentukan oleh pekerjaan baru khusus pekerja. Kami menciptakan kelas baru SuperWorker untuk ini.Mari kita asumsikan kelas manajer cukup kompleks, yang berisi logika yang sangat kompleks. Dan sekarang kita harus berubah untuk memperkenalkan SuperWorker baru. Mari kita lihat kerugian: kita harus mengubah kelas manajer (ingat itu adalah kompleks dan ini akan melibatkan waktu dan usaha untuk membuat perubahan). beberapa fungsi saat ini dari kelas manajer mungkin akan terpengaruh. unit pengujian harus diulang.Semua masalah tersebut dapat mengambil banyak waktu untuk dipecahkan dan mereka mungkin mendorong baru kesalahan dalam functionlity tua. Situasi ini akan berbeda jika aplikasi telah dirancang mengikuti prinsip inversi ketergantungan. Itu berarti kita desain kelas manajer, antarmuka IWorker dan kelas pekerja yang mengimplementasikan antarmuka IWorker. Ketika kita perlu menambahkan kelas SuperWorker semua harus kita lakukan adalah menerapkan antarmuka IWorker untuk itu. Tidak ada tambahan perubahan di kelas yang ada.

Results (Indonesian) 2:

Motivasi Ketika kita merancang aplikasi perangkat lunak kami dapat mempertimbangkan kelas tingkat rendah kelas yang mengimplementasikan operasi dasar dan utama (akses disk, protokol jaringan, ...) dan kelas tingkat tinggi kelas yang merangkum logika kompleks (arus bisnis, ...) . Yang terakhir bergantung pada kelas tingkat rendah. Sebuah cara alami menerapkan struktur seperti akan menulis kelas tingkat rendah dan setelah kami memiliki mereka untuk menulis kelas tingkat tinggi yang kompleks. Sejak kelas tingkat tinggi didefinisikan dalam hal lain ini tampaknya cara yang logis untuk melakukannya. Tapi ini bukan desain yang fleksibel. Apa yang terjadi jika kita perlu mengganti kelas tingkat rendah? Mari kita ambil contoh klasik dari modul salinan yang berbunyi karakter dari keyboard dan menulis mereka ke perangkat printer. Kelas tingkat tinggi yang mengandung logika adalah kelas Copy. Kelas tingkat rendah yang KeyboardReader dan PrinterWriter. Dalam desain yang buruk kelas tingkat tinggi menggunakan langsung dan sangat bergantung pada kelas tingkat rendah. Dalam kasus seperti itu jika kita ingin mengubah desain untuk mengarahkan output ke kelas FileWriter baru kita harus membuat perubahan di kelas Copy. (Mari kita asumsikan bahwa itu adalah kelas yang sangat kompleks, dengan banyak logika dan benar-benar sulit untuk test). Dalam rangka untuk menghindari masalah seperti kita dapat memperkenalkan lapisan abstraksi antara kelas tingkat tinggi dan kelas rendah. Karena modul tingkat tinggi mengandung logika kompleks mereka tidak harus bergantung pada modul tingkat rendah sehingga lapisan abstraksi baru tidak boleh dibuat berdasarkan modul tingkat rendah. Modul tingkat rendah yang akan dibuat berdasarkan pada lapisan abstraksi. Menurut prinsip ini dengan cara merancang struktur kelas adalah mulai dari modul tingkat tinggi untuk modul tingkat rendah: Tingkat Tinggi Kelas -> Lapisan Abstraksi -> Rendah Kelas Intent modul tingkat tinggi seharusnya tidak bergantung pada modul tingkat rendah. Keduanya harus bergantung pada abstraksi. Abstraksi seharusnya tidak bergantung pada rincian. Rincian harus tergantung pada abstraksi. Contoh Berikut adalah contoh yang melanggar Ketergantungan Inversi Prinsip. Kami memiliki kelas manajer yang merupakan kelas tingkat tinggi, dan kelas tingkat rendah yang disebut Pekerja. Kita perlu menambahkan modul baru untuk aplikasi kita untuk model perubahan struktur perusahaan ditentukan oleh kerja dari pekerja khusus baru. Kami menciptakan kelas SuperWorker baru untuk ini. Mari kita asumsikan kelas manajer cukup kompleks, yang mengandung logika yang sangat kompleks. Dan sekarang kita harus mengubahnya untuk memperkenalkan SuperWorker baru. Mari kita lihat kelemahan:. Kita harus mengubah kelas Manager (ingat itu adalah satu kompleks dan ini akan melibatkan waktu dan usaha untuk membuat perubahan). Beberapa fungsi arus dari kelas manajer mungkin terpengaruh unit testing harus redone. Semua masalah tersebut bisa mengambil banyak waktu untuk diselesaikan dan mereka mungkin menyebabkan kesalahan baru di functionlity tua. Situasi akan berbeda jika aplikasi telah dirancang mengikuti Ketergantungan Inversi Prinsip. Artinya kita merancang kelas manajer, antarmuka IWorker dan kelas Pekerja mengimplementasikan antarmuka IWorker. Ketika kita perlu menambahkan kelas SuperWorker yang harus kita lakukan adalah mengimplementasikan antarmuka IWorker untuk itu. Tidak ada perubahan tambahan dalam kelas yang ada.