Why was it important to separate th

Why was it important to separate these two responsibilities into separate classes?
Because each responsibility is an axis of change. When the requirements change, that
change will be manifest through a change in responsibility amongst the classes. If a class
assumes more than one responsibility, then there will be more than one reason for it to
change.

If a class has more then one responsibility, then the responsibilities become coupled.
Changes to one responsibility may impair or inhibit the class’ ability to meet the others.
This kind of coupling leads to fragile designs that break in unexpected ways when
changed.
For example, consider the design in Figure 9-1. TheRectangleclass has two methods shown. One draws the rectangle on the screen, the other computes the area of the rectangle.

Two different applications use theRectangleclass. One application does computational geometry. It uses Rectangleto help it with the mathematics of geometric shapes.
It never draws the rectangle on the screen. The other application is graphical in nature. It
may also do some computational geometry, but it definitely draws the rectangle on the
screen.
This design violates the SRP. The Rectangle class has two responsibilities. The first
responsibility is to provide a mathematical model of the geometry of a rectangle. The second responsibility is to render the rectangle on a graphical user interface.
The violation of SRP causes several nasty problems. Firstly, we must include theGUI
in the computational geometry application. If this were a C++ application, the GUI would
have to be linked in, consuming link time, compile time, and memory footprint. In a Java
application, the.classfiles for theGUIhave to be deployed to the target platform.
Secondly, if a change to theGraphicalApplicationcauses theRectangleto
change for some reason, that change may force us to rebuild, retest, and redeploy the
ComputationalGeometryApplication. If we forget to do this, that application may
break in unpredictable ways

A better design is to separate the two responsibilities into two completely different
classes as shown in Figure 9-2. This design moves the computational portions of
Rectangleinto theGeometricRectangleclass. Now changes made to the way rectangles are rendered cannot affect theComputationalGeometryApplication.


What is a Responsibility?
In the context of the Single Responsibility Principle (SRP) we define a responsibility to be
“a reason for change.” If you can think of more than one motive for changing a class, then
that class has more than one responsibility. This is sometimes hard to see. We are accustomed to thinking of responsibility in groups. For example, consider the Modeminterface
in Listing 9-1. Most of us will agree that this interface looks perfectly reasonable. The four
functions it declares are certainly functions belonging to a modem.

However, there are two responsibilities being shown here. The first responsibility is
connection management. The second is data communication. Thedialandhangupfunctions manage the connection of the modem, while thesendandrecvfunctions communicate data.
Should these two responsibilities be separated? Almost certainly they should. The
two sets of functions have almost nothing in common. They’ll certainly change for different reasons. Moreover, they will be called from completely different parts of the applications that use them. Those different parts will change for different reasons as well.

Therefore the design in Figure 9-3 is probably better. It separates the two responsibilities into two separate interfaces
3
. This, at least, keeps the client applications from coupling the two responsibilities.


However, notice that I have recoupled the two responsibilities into a single
ModemImplementationclass. This is not desirable, but it may be necessary. There are
often reasons, having to do with the details of the hardware or OS, that force us to couple
things that we’d rather not couple. However, by separating their interfaces we have decoupled the concepts as far as the rest of the application is concerned.
We may view theModemImplementationclass is a kludge, or a wart; however,
notice that all dependencies flowawayfrom it. Nobody need depend upon this class.
Nobody exceptmainneeds to know that it exists. Thus, we’ve put the ugly bit behind a
fence. It’s ugliness need not leak out and pollute the rest of the application.

The SRP is one of the simplest of the principle, and one of the hardest to get right. Conjoining responsibilities is something that we do naturally. Finding and separating those
responsibilities from one another is much of what software design is really about. Indeed,
the rest of the principles we will discuss come back to this issue in one way or another.

Results (Indonesian) 1:

Mengapa itu penting untuk memisahkan tanggung-jawab ini dua kedalam kelompok berbeda?Karena setiap tanggung jawab sebagai poros perubahan. Ketika persyaratan mengubah, yangperubahan akan terwujud melalui perubahan dalam tanggung jawab antara kelas. Jika kelasmenganggap tanggung-jawab lebih dari satu, maka akan ada lebih dari satu alasan untuk ituperubahan.Jika kelas memiliki lebih banyak tanggung jawab satu, kemudian tanggung jawab menjadi digabungkan.Perubahan ke salah satu tanggung jawab mungkin mengganggu atau menghambat kemampuan kelas untuk bertemu dengan orang lain.Kopling semacam ini mengarah pada desain rapuh yang istirahat dalam cara yang tak terduga ketikaberubah.Sebagai contoh, mempertimbangkan desain di gambar 9-1. TheRectangleclass memiliki dua metode yang ditampilkan. Salah satu menarik persegi panjang di layar, yang lain menghitung luas persegi panjang.Dua aplikasi yang berbeda menggunakan theRectangleclass. Satu aplikasi melakukan komputasi geometri. Menggunakan Rectangleto membantu dengan matematika bentuk geometris.Ia tidak pernah menarik persegi panjang di layar. Aplikasi lain grafis di alam. Itujuga dapat melakukan beberapa komputasi geometri, tapi itu pasti menarik persegi panjang padalayar.Desain ini melanggar SRP. Persegi panjang kelas memiliki dua tanggung jawab. Yang pertamatanggung jawab adalah untuk memberikan model matematis geometri dari sebuah persegi panjang. Tanggung jawab kedua adalah untuk membuat persegi panjang pada antarmuka pengguna grafis.Pelanggaran SRP menyebabkan beberapa masalah yang buruk. Pertama, kita harus menyertakan theGUIdalam aplikasi komputasi geometri. Jika ini adalah sebuah aplikasi C++, GUI akanharus dihubungkan di, mengkonsumsi link waktu, waktu kompilasi dan tapak memori. Di Jawaaplikasi, the.classfiles untuk theGUIhave akan ditugaskan untuk target platform.Kedua, jika perubahan ke theGraphicalApplicationcauses theRectangletomengubah untuk beberapa alasan, bahwa perubahan mungkin memaksa kita untuk membangun kembali, tes ulang dan redeployComputationalGeometryApplication. Jika kita lupa untuk melakukan ini, aplikasi tersebut dapatistirahat dalam cara yang tak terdugaDesain yang lebih baik adalah untuk memisahkan dua tanggung jawab menjadi dua yang sama sekali berbedakelas seperti yang ditunjukkan pada gambar 9-2. Desain ini bergerak bagian komputasiRectangleinto theGeometricRectangleclass. Sekarang perubahan cara persegi yang diberikan tidak mempengaruhi theComputationalGeometryApplication.Apakah tanggung jawab?Dalam konteks prinsip tanggung jawab tunggal (SRP) kita mendefinisikan tanggung jawab untuk menjadi"alasan untuk perubahan." Jika Anda dapat memikirkan lebih dari satu motif untuk mengubah kelas, kemudiankelas yang memiliki tanggung jawab yang lebih dari satu. Hal ini kadang-kadang sulit untuk melihat. Kita sudah terbiasa berpikir tanggung-jawab dalam kelompok. Sebagai contoh, mempertimbangkan Modeminterfacedalam daftar 9-1. Sebagian besar dari kita akan setuju bahwa antarmuka ini tampak wajar. Empatfungsi ini menyatakan yang pasti fungsi milik modem.Namun, ada dua tanggung jawab yang sedang ditampilkan di sini. Tanggung-jawab pertamapengelolaan koneksi. Yang kedua adalah komunikasi data. Thedialandhangupfunctions mengelola koneksi modem, sementara thesendandrecvfunctions berkomunikasi data.Harus tanggung jawab ini dua dipisahkan? Hampir pasti mereka harus. Thedua set fungsi memiliki hampir tidak ada kesamaan. Mereka pasti akan mengubah untuk alasan yang berbeda. Selain itu, mereka akan dipanggil dari bagian-bagian yang sama sekali berbeda dari aplikasi yang menggunakan mereka. Bagian-bagian yang berbeda akan mengubah untuk alasan yang berbeda juga.Oleh karena itu desain di gambar 9-3 mungkin lebih baik. Memisahkan dua tanggung jawab ke dua antarmuka yang terpisah3. Hal ini, setidaknya, membuat klien aplikasi dari kopling dua tanggung jawab.Namun, perhatikan bahwa saya memiliki recoupled tanggung jawab dua menjadi satuModemImplementationclass. Hal ini tidak diinginkan, tetapi mungkin diperlukan. Adasering alasan, yang berkaitan dengan rincian hardware atau OS, yang memaksa kita untuk pasanganhal-hal yang kita tidak suka akan pasangan. Namun, dengan memisahkan mereka antarmuka kami telah dipisahkan konsep sejauh sisa aplikasi yang bersangkutan.Kita dapat melihat theModemImplementationclass adalah kludge, atau kutil; Namun,Perhatikan bahwa semua dependensi flowawayfrom itu. Tidak ada perlu tergantung pada kelas ini.Tak seorang pun exceptmainneeds untuk tahu bahwa itu ada. Dengan demikian, kami telah menempatkan sedikit jelek di belakangpagar. Keburukan itu tidak perlu bocor keluar dan mencemari sisa aplikasi.SRP adalah salah satu yang paling sederhana dari prinsip, dan salah satu yang paling sulit untuk mendapatkan yang tepat. Dibentuk tanggung jawab adalah sesuatu yang kita lakukan secara alami. Menemukan dan memisahkan orang-orangtanggung jawab dari satu sama lain adalah jauh dari apa perangkat lunak desain benar-benar tentang. Memang,sisa dari prinsip-prinsip yang kita akan membahas kembali ke masalah ini dalam satu atau lain cara.

Results (Indonesian) 2:

Mengapa penting untuk memisahkan dua tanggung jawab ini ke dalam kelas terpisah?
Karena setiap tanggung jawab adalah sumbu perubahan. Ketika perubahan persyaratan, bahwa
perubahan akan terwujud melalui perubahan dalam tanggung jawab antara kelas. Jika kelas
mengasumsikan lebih dari satu tanggung jawab, maka akan ada lebih dari satu alasan untuk itu untuk
mengubah. Jika kelas memiliki lebih dari satu tanggung jawab, maka tanggung jawab menjadi digabungkan. Perubahan salah satu tanggung jawab dapat mengganggu atau menghambat kemampuan kelas untuk memenuhi lain. semacam ini kopling menyebabkan desain rapuh yang melanggar dengan cara tak terduga ketika berubah. Sebagai contoh, mempertimbangkan desain pada Gambar 9-1. TheRectangleclass memiliki dua metode ditampilkan. Satu menarik persegi panjang di layar, yang lain menghitung luas persegi panjang. Dua aplikasi yang berbeda menggunakan theRectangleclass. Salah satu aplikasi tidak geometri komputasi. Menggunakan Rectangleto membantu dengan matematika bentuk geometris. Ini tidak pernah menarik persegi panjang di layar. Aplikasi lain adalah grafis di alam. Ini juga dapat melakukan beberapa geometri komputasi, tapi pasti menarik persegi panjang pada layar. Desain ini melanggar SRP. Kelas Rectangle memiliki dua tanggung jawab. Yang pertama jawab adalah untuk menyediakan model matematika dari geometri persegi panjang. Tanggung jawab kedua adalah untuk membuat persegi panjang pada antarmuka pengguna grafis. Pelanggaran SRP menyebabkan beberapa masalah jahat. Pertama, kita harus menyertakan theGUI dalam aplikasi geometri komputasi. Jika ini adalah ++ aplikasi C, GUI akan harus terhubung dalam, memakan waktu hubungan, waktu kompilasi, dan jejak memori. Dalam Java aplikasi, the.classfiles untuk theGUIhave akan dikerahkan untuk platform target. Kedua, jika perubahan ke theGraphicalApplicationcauses theRectangleto perubahan untuk beberapa alasan, perubahan yang mungkin memaksa kita untuk membangun kembali, tes ulang, dan memindahkan para ComputationalGeometryApplication. Jika kita lupa untuk melakukan hal ini, aplikasi yang dapat mematahkan cara tak terduga Sebuah desain yang lebih baik adalah untuk memisahkan dua tanggung jawab menjadi dua sama sekali berbeda kelas seperti yang ditunjukkan pada Gambar 9-2. Desain ini bergerak bagian komputasi Rectangleinto theGeometricRectangleclass. Sekarang perubahan dibuat dengan cara persegi panjang yang diberikan tidak dapat mempengaruhi theComputationalGeometryApplication. Apa Tanggung Jawab a? Dalam konteks Tanggung Jawab Single Prinsip (SRP) kita mendefinisikan tanggung jawab untuk menjadi "alasan untuk perubahan." Jika Anda dapat memikirkan lebih dari satu Motif untuk mengubah kelas, maka kelas yang memiliki lebih dari satu tanggung jawab. Hal ini kadang-kadang sulit untuk melihat. Kita terbiasa berpikir tanggung jawab dalam kelompok. Sebagai contoh, mempertimbangkan Modeminterface pada Listing 9-1. Sebagian besar dari kita akan setuju bahwa antarmuka ini terlihat sangat masuk akal. Keempat fungsi itu menyatakan tentu fungsi milik modem. Namun, ada dua tanggung jawab yang ditampilkan di sini. Tanggung jawab pertama adalah manajemen koneksi. Yang kedua adalah komunikasi data. Thedialandhangupfunctions mengelola koneksi modem, sedangkan thesendandrecvfunctions berkomunikasi data. Jika dua tanggung jawab ini dipisahkan? Hampir pasti mereka harus. The dua set fungsi hampir tidak ada kesamaan. Mereka pasti akan berubah untuk alasan yang berbeda. Selain itu, mereka akan dipanggil dari bagian yang sama sekali berbeda dari aplikasi yang menggunakannya. Bagian-bagian yang berbeda akan berubah untuk alasan yang berbeda juga. Oleh karena itu desain pada Gambar 9-3 mungkin lebih baik. Memisahkan dua tanggung jawab menjadi dua interface yang terpisah 3. Ini, setidaknya, membuat aplikasi client dari kopling dua tanggung jawab. Namun, pemberitahuan bahwa saya telah recoupled dua tanggung jawab menjadi satu ModemImplementationclass. Ini tidak diinginkan, tapi mungkin diperlukan. Ada sering alasan, yang berkaitan dengan rincian perangkat keras atau OS, yang memaksa kita untuk beberapa hal yang kita lebih suka tidak pasangan. . Namun, dengan memisahkan antarmuka mereka kita telah dipisahkan konsep sejauh sisa dari aplikasi yang bersangkutan Kita mungkin melihat theModemImplementationclass adalah kludge, atau kutil; Namun, perhatikan bahwa semua dependensi flowawayfrom itu. Tidak ada yang perlu tergantung pada kelas ini. Tidak ada yang exceptmainneeds tahu bahwa itu ada. Dengan demikian, kami telah menempatkan sedikit jelek di balik pagar. Ini keburukan tidak perlu bocor dan mencemari sisa aplikasi. SRP adalah salah satu yang paling sederhana dari prinsip, dan salah satu yang paling sulit untuk mendapatkan hak. Conjoining tanggung jawab adalah sesuatu yang kita lakukan secara alami. Menemukan dan memisahkan mereka tanggung jawab dari satu sama lain jauh dari apa desain software benar-benar tentang. Memang, sisa prinsip-prinsip kita akan membahas kembali ke masalah ini dalam satu atau lain cara.