1The Open-Closed PrincipleThis is t

1
The Open-Closed Principle
This is the first of my Engineering Notebookcolumns for The C++ Report. The articles
that will appear in this column will focus on the use of C++ and OOD, and will address
issues of software engineering. I will strive for articles that are pragmatic and directly useful to the software engineer in the trenches. In these articles I will make use of Booch’s
notation for documenting object oriented designs. The sidebar provides a brief lexicon of
Booch’s notation.
There are many heuristics associated with object oriented design. For example, “all
member variables should be private”, or “global variables should be avoided”, or “using
run time type identification (RTTI) is dangerous”. What is the source of these heuristics?
What makes them true? Are they alwaystrue? This column investigates the design principle that underlies these heuristics -- the open-closed principle.
As Ivar Jacobson said: “All systems change during their life cycles. This must be
borne in mind when developing systems expected to last longer than the first version.”
1
How can we create designs that are stable in the face of change and that will last longer
than the first version? Bertrand Meyer
2
gave us guidance as long ago as 1988 when he
coined the now famous open-closed principle. To paraphrase him:
SOFTWAREENTITIES(CLASSES, MODULES, FUNCTIONS, ETC.)
SHOULDBEOPENFOREXTENSION, BUTCLOSEDFOR
MODIFICATION.
When a single change to a program results in a cascade of changes to dependent modules,
that program exhibits the undesirable attributes that we have come to associate with “bad”
design. The program becomes fragile, rigid, unpredictable and unreusable. The openclosed principle attacks this in a very straightforward way. It says that you should design
modules that never change. When requirements change, you extend the behavior of such
modules by adding new code, not by changing old code that already works.
Description
Modules that conform to the open-closed principle have two primary attributes.
1. Object Oriented Software Engineering a Use Case Driven Approach, Ivar Jacobson, Addison
Wesley, 1992, p 21.
2. Object Oriented Software Construction, Bertrand Meyer, Prentice Hall, 1988, p 23
2 Description
1. They are “Open For Extension”.
This means that the behavior of the module can be extended. That we can make
the module behave in new and different ways as the requirements of the application change, or to meet the needs of new applications.
2. They are “Closed for Modification”.
The source code of such a module is inviolate. No one is allowed to make source
code changes to it.
It would seem that these two attributes are at odds with each other. The normal way to
extend the behavior of a module is to make changes to that module. A module that cannot
be changed is normally thought to have a fixed behavior. How can these two opposing
attributes be resolved?
Abstraction is the Key.
In C++, using the principles of object oriented design, it is possible to create abstractions
that are fixed and yet represent an unbounded group of possible behaviors. The abstractions are abstract base classes, and the unbounded group of possible behaviors is represented by all the possible derivative classes. It is possible for a module to manipulate an
abstraction. Such a module can be closed for modification since it depends upon an
abstraction that is fixed. Yet the behavior of that module can be extended by creating new
derivatives of the abstraction.
Figure 1 shows a simple design that does not conform to the open-closed principle.
Both the Clientand Serverclasses are concrete. There is no guarantee that the member functions of the Serverclass are virtual. The Clientclass usesthe Serverclass.
If we wish for a Clientobject to use a different server object, then the Clientclass
must be changed to name the new server class.
Figure 2 shows the corresponding design that conforms to the open-closed principle.
In this case, the AbstractServerclass is an abstract class with pure-virtual member
functions. the Clientclass uses this abstraction. However objects of the Clientclass
will be using objects of the derivative Serverclass. If we want Clientobjects to use a
different server class, then a new derivative of the AbstractServerclass can be created. The Clientclass can remain unchanged.
Figure 1
Closed Client
Client Server
3 : The Open-Closed Principle
The ShapeAbstraction
Consider the following example. We have an application that must be able to draw circles
and squares on a standard GUI. The circles and squares must be drawn in a particular
order. A list of the circles and squares will be created in the appropriate order and the program must walk the list in that order and draw each circle or square.
In C, using procedural techniques that do not conform to the open-closed principle,
we might solve this problem as shown in Listing 1. Here we see a set of data structures
that have the same first element, but are different beyond that. The first element of each is
a type code that identifies the data structure as either a circle or a square. The function
DrawAllShapeswalks an array of pointers to these data structures, examining the type
code and then calling the appropriate function (either DrawCircleor DrawSquare).
Figure 2
Open Client
Listing 1
Procedural Solution to the Square/Circle Problem
enum ShapeType {circle, square};
struct Shape
{
ShapeType itsType;
};
struct Circle
{
ShapeType itsType;
double itsRadius;
Point itsCenter;
};
Client
Abstract
Server
Server
A
4 The Shape Abstraction
The function DrawAllShapesdoes not conform to the open-closed principle
because it cannot be closed against new kinds of shapes. If I wanted to extend this function
to be able to draw a list of shapes that included triangles, I would have to modify the function. In fact, I would have to modify the function for any new type of shape that I needed
to draw.
Of course this program is only a simple example. In real life the switchstatement in
the DrawAllShapesfunction would be repeated over and over again in various functions all over the application; each one doing something a little different. Adding a new
shape to such an application means hunting for every place that such switchstatements
(or if/elsechains) exist, and adding the new shape to each. Moreover, it is very
unlikely that all the switchstatements and if/elsechains would be as nicely structured as the one in DrawAllShapes. It is much more likely that the predicates of the if
struct Square
{
ShapeType itsType;
double itsSide;
Point itsTopLeft;
};
//
// These functions are implemented elsewhere
//
void DrawSquare(struct Square*)
void DrawCircle(struct Circle*);
typedef struct Shape *ShapePointer;
void DrawAllShapes(ShapePointer list[], int n)
{
int i;
for (i=0; iitsType)
{
case square:
DrawSquare((struct Square*)s);
break;
case circle:
DrawCircle((struct Circle*)s);
break;
}
}
}
Listing 1 (Continued)
Procedural Solution to the Square/Circle Problem
5 : The Open-Closed Principle
statements would be combined with logical operators, or that the caseclauses of the
switchstatements would be combined so as to “simplify” the local decision making.
Thus the problem of finding and understanding all the places where the new shape needs
to be added can be non-trivial.
Listing 2 shows the code for a solution to the square/circle problem that conforms to
the open-closed principle. In this case an abstract Shapeclass is created. This abstract
class has a single pure-virtual function called Draw. Both Circleand Squareare
derivatives of the Shapeclass.
Note that if we want to extend the behavior of the DrawAllShapesfunction in
Listing 2 to draw a new kind of shape, all we need do is add a new derivative of the
Shapeclass. The DrawAllShapesfunction does not need to change. Thus
DrawAllShapesconforms to the open-closed principle. Its behavior can be extended
without modifying it.
In the real world the Shapeclass would have many more methods. Yet adding a new
shape to the application is still quite simple since all that is required is to create the new
derivative and implement all its functions. There is no need to hunt through all of the
application looking for places that require changes.
Since programs that conform to the open-closed principle are changed by adding new
code, rather than by changing existing code, they do not experience the cascade of changes
exhibited by non-conforming programs.
Listing 2
OOD solution to Square/Circle problem.
class Shape
{
public:
virtual void Draw() const = 0;
};
class Square : public Shape
{
public:
virtual void Draw() const;
};
class Circle : public Shape
{
public:
virtual void Draw() const;
};
void DrawAllShapes(Set& list)
{
for (Iteratori(list); i; i++)
(*i)->Draw();
}
6 Strategic Closure
Strategic Closure
It should be clear that no significant program can be 100% closed. For example, consider
what would happen to the DrawAllShapesfunction from Listing 2 if we decided that
all Circlesshould be drawn before any Squares. The DrawAllShapesfunction is
not closed against a change like this. In general, no matter how “closed” a module is, there
will always be some kind of change against which it is not closed.
Since closure cannot be complete, it must be strategic. That is, the designer must
choose the kinds of changes against which to close his design. This takes a certain amount
of prescience derived from experience. The experienced designer knows the users and the
industry well enough to judge the probability of different kinds of changes. He then makes
sure that the open-closed principle is invoked for the most probable changes.
Using Abstraction to Gain Explicit Closure.
How could we close the DrawAllShapesfunction against changes in the ordering
of drawing? Remember that closure is based upon abstraction. Thus, in order to close
DrawAllShapesagainst ordering, we need some

Results (Indonesian) 1:

1Prinsip ditutup terbukaIni adalah yang pertama dari Notebookcolumns saya teknik untuk The C++ laporan. Artikelyang akan muncul di kolom ini akan fokus pada penggunaan C ++ dan OOD, dan akan alamatisu-isu rekayasa perangkat lunak. Saya akan berusaha untuk artikel yang pragmatis dan langsung bermanfaat untuk software engineer di parit. Dalam artikel ini saya akan membuat penggunaan Beli batu Mangan dinotasi untuk mendokumentasikan desain berorientasi objek. Sidebar menyediakan sebuah lexicon singkat dariBeli batu Mangan di notasi.Ada banyak heuristik yang terkait dengan desain berorientasi objek. Misalnya, "Semuavariabel member harus pribadi", atau"variabel global harus dihindari", atau"menggunakanjangka waktu jenis identifikasi (RTTI) berbahaya. Apakah sumber heuristik ini?Apa yang membuat mereka benar? Apakah mereka alwaystrue? Kolom ini menyelidiki prinsip desain yang mendasari heuristik ini--prinsip ditutup terbuka.Sebagai Ivar Jacobson berkata: "semua sistem perubahan selama siklus hidup mereka. Ini harusdiingat ketika mengembangkan sistem untuk bertahan lebih lama daripada versi pertama."1Bagaimana kita dapat membuat desain yang stabil dalam menghadapi perubahan dan yang akan bertahan lebih lamadaripada versi pertama? Bertrand Meyer2memberikan bimbingan lama sebagai 1988 ketika iadiciptakan prinsip ditutup terbuka sekarang terkenal. Untuk parafrase dia:SOFTWAREENTITIES (KELAS, MODUL, FUNGSI, DLL) SHOULDBEOPENFOREXTENSION, BUTCLOSEDFORMODIFIKASI. Ketika satu perubahan ke hasil program di cascade perubahan tergantung modul,program itu menunjukkan atribut tidak diinginkan yang kita telah datang untuk mengasosiasikan dengan "buruk"Desain. Program menjadi rapuh, kaku, tak terduga dan unreusable. Prinsip openclosed serangan ini dalam cara yang sangat mudah. Dikatakan bahwa Anda harus desainmodul yang tidak pernah berubah. Bila mengubah persyaratan, Anda memperpanjang perilaku tersebutmodul dengan menambahkan kode baru, tidak dengan mengubah tua kode yang sudah bekerja.DeskripsiModul yang sesuai dengan prinsip ditutup terbuka memiliki dua atribut utama.1. object Oriented rekayasa perangkat lunak menggunakan pendekatan kasus yang didorong, Ivar Jacobson, Addison Wesley, 1992, p 21.2. object Oriented perangkat lunak konstruksi, Bertrand Meyer, Prentice Hall, 1988, p 232 Deskripsi1. mereka adalah "Terbuka untuk ekstensi".Ini berarti bahwa perilaku modul dapat diperpanjang. Bahwa kita dapat membuat modul berperilaku dalam cara-cara baru dan berbeda sebagai persyaratan aplikasi perubahan, atau untuk memenuhi kebutuhan aplikasi baru.2. mereka adalah "Ditutup untuk modifikasi".Kode sumber dari modul tersebut tidak berubah. Tidak diperbolehkan untuk membuat sumber Kode perubahan untuk itu.Tampaknya bahwa atribut ini dua yang bertentangan satu sama lain. Cara biasa untukmemperpanjang perilaku modul adalah untuk membuat perubahan ke yang modul. Modul yang tidakdiganti biasanya dianggap memiliki perilaku yang tetap. Bagaimana kedua yang menentangatribut dapat diselesaikan?Abstraksi adalah kunci.Dalam c + +, menggunakan prinsip objek desain yang berorientasi, mungkin untuk membuat abstraksiitu adalah tetap dan belum mewakili kelompok mungkin perilaku yang tak terbatas. Abstraksi yang abstrak kelas dasar, dan kelompok tak terbatas mungkin perilaku diwakili oleh semua kelas turunan mungkin. Mungkin untuk sebuah modul untuk memanipulasiabstraksi. Modul tersebut dapat ditutup untuk modifikasi karena itu tergantung padaabstraksi yang telah diperbaiki. Namun perilaku modul tersebut dapat diperpanjang dengan menciptakan baruturunan dari abstraksi.Gambar 1 menunjukkan desain yang sederhana yang tidak sesuai dengan prinsip ditutup terbuka.Kedua Clientand Serverclasses beton. Ada tidak ada jaminan bahwa fungsi anggota Serverclass virtual. Clientclass usesthe Serverclass.Jika kita ingin Clientobject menggunakan objek server yang berbeda, maka Clientclassharus diubah untuk nama kelas server baru. Gambar 2 menunjukkan desain sesuai yang sesuai dengan prinsip ditutup terbuka.Dalam kasus ini, AbstractServerclass adalah kelas abstrak dengan anggota murni-virtualfungsi. Clientclass menggunakan abstraksi ini. Namun objek dari Clientclassakan menggunakan objek turunan Serverclass. Jika kita ingin Clientobjects menggunakankelas server yang berbeda, maka baru turunan dari AbstractServerclass dapat dibuat. Clientclass dapat tetap tidak berubah.Gambar 1Klien tertutupKlien Server3: prinsip ditutup terbukaShapeAbstractionPerhatikan contoh berikut. Kami memiliki aplikasi yang harus mampu menggambar lingkarandan kotak pada GUI standar. Lingkaran dan kotak harus ditarik secara khususurutan. Daftar lingkaran dan kotak akan dibuat sesuai urutan dan program harus berjalan daftar dalam urutan dan menarik setiap lingkaran atau persegi.C, menggunakan teknik prosedural yang tidak sesuai dengan prinsip ditutup terbuka,kita mungkin memecahkan masalah ini seperti yang ditunjukkan dalam daftar 1. Di sini kita melihat satu set struktur datayang memiliki elemen pertama sama, tetapi berbeda lebih dari itu. Elemen pertama dari masing-masing adalahKetikkan kode yang mengidentifikasi struktur data sebagai sebuah lingkaran atau persegi. FungsiDrawAllShapeswalks sebuah array dari pointer ke struktur data ini, memeriksa jeniskode dan kemudian memanggil fungsi sesuai (baik DrawCircleor DrawSquare).Gambar 2Buka klienDaftar 1 Prosedural solusi untuk masalah Square lingkaranENUM ShapeType {lingkaran, persegi};struct bentuk {ShapeType itsType;};struct lingkaran {ShapeType itsType;itsRadius ganda; Titik itsCenter;};KlienAbstrakServerServerA4 abstraksi bentukFungsi DrawAllShapesdoes tidak sesuai dengan prinsip ditutup terbukakarena itu tidak dapat ditutup terhadap jenis baru bentuk. Jika saya ingin memperluas fungsi iniuntuk dapat menggambar daftar bentuk yang termasuk segitiga, saya akan harus memodifikasi fungsi. Bahkan, saya akan harus memodifikasi fungsi untuk jenis baru dari bentuk yang saya butuhkanmenggambar.Tentu saja program ini adalah hanya sebuah contoh sederhana. Dalam kehidupan nyata switchstatement diDrawAllShapesfunction akan diulang lagi dan lagi dalam berbagai fungsi seluruh aplikasi; masing-masing melakukan sesuatu yang sedikit berbeda. Menambahkan barubentuk untuk aplikasi tersebut berarti berburu untuk setiap tempat itu seperti switchstatements(atau jika / elsechains) ada, dan menambahkan bentuk baru untuk masing-masing. Selain itu, ianya sangattidak mungkin bahwa semua switchstatements dan jika / elsechains akan semanis terstruktur sebagai satu di DrawAllShapes. Hal ini jauh lebih mungkin bahwa predikat jikastruct Square {ShapeType itsType;itsSide ganda; Titik itsTopLeft;};//Fungsi-fungsi ini dilaksanakan di tempat lain//membatalkan DrawSquare (struct Square *)membatalkan DrawCircle (struct lingkaran *);typedef struct bentuk * ShapePointer;membatalkan DrawAllShapes ([-] daftar ShapePointer, int n){Int saya;untuk (i = 0; saya{struct bentuk * s = Daftar [i];beralih (s -> itsType){kasus persegi:DrawSquare ((struct Square *) s);istirahat;kasus lingkaran:DrawCircle ((struct lingkaran *) s);istirahat;}}}Daftar 1 (lanjutan)Prosedural solusi untuk masalah Square lingkaran5: prinsip ditutup terbukapernyataan dapat dikombinasikan dengan operator logis, atau yang caseclauses dariswitchstatements dapat dikombinasikan untuk "menyederhanakan" pengambilan keputusan lokal.Dengan demikian masalah menemukan dan memahami semua tempat di mana bentuk baru kebutuhanditambahkan dapat non-sepele.Daftar 2 menunjukkan kode untuk solusi untuk masalah square lingkaran yang sesuaiprinsip ditutup terbuka. Dalam kasus ini abstrak Shapeclass dibuat. Abstrak inikelas memiliki fungsi murni-virtual tunggal yang disebut menarik. Kedua Circleand Squareareturunan dari Shapeclass. Perhatikan bahwa jika kita ingin memperpanjang perilaku DrawAllShapesfunction diDaftar 2 Menggambar bentuk bentuk, kita perlu lakukan adalah menambahkan baru turunan dariShapeclass. DrawAllShapesfunction tidak perlu untuk mengubah. Dengan demikianDrawAllShapesconforms prinsip ditutup terbuka. Perilaku dapat diperpanjangtanpa memodifikasi itu. Dalam dunia nyata Shapeclass akan memiliki banyak metode lain. Namun menambahkan barubentuk aplikasi ini masih cukup sederhana karena semua yang diperlukan adalah untuk menciptakan baruDerivatif dan melaksanakan fungsi-fungsi. Tidak perlu untuk berburu melalui semuaaplikasi mencari tempat yang memerlukan perubahan.Sejak program yang sesuai dengan prinsip ditutup terbuka diganti dengan menambahkan barukode, daripada dengan mengubah kode yang ada, mereka tidak mengalami cascade perubahandipamerkan oleh program bebas-penurut.Daftar 2 OOD solusi untuk masalah Square lingkaran.kelas bentuk {Umum: Virtual Batal Draw() const = 0;};kelas Square: bentuk umum{Umum: Virtual Batal Draw() const;};kelas lingkaran: bentuk umum{Umum: Virtual Batal Draw() const;};Batal DrawAllShapes (Set& daftar){untuk (Iteratori(list); saya; i ++)(* saya) -> Draw();}6 penutupan strategisPenutupan strategisHarus jelas bahwa tidak ada program yang signifikan bisa 100% ditutup. Sebagai contoh, perhatikanapa yang akan terjadi ke DrawAllShapesfunction dari daftar 2 jika kami memutuskan bahwaCirclesshould semua ditarik sebelum setiap kotak. DrawAllShapesfunction adalahtidak tertutup terhadap perubahan seperti ini. Secara umum, tidak peduli bagaimana "menutup" modul yang ada,akan selalu ada beberapa jenis perubahan yang tidak ditutup.Karena penutupan tidak dapat menyelesaikan, itu harus strategis. Itu adalah, perancang harusmemilih jenis-jenis perubahan terhadap untuk menutup rancangannya. Ini membutuhkan jumlah tertentudari kejayaannya berasal dari pengalaman. Perancang berpengalaman tahu pengguna danindustri cukup baik untuk menilai kemungkinan jenis perubahan. Ia kemudian membuatyakin bahwa prinsip ditutup terbuka dipanggil untuk perubahan yang paling mungkin.Menggunakan abstraksi untuk mendapatkan eksplisit penutupan.Bagaimana kita bisa menutup DrawAllShapesfunction terhadap perubahan dalam memesangambar? Ingat bahwa penutupan didasarkan pada abstraksi. Dengan demikian, dalam rangka untuk menutupDrawAllShapesagainst memesan, kita perlu beberapa

Results (Indonesian) 2:

1
Open-Closed Prinsip
ini adalah pertama saya Rekayasa Notebookcolumns untuk The C ++ Report. Artikel-artikel
yang akan muncul di kolom ini akan fokus pada penggunaan C ++ dan OOD, dan akan membahas
isu-isu rekayasa perangkat lunak. Saya akan berusaha untuk artikel yang pragmatis dan langsung berguna untuk insinyur perangkat lunak dalam parit. Dalam artikel ini saya akan memanfaatkan Booch ini
notasi untuk mendokumentasikan berorientasi objek desain. Sidebar menyediakan leksikon singkat
notasi Booch ini.
Ada banyak heuristik terkait dengan desain berorientasi objek. Misalnya, "semua
variabel anggota harus pribadi", atau "variabel global harus dihindari", atau "menggunakan
identifikasi jenis run time (RTTI) berbahaya". Apa sumber heuristik ini?
Apa yang membuat mereka benar? Apakah mereka alwaystrue? Kolom ini menyelidiki prinsip desain yang mendasari heuristik ini - prinsip terbuka tertutup.
Seperti Ivar Jacobson mengatakan: "Semua sistem berubah selama siklus hidup mereka. Ini harus
diingat ketika mengembangkan sistem diperkirakan berlangsung lebih lama dari versi pertama.
"1
Bagaimana kita bisa membuat desain yang stabil dalam menghadapi perubahan dan yang akan bertahan lebih lama
dari versi pertama? Bertrand Meyer
2
memberikan bimbingan selama lalu sebagai 1988 ketika ia
menciptakan prinsip terbuka-tertutup sekarang terkenal. Mengutip dia:
SOFTWAREENTITIES (CLASSES, MODUL, FUNGSI, DLL)
SHOULDBEOPENFOREXTENSION,
BUTCLOSEDFOR. MODIFIKASI
Ketika satu perubahan untuk hasil program riam perubahan modul tergantung,
program yang menunjukkan atribut yang tidak diinginkan bahwa kita telah datang untuk mengasosiasikan dengan "buruk"
desain. Program ini menjadi rapuh, kaku, tak terduga dan unreusable. Serangan prinsip openclosed ini dalam cara yang sangat mudah. Ia mengatakan bahwa Anda harus merancang
modul yang tidak pernah berubah. Ketika perubahan persyaratan, Anda memperpanjang perilaku seperti
modul dengan menambahkan kode baru, bukan dengan mengubah kode lama yang sudah bekerja.
Deskripsi
Modul yang sesuai dengan prinsip terbuka tertutup memiliki dua atribut utama.
1. Software Berorientasi objek Insinyur Pendekatan Gunakan Kasus Didorong, Ivar Jacobson, Addison
Wesley, 1992, hal 21.
2. Obyek Software Berorientasi Konstruksi, Bertrand Meyer, Prentice Hall, 1988, p 23
2 Keterangan
1. Mereka adalah "Open Untuk Extension".
Ini berarti bahwa perilaku modul dapat diperpanjang. Bahwa kita dapat membuat
berperilaku modul dalam cara-cara baru dan berbeda sebagai persyaratan perubahan aplikasi, atau untuk memenuhi kebutuhan aplikasi baru.
2. Mereka "Ditutup untuk Modifikasi".
Kode sumber dari modul tersebut adalah terhormat. Tidak ada yang diperbolehkan untuk membuat sumber
perubahan kode untuk itu.
Akan terlihat bahwa kedua sifat ini bertentangan satu sama lain. Cara biasa untuk
memperpanjang perilaku modul adalah untuk membuat perubahan pada modul itu. Sebuah modul yang tidak dapat
diubah biasanya dianggap memiliki perilaku tetap. Bagaimana bisa kedua melawan
atribut diselesaikan?
Abstraksi adalah Kunci.
Dalam C ++, menggunakan prinsip-prinsip desain berorientasi objek, adalah mungkin untuk membuat abstraksi
yang tetap dan belum mewakili kelompok terbatas perilaku mungkin. Abstraksi yang kelas dasar abstrak, dan kelompok terbatas dari perilaku yang mungkin diwakili oleh semua kelas turunan mungkin. Hal ini dimungkinkan untuk modul untuk memanipulasi
abstraksi. Modul tersebut dapat ditutup untuk modifikasi karena tergantung pada sebuah
abstraksi yang tetap. Namun perilaku modul yang dapat diperpanjang dengan menciptakan baru
turunan dari abstraksi.
Gambar 1 menunjukkan desain sederhana yang tidak sesuai dengan prinsip terbuka tertutup.
Kedua Clientand Serverclasses beton. Tidak ada jaminan bahwa fungsi anggota Serverclass adalah virtual. The Clientclass usesthe Serverclass.
Jika kita ingin untuk Clientobject untuk menggunakan objek server yang berbeda, maka Clientclass
harus diubah untuk nama kelas server baru.
Gambar 2 menunjukkan desain yang sesuai yang sesuai dengan prinsip terbuka tertutup.
Dalam hal ini, yang AbstractServerclass adalah kelas abstrak dengan anggota murni-virtual
fungsi. yang Clientclass menggunakan abstraksi ini. Namun obyek dari Clientclass
akan menggunakan obyek dari Serverclass derivatif. Jika kita ingin Clientobjects menggunakan
kelas server yang berbeda, maka turunan baru dari AbstractServerclass dapat dibuat. The Clientclass dapat tetap tidak berubah.
Gambar 1
Client Tertutup
Client Server
3: The Open-Closed Prinsip
yang ShapeAbstraction
Perhatikan contoh berikut. Kami memiliki aplikasi yang harus mampu menggambar lingkaran
dan kotak pada GUI standar. Lingkaran dan kotak harus ditarik tertentu
agar. Daftar lingkaran dan kotak akan dibuat dalam urutan yang tepat dan program harus berjalan daftar agar dan menarik setiap lingkaran atau persegi.
Dalam C, menggunakan teknik prosedural yang tidak sesuai dengan prinsip terbuka-tertutup,
kita mungkin memecahkan masalah ini seperti yang ditunjukkan pada Listing 1. Di sini kita melihat satu set struktur data
yang memiliki yang sama pertama elemen, tetapi berbeda di luar itu. Elemen pertama dari masing-masing
jenis kode yang mengidentifikasi struktur data baik sebagai lingkaran atau persegi. Fungsi
DrawAllShapeswalks array pointer ke struktur data ini, memeriksa jenis
kode dan kemudian memanggil fungsi yang sesuai (baik DrawCircleor DrawSquare).
Gambar 2
Buka Client
Listing 1
Solusi Prosedural ke Square / Lingkaran Masalah
enum ShapeType {lingkaran, persegi};
struct Bentuk
{ShapeType itsType;}; struct Lingkaran {ShapeType itsType; ganda itsRadius, Titik itsCenter;}; Client Abstrak Server Server A 4 The Shape Abstraksi Fungsi DrawAllShapesdoes tidak sesuai dengan prinsip terbuka-tertutup karena tidak dapat ditutup terhadap jenis baru bentuk. Jika saya ingin memperpanjang fungsi ini untuk dapat menarik daftar bentuk yang termasuk segitiga, saya harus memodifikasi fungsi. Bahkan, saya harus memodifikasi fungsi untuk setiap jenis baru dari bentuk yang saya butuhkan untuk menarik. Tentu saja program ini hanya contoh sederhana. Dalam kehidupan nyata switchstatement di DrawAllShapesfunction akan diulang lagi dan lagi dalam berbagai fungsi seluruh aplikasi; masing-masing melakukan sesuatu yang sedikit berbeda. Menambahkan baru bentuk untuk aplikasi seperti itu berarti berburu untuk setiap tempat yang switchstatements seperti (atau jika / elsechains) ada, dan menambahkan bentuk baru untuk setiap. Selain itu, sangat tidak mungkin bahwa semua switchstatements dan jika / elsechains akan semanis disusun sebagai satu di DrawAllShapes. Hal ini jauh lebih mungkin bahwa predikat dari jika struct Lapangan {ShapeType itsType; ganda itsSide, Titik itsTopLeft;}; // // fungsi ini dilaksanakan di tempat lain // kekosongan DrawSquare (struct Lapangan *) batal DrawCircle (struct Lingkaran *) ; typedef struct Shape * ShapePointer; kekosongan DrawAllShapes (daftar ShapePointer [], int n) {int i; for (i = 0; i






































{Struct Bentuk * s = daftar [i]; switch (s-> itsType) {kasus persegi: DrawSquare ((struct Lapangan *) s); break; kasus lingkaran: DrawCircle ((struct Lingkaran *) s); break;} }} Listing 1 (Lanjutan) Solusi Prosedural ke Square / Lingkaran Soal 5: The Open-Closed Prinsip pernyataan akan dikombinasikan dengan operator logika, atau bahwa caseclauses dari switchstatements akan digabungkan sehingga "menyederhanakan" pengambilan keputusan lokal . Dengan demikian masalah menemukan dan memahami semua tempat di mana bentuk baru perlu ditambahkan dapat non-sepele. Kode 2 menunjukkan kode untuk solusi untuk masalah persegi / lingkaran yang sesuai dengan prinsip terbuka tertutup. Dalam hal ini sebuah Shapeclass abstrak dibuat. Abstrak ini kelas memiliki fungsi murni virtual tunggal yang disebut Draw. Kedua Circleand Squareare turunan dari Shapeclass. Perhatikan bahwa jika kita ingin memperpanjang perilaku DrawAllShapesfunction di properti 2 untuk menarik jenis baru bentuk, semua yang perlu kita lakukan adalah menambahkan turunan baru dari Shapeclass. The DrawAllShapesfunction tidak perlu mengubah. Sehingga DrawAllShapesconforms prinsip terbuka tertutup. Perilakunya dapat diperpanjang tanpa modifikasi. Dalam dunia nyata Shapeclass akan memiliki lebih banyak metode. Namun menambahkan baru bentuk untuk aplikasi masih cukup sederhana karena semua yang diperlukan adalah untuk menciptakan baru derivatif dan melaksanakan semua fungsinya. Tidak perlu untuk berburu melalui semua aplikasi mencari tempat-tempat yang memerlukan perubahan. Sejak program yang sesuai dengan prinsip terbuka-tertutup diubah dengan menambahkan baru kode, bukan dengan mengubah kode yang ada, mereka tidak mengalami riam perubahan ditunjukkan oleh program yang tidak sesuai. Listing 2 OOD solusi untuk Square / Lingkaran masalah. class Shape {public: virtual void Draw () const = 0;}; class Square: Bentuk umum {public: virtual void Draw () const;}; kelas Lingkaran: Bentuk umum {public: virtual void Draw () const;}; kekosongan DrawAllShapes (Set




















































& Daftar)
{for (Iterator
i (daftar); i; i ++)
(* i) -> Menggambar
();}
6 Strategis Penutupan
Strategis Penutupan
Ini harus jelas bahwa tidak ada program yang signifikan bisa 100% tertutup. Sebagai contoh, perhatikan
apa yang akan terjadi DrawAllShapesfunction dari properti 2 jika kami memutuskan bahwa
semua Circlesshould ditarik sebelum Squares. DrawAllShapesfunction yang
tidak tertutup terhadap perubahan seperti ini. Secara umum, tidak peduli seberapa "ditutup" modul adalah, ada
akan selalu ada beberapa jenis perubahan terhadap yang tidak ditutup.
Karena penutupan tidak bisa lengkap, itu harus strategis. Artinya, perancang harus
memilih jenis perubahan terhadap yang untuk menutup desain. Ini mengambil sejumlah
dari pengetahuanNya berasal dari pengalaman. Desainer berpengalaman tahu pengguna dan
industri cukup baik untuk menilai probabilitas berbagai jenis perubahan. Dia kemudian membuat
memastikan bahwa prinsip terbuka tertutup dipanggil untuk perubahan yang paling mungkin.
Menggunakan Abstraksi Keuntungan eksplisit Penutupan.
Bagaimana kita bisa menutup DrawAllShapesfunction terhadap perubahan pemesanan
menggambar? Ingat penutupan yang didasarkan pada abstraksi. Dengan demikian, dalam rangka untuk menutup
DrawAllShapesagainst memesan, kami membutuhkan beberapa