ورود به حساب

نام کاربری گذرواژه

گذرواژه را فراموش کردید؟ کلیک کنید

حساب کاربری ندارید؟ ساخت حساب

ساخت حساب کاربری

نام نام کاربری ایمیل شماره موبایل گذرواژه

برای ارتباط با ما می توانید از طریق شماره موبایل زیر از طریق تماس و پیامک با ما در ارتباط باشید


09117307688
09117179751

در صورت عدم پاسخ گویی از طریق پیامک با پشتیبان در ارتباط باشید

دسترسی نامحدود

برای کاربرانی که ثبت نام کرده اند

ضمانت بازگشت وجه

درصورت عدم همخوانی توضیحات با کتاب

پشتیبانی

از ساعت 7 صبح تا 10 شب

دانلود کتاب Refactoring - Improving the Design of Existing Code

دانلود کتاب Refactoring - بهبود طراحی کد موجود

Refactoring - Improving the Design of Existing Code

مشخصات کتاب

Refactoring - Improving the Design of Existing Code

دسته بندی: کامپیوتر
ویرایش: 1 
نویسندگان: , , , ,   
سری:  
ISBN (شابک) : 9780201485677, 0201485672 
ناشر: Addison-Wesley Professional 
سال نشر: 1999 
تعداد صفحات: 337 
زبان: English 
فرمت فایل : PDF (درصورت درخواست کاربر به PDF، EPUB یا AZW3 تبدیل می شود) 
حجم فایل: 2 مگابایت 

قیمت کتاب (تومان) : 52,000



ثبت امتیاز به این کتاب

میانگین امتیاز به این کتاب :
       تعداد امتیاز دهندگان : 9


در صورت تبدیل فایل کتاب Refactoring - Improving the Design of Existing Code به فرمت های PDF، EPUB، AZW3، MOBI و یا DJVU می توانید به پشتیبان اطلاع دهید تا فایل مورد نظر را تبدیل نمایند.

توجه داشته باشید کتاب Refactoring - بهبود طراحی کد موجود نسخه زبان اصلی می باشد و کتاب ترجمه شده به فارسی نمی باشد. وبسایت اینترنشنال لایبرری ارائه دهنده کتاب های زبان اصلی می باشد و هیچ گونه کتاب ترجمه شده یا نوشته شده به فارسی را ارائه نمی دهد.


توضیحاتی در مورد کتاب Refactoring - بهبود طراحی کد موجود

از آنجایی که استفاده از فناوری شی - به ویژه زبان برنامه نویسی جاوا - رایج شده است، مشکل جدیدی برای رویارویی با جامعه توسعه نرم افزار پدیدار شده است. تعداد قابل توجهی از برنامه‌های ضعیف طراحی شده توسط توسعه‌دهندگان کم‌تجربه ایجاد شده‌اند که در نتیجه برنامه‌هایی ناکارآمد هستند و نگهداری و گسترش آن‌ها سخت است. به طور فزاینده‌ای، متخصصان سیستم نرم‌افزاری متوجه می‌شوند که کار با این برنامه‌های کاربردی \"غیر بهینه\" ارثی چقدر دشوار است. برای چندین سال، برنامه نویسان شی در سطح متخصص از مجموعه رو به رشدی از تکنیک ها برای بهبود یکپارچگی ساختاری و عملکرد چنین برنامه های نرم افزاری موجود استفاده کرده اند. این شیوه‌ها که به عنوان \"بازسازی\" نامیده می‌شود، در حوزه کارشناسان باقی مانده است زیرا هیچ تلاشی برای رونویسی اطلاعات به شکلی که همه توسعه‌دهندگان بتوانند از آن استفاده کنند، صورت نگرفته است. . .تا به حال. در Refactoring: Improving the Design of Existing Code، مارتین فاولر، مربی مشهور فن‌آوری شی، زمینه جدیدی را ایجاد می‌کند، این شیوه‌های اصلی را ابهام‌زدایی می‌کند و نشان می‌دهد که چگونه متخصصان نرم‌افزار می‌توانند به مزایای قابل توجه این فرآیند جدید پی ببرند. با آموزش مناسب، یک طراح سیستم ماهر می‌تواند یک طرح بد را انتخاب کند و آن را به کدهایی با طراحی خوب و قوی تبدیل کند. در این کتاب، مارتین فاولر به شما نشان می‌دهد که معمولاً کجا می‌توان فرصت‌هایی برای بازسازی مجدد پیدا کرد و چگونه می‌توان یک طرح بد را به یک طرح خوب تبدیل کرد. هر مرحله بازسازی ساده است - به ظاهر بسیار ساده است که ارزش انجام آن را ندارد. Refactoring ممکن است شامل انتقال یک فیلد از یک کلاس به کلاس دیگر، یا بیرون کشیدن کد از یک متد برای تبدیل آن به متد خاص خود، یا حتی فشار دادن برخی کدها به بالا یا پایین سلسله مراتب باشد. در حالی که این مراحل فردی ممکن است ابتدایی به نظر برسند، اثر تجمعی چنین تغییرات کوچکی می تواند به طور اساسی طراحی را بهبود بخشد. Refactoring یک راه اثبات شده برای جلوگیری از پوسیدگی نرم افزار است. نویسنده علاوه بر بحث در مورد تکنیک‌های مختلف بازسازی، فهرست مفصلی از بیش از هفتاد بازسازی اثبات‌شده را همراه با نکات مفیدی ارائه می‌کند که به شما یاد می‌دهد چه زمانی آنها را اعمال کنید. دستورالعمل های گام به گام برای اعمال هر بازآفرینی؛ و مثالی که نحوه عملکرد refactoring را نشان می دهد. مثال‌های گویا در جاوا نوشته شده‌اند، اما ایده‌ها برای هر زبان برنامه‌نویسی شی گرا قابل اجرا هستند.


توضیحاتی درمورد کتاب به خارجی

As the application of object technology - particularly the Java programming language - has become commonplace, a new problem has emerged to confront the software development community. Significant numbers of poorly designed programs have been created by less-experienced developers, resulting in applications that are inefficient and hard to maintain and extend. Increasingly, software system professionals are discovering just how difficult it is to work with these inherited, "non-optimal" applications. For several years, expert-level object programmers have employed a growing collection of techniques to improve the structural integrity and performance of such existing software programs. Referred to as "refactoring," these practices have remained in the domain of experts because no attempt has been made to transcribe the lore into a form that all developers could use. . .until now. In Refactoring: Improving the Design of Existing Code, renowned object technology mentor Martin Fowler breaks new ground, demystifying these master practices and demonstrating how software practitioners can realize the significant benefits of this new process. With proper training a skilled system designer can take a bad design and rework it into well-designed, robust code. In this book, Martin Fowler shows you where opportunities for refactoring typically can be found, and how to go about reworking a bad design into a good one. Each refactoring step is simple - seemingly too simple to be worth doing. Refactoring may involve moving a field from one class to another, or pulling some code out of a method to turn it into its own method, or even pushing some code up or down a hierarchy. While these individual steps may seem elementary, the cumulative effect of such small changes can radically improve the design. Refactoring is a proven way to prevent software decay. In addition to discussing the various techniques of refactoring, the author provides a detailed catalog of more than seventy proven refactorings with helpful pointers that teach you when to apply them; step-by-step instructions for applying each refactoring; and an example illustrating how the refactoring works. The illustrative examples are written in Java, but the ideas are applicable to any object-oriented programming language.



فهرست مطالب

Refactoring - Wie Sie das Design vorhandener Software verbessern......Page 3
3 Übel riechender Code......Page 7
6 Methoden zusammenstellen......Page 8
9 Bedingte Ausdrücke vereinfachen......Page 9
11 Der Umgang mit der Generalisierung......Page 10
Stichwortverzeichnis......Page 11
Vorwort des Übersetzers......Page 13
Geleitwort......Page 15
Vorwort......Page 17
Was ist Refaktorisieren?......Page 18
Was finden Sie in diesem Buch?......Page 19
Warum sollten Sie dieses Buch lesen?......Page 20
Von anderen erarbeitete Grundlagen......Page 21
Danksagungen......Page 22
1.1 Der Ausgangspunkt......Page 25
1.1.1 Movie......Page 26
1.1.3 Customer......Page 27
1.1.4 Kommentare zum Ausgangsprogramm......Page 29
1.2 Der erste Faktorisierungsschritt......Page 31
1.3 Zerlegen und Umverteilen der Methode......Page 32
1.3.1 Verschieben der Betragsberechnung......Page 37
1.3.2 Extrahieren der Bonuspunkte......Page 43
1.3.3 Entfernen temporärer Variablen......Page 46
1.4 Ersetzen der Bedingung durch Polymorphismus......Page 52
1.4.1 Zu guter Letzt ... Vererbung......Page 55
1.5 Schlussgedanken......Page 64
2.1 Definition des Refaktorisierens......Page 65
2.1.1 Die zwei Hüte......Page 66
2.2.1 Refaktorisieren verbessert das Design von Software......Page 67
2.2.2 Refaktorisieren macht Software leichter verständlich......Page 68
2.2.4 Refaktorisieren hilft Ihnen schneller zu programmieren......Page 69
2.3.2 Refaktorisieren Sie beim Hinzufügen von Funktionen......Page 70
2.3.4 Refaktorisieren Sie bei Code-Reviews......Page 71
2.4 Wie sag ich’s meinem Chef?......Page 73
2.5 Probleme beim Refaktorisieren......Page 76
2.5.2 Veränderung von Schnittstellen......Page 77
2.5.3 Schwer durchzuführende Entwurfsänderungen......Page 79
2.5.4 Wann sollten Sie nicht refaktorisieren?......Page 80
2.6 Refaktorisieren und Design......Page 81
2.7 Refaktorisieren und Performance......Page 84
2.8 Woher stammt Refaktorisieren?......Page 86
3 Übel riechender Code......Page 91
3.1 Duplizierter Code......Page 92
3.2 Lange Methode......Page 93
3.3 Große Klasse......Page 95
3.5 Divergierende Änderungen......Page 96
3.6 Schrotkugeln herausoperieren......Page 97
3.8 Datenklumpen......Page 98
3.9 Neigung zu elementaren Typen......Page 99
3.10 Befehle......Page 100
3.13 Spekulative Allgemeinheit......Page 101
3.15 Nachrichtenketten......Page 102
3.17 Unangebrachte Intimität......Page 103
3.19 Unvollständige Bibliotheksklasse......Page 104
3.21 Ausgeschlagenes Erbe......Page 105
3.22 Kommentare......Page 106
4.1 Der Wert selbst testenden Codes......Page 107
4.2 Das JUnit-Test-Framework......Page 110
4.3 Komponenten- und Funktionstest......Page 116
4.4 Hinzufügen weiterer Tests......Page 117
5.1 Gliederung der Refaktorisierungen......Page 123
5.2 Finden von Referenzierungen......Page 125
5.3 Wie ausgereift sind diese Refaktorisierungen?......Page 127
6 Methoden zusammenstellen......Page 129
6.1.1 Motivation......Page 130
6.1.2 Vorgehen......Page 131
6.1.3 Beispiel: Ohne lokale Variablen......Page 132
6.1.4 Beispiel: Einsatz lokaler Variablen......Page 133
6.1.5 Beispiel: Neue Zuweisung einer lokalen Variablen......Page 134
6.2.1 Motivation......Page 138
6.2.2 Vorgehen......Page 139
6.3.2 Vorgehen......Page 140
6.4.1 Motivation......Page 141
6.4.2 Vorgehen......Page 142
6.4.3 Beispiel......Page 143
6.5.1 Motivation......Page 145
6.5.3 Beispiel......Page 146
6.5.4 Beispiel mit Methode extrahieren......Page 147
6.6.1 Motivation......Page 149
6.6.3 Beispiel......Page 150
6.7.1 Motivation......Page 152
6.7.2 Vorgehen......Page 153
6.7.4 Übergabe von Werten in Java......Page 154
6.8 Methode durch Methodenobjekt ersetzen......Page 156
6.8.2 Vorgehen......Page 157
6.8.3 Beispiel......Page 158
6.9.1 Motivation......Page 160
6.9.2 Vorgehen......Page 161
7.1 Methode verschieben......Page 163
7.1.1 Motivation......Page 164
7.1.2 Vorgehen......Page 165
7.1.3 Beispiel......Page 166
7.2 Feld verschieben......Page 168
7.2.2 Vorgehen......Page 169
7.2.3 Beispiel......Page 170
7.2.4 Beispiel mit Kapselung eines eigenen Feldes......Page 171
7.3.1 Motivation......Page 172
7.3.3 Beispiel......Page 173
7.4.2 Vorgehen......Page 177
7.4.3 Beispiel......Page 178
7.5 Delegation verbergen......Page 179
7.5.2 Vorgehen......Page 180
7.5.3 Beispiel......Page 181
7.6 Vermittler entfernen......Page 182
7.6.3 Beispiel......Page 183
7.7.1 Motivation......Page 185
7.7.3 Beispiel......Page 186
7.8.1 Motivation......Page 187
7.8.3 Beispiele......Page 188
7.8.4 Beispiel: Verwenden einer Unterklasse......Page 189
7.8.5 Beispiel: Verwenden einer Hülle......Page 190
8 Daten organisieren......Page 193
8.1.1 Motivation......Page 195
8.1.3 Beispiel......Page 196
8.2.2 Vorgehen......Page 199
8.2.3 Beispiel......Page 200
8.3.1 Motivation......Page 203
8.3.3 Beispiel......Page 204
8.4.1 Motivation......Page 207
8.4.3 Beispiel......Page 208
8.5.2 Vorgehen......Page 210
8.5.3 Beispiel......Page 211
8.6.1 Motivation......Page 214
8.6.2 Vorgehen......Page 215
8.6.3 Beispiel......Page 216
8.6.4 Die Verwendung von Ereignisbeobachtern......Page 222
8.7.1 Motivation......Page 223
8.7.3 Beispiel......Page 224
8.8.1 Motivation......Page 227
8.8.2 Vorgehen......Page 228
8.8.3 Beispiel......Page 229
8.9.1 Motivation......Page 232
8.10.1 Motivation......Page 233
8.10.2 Vorgehen......Page 234
8.11.2 Vorgehen......Page 235
8.11.4 Beispiel: Java 2......Page 237
8.11.5 Verhalten in die Klasse verschieben......Page 240
8.11.6 Beispiel: Java 1.1......Page 241
8.11.7 Beispiel: Arrays kapseln......Page 243
8.12.1 Motivation......Page 244
8.13.1 Motivation......Page 245
8.13.2 Vorgehen......Page 246
8.13.3 Beispiel......Page 247
8.14.1 Motivation......Page 251
8.14.2 Vorgehen......Page 252
8.14.3 Beispiel......Page 253
8.15.2 Vorgehen......Page 255
8.15.3 Beispiel......Page 256
8.16.1 Motivation......Page 260
8.16.2 Vorgehen......Page 261
8.16.3 Beispiel......Page 262
9 Bedingte Ausdrücke vereinfachen......Page 265
9.1.2 Vorgehen......Page 266
9.1.3 Beispiel......Page 267
9.2.1 Motivation......Page 268
9.2.3 Beispiel: Oder......Page 269
9.2.4 Beispiel: Und......Page 270
9.3.2 Vorgehen......Page 271
9.4 Steuerungsvariable entfernen......Page 272
9.4.2 Vorgehen......Page 273
9.4.3 Beispiel: Eine einfache Steuerungsvariable durch ersetzen......Page 274
9.4.4 Beispiel: Verwendung von return mit einer Steuerungsvariablen als Ergebnis......Page 276
9.5 Geschachtelte Bedingungen durch Wächterbedingungen ersetzen......Page 278
9.5.2 Vorgehen......Page 279
9.5.3 Beispiel......Page 280
9.5.4 Beispiel: Bedingungen umdrehen......Page 281
9.6 Bedingten Ausdruck durch Polymorphismus ersetzen......Page 283
9.6.2 Vorgehen......Page 284
9.6.3 Beispiel......Page 285
9.7 Null-Objekt einführen......Page 288
9.7.1 Motivation......Page 289
9.7.2 Vorgehen......Page 290
9.7.3 Beispiel......Page 291
9.7.4 Beispiel: Eine testende Schnittstelle......Page 295
9.7.5 Andere Sonderfälle......Page 296
9.8.1 Motivation......Page 297
9.8.3 Beispiel......Page 298
10 Methodenaufrufe vereinfachen......Page 301
10.1.1 Motivation......Page 303
10.1.3 Beispiel......Page 304
10.2.1 Motivation......Page 305
10.2.2 Vorgehen......Page 306
10.3.1 Motivation......Page 307
10.3.2 Vorgehen......Page 308
10.4.2 Vorgehen......Page 309
10.4.3 Beispiel......Page 310
10.5.1 Motivation......Page 313
10.5.3 Beispiel......Page 314
10.6.1 Motivation......Page 316
10.6.3 Beispiel......Page 317
10.7.1 Motivation......Page 319
10.7.2 Vorgehen......Page 320
10.7.3 Beispiel......Page 321
10.8.1 Motivation......Page 323
10.8.3 Beispiel......Page 324
10.9.2 Vorgehen......Page 327
10.9.3 Beispiel......Page 328
10.10.1 Motivation......Page 332
10.10.3 Beispiel......Page 333
10.11.2 Vorgehen......Page 336
10.12.1 Motivation......Page 337
10.12.3 Beispiel......Page 338
10.12.4 Beispiel: Unterklasse mit einem String erzeugen......Page 339
10.12.5 Unterklasse mit expliziten Methoden erzeugen......Page 340
10.13.1 Motivation......Page 341
10.13.3 Beispiel......Page 342
10.14 Fehlercode durch Ausnahme ersetzen......Page 343
10.14.2 Vorgehen......Page 344
10.14.3 Beispiel......Page 345
10.14.4 Beispiel: Nicht überwachte Ausnahme......Page 346
10.14.5 Beispiel: Überwachte Ausnahme......Page 347
10.15.1 Motivation......Page 349
10.15.3 Beispiel......Page 350
11 Der Umgang mit der Generalisierung......Page 353
11.1.2 Vorgehen......Page 354
11.2.1 Motivation......Page 355
11.2.2 Vorgehen......Page 356
11.2.3 Beispiel......Page 357
11.3 Konstruktorrumpf nach oben verschieben......Page 358
11.3.2 Vorgehen......Page 359
11.3.3 Beispiel......Page 360
11.4 Methode nach unten verschieben......Page 361
11.4.2 Vorgehen......Page 362
11.5.2 Vorgehen......Page 363
11.6.2 Vorgehen......Page 364
11.6.3 Beispiel......Page 366
11.7.1 Motivation......Page 370
11.7.2 Vorgehen......Page 371
11.7.3 Beispiel......Page 372
11.8 Schnittstelle extrahieren......Page 375
11.8.2 Vorgehen......Page 376
11.8.3 Beispiel......Page 377
11.9.2 Vorgehen......Page 378
11.10 Template-Methode bilden......Page 379
11.10.3 Beispiel......Page 380
11.11 Vererbung durch Delegation ersetzen......Page 387
11.11.2 Vorgehen......Page 388
11.11.3 Beispiel......Page 389
11.12 Delegation durch Vererbung ersetzen......Page 390
11.12.2 Vorgehen......Page 391
11.12.3 Beispiel......Page 392
12.1 Der Sinn des Spiels......Page 395
12.2 Warum große Refaktorisierungen so wichtig sind......Page 396
12.3 Vier große Refaktorisierungen......Page 397
12.4 Vererbungsstrukturen entzerren......Page 398
12.4.2 Vorgehen......Page 399
12.4.3 Beispiele......Page 400
12.5 Prozedurale Entwürfe in Objekte überführen......Page 404
12.5.2 Vorgehen......Page 405
12.6.1 Motivation......Page 406
12.6.2 Vorgehen......Page 407
12.6.3 Beispiel......Page 408
12.7 Hierarchie extrahieren......Page 411
12.7.2 Vorgehen......Page 412
12.7.3 Beispiel......Page 413
13 Refaktorisieren, Recycling und Realität......Page 417
13.1 Eine Nagelprobe......Page 418
13.2 Warum weigern sich Entwickler, ihre eigenen Programme zu refaktorisieren?......Page 420
13.2.1 Wie und wann refaktorisiert man?......Page 421
13.2.2 Refaktorisieren, um kurzfristige Ziele zu erreichen......Page 427
13.2.3 Den Aufwand für Refaktorisieren verringern......Page 430
13.2.4 Sicheres Refaktorisieren......Page 431
13.3 Eine zweite Nagelprobe......Page 435
13.4 Quellen und Belege zum Refaktorisieren......Page 436
13.5 Konsequenzen für Wiederverwendung und Techniktransfer......Page 437
13.6 Eine letzte Bemerkung......Page 438
13.7 Literatur......Page 439
14.1 Refaktorisieren mit einem Werkzeug......Page 441
14.2.1 Programmdatenbank......Page 443
14.2.2 Ableitungsbäume......Page 444
14.2.3 Genauigkeit......Page 445
14.3.2 Rückgängig machen......Page 446
14.3.4 Zusammenfassung......Page 447
15 Schlusswort......Page 449
16 Literatur......Page 453
17 Liste der Merksätze......Page 457
C......Page 459
G......Page 460
M......Page 461
P......Page 462
T......Page 463
Z......Page 464
Liste der Refaktorisierungen......Page 465
Ins Internet: Weitere Infos zum Buch, Downloads, etc.......Page 0




نظرات کاربران