Muutke küpsiste eelistusi

Introduction to Software Design with Java 1st ed. 2019 [Pehme köide]

4.50/5 (4 hinnangut Goodreads-ist)
  • Formaat: Paperback / softback, 297 pages, kõrgus x laius: 235x155 mm, kaal: 480 g, 100 Illustrations, black and white; XII, 297 p. 100 illus., 1 Paperback / softback
  • Ilmumisaeg: 17-Jul-2019
  • Kirjastus: Springer Nature Switzerland AG
  • ISBN-10: 3030240932
  • ISBN-13: 9783030240936
Teised raamatud teemal:
  • Pehme köide
  • Hind: 61,10 €*
  • * saadame teile pakkumise kasutatud raamatule, mille hind võib erineda kodulehel olevast hinnast
  • See raamat on trükist otsas, kuid me saadame teile pakkumise kasutatud raamatule.
  • Kogus:
  • Lisa ostukorvi
  • Tasuta tarne
  • Lisa soovinimekirja
Introduction to Software Design with Java 1st ed. 2019Suurem pilt
  • Formaat: Paperback / softback, 297 pages, kõrgus x laius: 235x155 mm, kaal: 480 g, 100 Illustrations, black and white; XII, 297 p. 100 illus., 1 Paperback / softback
  • Ilmumisaeg: 17-Jul-2019
  • Kirjastus: Springer Nature Switzerland AG
  • ISBN-10: 3030240932
  • ISBN-13: 9783030240936
Teised raamatud teemal:
Püsilink: https://www.kriso.ee/db/9783030240936.html
This textbook provides an in-depth introduction to software design, with a focus on object-oriented design, and using the Java programming language. Its goal is to help readers learn software design by discovering the experience of the design process. To this end, a narrative is used that introduces each element of design know-how in context, and explores alternative solutions in that context. The narrative is supported by hundreds of code fragments and design diagrams.

The first chapter is a general introduction to software design. The subsequent chapters cover design concepts and techniques, which are presented as a continuous narrative anchored in specific design problems. The design concepts and techniques covered include effective use of types and interfaces, encapsulation, composition, inheritance, design patterns, unit testing, and many more. A major emphasis is placed on coding and experimentation as a necessary complement to reading the text. To support this aspect of the learning process, a companion website with practice problems is provided, and three sample applications that capture numerous design decisions are included. Guidance on these sample applications is provided in a section called “Code Exploration” at the end of each chapter. Although the Java language is used as a means of conveying design-related ideas, the book’s main goal is to address concepts and techniques that are applicable in a host of technologies.

This book is intended for readers who have a minimum of programming experience and want to move from writing small programs and scripts to tackling the development of larger systems. This audience naturally includes students in university-level computer science and software engineering programs. As the prerequisites to specific computing concepts are kept to a minimum, the content is also accessible to programmers without a primary training in computing. In a similar vein, understanding the code fragments requires only a minimal grasp of the language, such as would be taught in an introductory programming course.
1 Introduction
1(12)
1.1 Defining Software Design
4(2)
1.2 Design in the Software Development Process
6(1)
1.3 Capturing Design Knowledge
7(2)
1.4 Sharing Design Know-How
9(2)
Insights
11(1)
Further Reading
12(1)
2 Encapsulation
13(26)
2.1 Encapsulation and Information Hiding
14(1)
2.2 Encoding Abstractions as Types
14(4)
2.3 Scopes and Visibility Restrictions
18(2)
2.4 Object Diagrams
20(3)
2.5 Escaping References
23(3)
2.6 Immutability
26(2)
2.7 Exposing Internal Data
28(3)
2.8 Design by Contract
31(3)
Insights
34(1)
Code Exploration
34(3)
Further Reading
37(2)
3 Types and Interfaces
39(22)
3.1 Decoupling Behavior from Implementation
40(3)
3.2 Specifying Behavior with Interfaces
43(2)
3.3 Class Diagrams
45(2)
3.4 Function Objects
47(3)
3.5 Iterators
50(3)
3.6 The Iterator Design Pattern
53(1)
3.7 The Strategy Design Pattern
54(1)
3.8 The Interface Segregation Principle
55(3)
Insights
58(1)
Code Exploration
59(1)
Further Reading
60(1)
4 Object State
61(30)
4.1 The Static and Dynamic Perspectives of a Software System
61(1)
4.2 Defining Object State
62(2)
4.3 State Diagrams
64(2)
4.4 Designing Object Life Cycles
66(2)
4.5 Nullability
68(6)
4.6 Final Fields and Variables
74(2)
4.7 Object Identity, Equality, and Uniqueness
76(3)
4.8 The Flyweight Design Pattern
79(3)
4.9 The Singleton Design Pattern
82(1)
4.10 Objects of Nested Classes
83(4)
Insights
87(1)
Code Exploration
88(1)
Further Reading
89(2)
5 Unit Testing
91(28)
5.1 Introduction to Unit Testing
92(2)
5.2 Unit Testing Framework Fundamentals with JUnit
94(2)
5.3 Organizing Test Code
96(1)
5.4 Metaprogramming
97(5)
5.5 Structuring Tests
102(4)
5.6 Tests and Exceptional Conditions
106(2)
5.7 Encapsulation and Unit Testing
108(2)
5.8 Testing with Stubs
110(3)
5.9 Test Coverage
113(3)
Insights
116(1)
Code Exploration
117(1)
Further Reading
118(1)
6 Composition
119(36)
6.1 Composition and Aggregation
120(3)
6.2 The Composite Design Pattern
123(4)
6.3 Sequence Diagrams
127(4)
6.4 The Decorator Design Pattern
131(5)
6.5 Combining Composite and Decorator
136(2)
6.6 Polymorphic Object Copying
138(5)
6.7 The Prototype Design Pattern
143(2)
6.8 The Command Design Pattern
145(3)
6.9 The Law of Demeter
148(2)
Insights
150(1)
Code Exploration
150(2)
Further Reading
152(3)
7 Inheritance
155(36)
7.1 The Case for Inheritance
156(2)
7.2 Inheritance and Typing
158(3)
7.3 Inheriting Fields
161(3)
7.4 Inheriting Methods
164(4)
7.5 Overloading Methods
168(2)
7.6 Inheritance Versus Composition
170(2)
7.7 Abstract Classes
172(3)
7.8 Revisiting the Decorator Design Pattern
175(2)
7.9 The Template Method Design Pattern
177(4)
7.10 Proper Use of Inheritance
181(5)
Insights
186(1)
Code Exploration
187(2)
Further Reading
189(2)
8 Inversion of Control
191(46)
8.1 Motivating Inversion of Control
192(2)
8.2 The Model--View--Controller Decomposition
194(1)
8.3 The Observer Design Pattern
195(10)
8.4 Applying the Observer Design Pattern
205(3)
8.5 Introduction to Graphical User Interface Development
208(3)
8.6 Graphical User Interface Component Graphs
211(6)
8.7 Event Handling
217(4)
8.8 The Visitor Design Pattern
221(12)
Insights
233(1)
Code Exploration
234(2)
Further Reading
236(1)
9 Functional Design
237(36)
9.1 First-Class Functions
238(1)
9.2 Functional Interfaces, Lambda Expressions, and Method References
239(7)
9.3 Using Functions to Compose Behavior
246(4)
9.4 Using Functions as Suppliers of Data
250(7)
9.5 First-Class Functions and Design Patterns
257(4)
9.6 Functional-Style Data Processing
261(8)
Insights
269(1)
Code Exploration
269(3)
Further Reading
272(1)
A Important Java Programming Concepts
273(8)
A.1 Variables and Types
273(1)
A.2 Objects and Classes
274(1)
A.3 Static Fields
275(1)
A.4 Methods
275(2)
A.5 Packages and Importing
277(1)
A.6 Generic Types
277(1)
A.7 Collection Classes
278(1)
A.8 Exception Handling
279(2)
B Coding Conventions
281(4)
C Example Applications
285(2)
References 287(2)
Index 289
Martin Robillard is a Professor of Computer Science at McGill University. He has been teaching software design with Java since 2005, and has over two decades of programming experience in Java. His current research focuses on problems related to software evolution, architecture and design, and software reuse. Martin served as the Program Co-Chair for the 20th ACM SIGSOFT International Symposium on the Foundations of Software Engineering (FSE 2012) and the 39th ACM/IEEE International Conference on Software Engineering (ICSE 2017).