.

0 (hodnocen0 x )

(1) Půjčeno:1x 

BK

Sixth edition

Global edition

Harlow : Pearson, [2017]

xxvii, 630 stran : barevné ilustrace ; 24 cm

ISBN 978-1-292-15904-1 (brožováno)

Always learning

Obsahuje rejstřík

001473795

Contents // Foreword // Preface // List of Projects Discussed in Detail in This Book Acknowledgments // xiv // XV // XXV // xxviii // Part 1 Foundations of Object Orientation 1 // Chapter 1 Objects and Classes 3 // 1.1 Objects and classes 3 // 1.2 Creating objects 4 // 1.3 Calling methods 5 // 1.4 Parameters 6 // 1.5 Data types 7 // 1.6 Multiple instances 8 // 1.7 State 9 // 1.8 What is in an object? 10 // 1.9 Java code 11 // 1.10 Object interaction 12 // 1.11 Source code 13 // 1.12 Another example 15 // 1.13 Return values 15 // 1.14 Objects as parameters 16 // 1.15 Summary 17 // Chapter 2 Understanding Class Definitions 21 // 2.1 Ticket machines 21 // 2.2 Examining a class definition 23 // 2.3 The class header 25 // 2.4 Fields, constructors, and methods 26 // 2.5 Parameters: receiving data 32 // 2.6 Assignment 34 // Contents // 2.7 Methods 35 // 2.8 Accessor and mutator methods 36 // 2.9 Printing from methods 39 // 2.10 Method summary 42 // 2.11 Summary of the naive ticket machine 42 // 2.12 Reflecting on the design of the ticket machine 43 // 2.13 Making choices: the conditional statement 45 // 2.14 A further conditional-statement example 47 // 2.15 Scope highlighting 48 // 2.16 Local variables 50 // 2.17 Fields, parameters, and local variables 51 // 2.18 Summary of the better ticket machine 53 // 2.19 Self-review exercises 53 // 2.20 Reviewing a familiar example 55 // 2.21 Calling methods 57 // 2.22 Experimenting with expressions: the Code Pad 59 // 2.23 Summary 61 // Chapter

3 Object Interaction 67 // 3.1 The clock example 67 // 3.2 Abstraction and modularization 68 // 3.3 Abstraction in software 69 // 3.4 Modularization in the clock example 69 // 3.5 Implementing the clock display 70 // ?.? Class diagrams versus object diagrams 71 // 3.7 Primitive types and object types 72 // 3.8 The NumberDi spi ay class 72 // 3.9 The Cl ockDi spi ay class 80 // 3.10 Objects creating objects 83 // 3.11 Multiple constructors 84 // 3.12 Method calls 84 // 3.13 Another example of object interaction 88 // 3.14 Using a debugger 92 // 3.15 Method calling revisited 96 // 3.16 Summary 97 // Chapter 4 Grouping Objects 101 // 4.1 Building on themes from Chapter 3 101 // 4.2 The collection abstraction 102 // Contents // VII // 4.3 An organizer for music files 103 // 4.4 Using a library class 104 // 4.5 Object structures with collections 107 // 4.6 Generic classes 109 // 4.7 Numbering within collections 110 // 4.8 Playing the music files 113 // 4.9 Processing a whole collection 115 // 4.10 Indefinite iteration 120 // 4.11 Improving structure—the Track class 128 // 4.12 The Iterator type 131 // 4.13 Summary of the music-organizer project 135 // 4.14 Another example: an auction system 137 // 4.15 Summary 147 // Chapter 5 Functional Processing of Collections (Advanced) 149 // 5.1 An alternative look at themes from Chapter 4 149 // 5.2 Monitoring animal populations 150 // 5.3 A first look at lambdas 154 // 5.4 The forEach method of collections 156 // 5.5 Streams 158 // 5.6 Summary

168 // Chapter 6 More-Sophisticated Behavior 171 // 6.1 Documentation for library classes 172 // 6.2 The TechSupport system 173 // 6.3 Reading class documentation 178 // 6.4 Adding random behavior 183 // 6.5 Packages and import 189 // 6.6 Using maps for associations 190 // 6.7 Using sets 195 // 6.8 Dividing strings 195 // 6.9 Finishing the TechSupport system 197 // 6.10 Autoboxing and wrapper classes 199 // 6.11 Writing class documentation 201 // 6.12 Public versus private 204 // 6.13 Learning about classes from their interfaces 206 // 6.14 Class variables and constants 211 // 6.15 Class methods 214 // 6.16 Executing without BlueJ 216 // Contents // 6.17 Further advanced material 216 // 6.18 Summary 220 // Chapter 7 Fixed-Size Collections—Arrays 223 // 7.1 Fixed-size collections 223 // 7.2 Arrays 224 // 7.3 A log-file analyzer 224 // 7.4 The for loop 230 // 7.5 The automaton project 236 // 7.6 Arrays of more than one dimension (advanced) 244 // 7.7 Arrays and streams (advanced) 251 // 7.8 Summary 252 // Chapter 8 Designing Classes 255 // 8.1 Introduction 256 // 8.2 The world-of-zuul game example 257 // 8.3 Introduction to coupling and cohesion 259 // 8.4 Code duplication 260 // 8.5 Making extensions 263 // 8.6 Coupling 266 // 8.7 Responsibility-driven design 270 // 8.8 Localizing change 273 // 8.9 Implicit coupling 274 // 8.10 Thinking ahead 277 // 8.11 Cohesion 278 // 8.12 Refactoring 282 // 8.13 Refactoring for language independence 286 // 8.14 Design guidelines 291 // 8.15

Summary 292 // Chapter 9 Well-Behaved Objects 295 // 9.1 Introduction 295 // 9.2 Testing and debugging 296 // 9.3 Unit testing within BlueJ 297 // 9.4 Test automation 304 // 9.5 Refactoring to use with streams (advanced) 311 // 9.6 Debugging 312 // 9.7 Commenting and style 314 // 9.8 Manual walkthroughs 315 // Contents // ix // 9.9 Print Statements 320 // 9.10 Debuggers 324 // 9.11 Debugging streams (advanced) 325 // 9.12 Choosing a debugging strategy 326 // 9.13 Putting the techniques into practice 327 // 9.14 Summary • 327 // Part 2 Application Structures 329 // Chapter 10 Improving Structure with Inheritance 331 // 10.1 The network example 331 // 10.2 Using inheritance 343 // 10.3 Inheritance hierarchies 345 // 10.4 Inheritance in Java 345 // 10.5 Network: adding other post types 349 // 10.6 Advantages of inheritance (so far) 351 // 10.7 Subtyping 352 // 10.8 The Object class 358 // 10.9 The collection hierarchy 359 // 10.10 Summary 360 // Chapter 11 More about Inheritance 363 // 11.1 The problem: network’s display method 363 // 11.2 Static type and dynamic type 365 // 11.3 Overriding 368 // 11.4 Dynamic method lookup 370 // 11.5 super call in methods 373 // 11.6 Method polymorphism 374 // 11.7 Object methods: toString 374 // 11.8 Object equality: equal s and hashCode 377 // 11.9 Protected access 37g // 11.10 The instanceof operator 381 // 11.11 Another example of inheritance with overriding 382 // 11.12 Summary 385 // Chapter 12 Further Abstraction Techniques 389 // 12.1

Simulations 389 // 12.2 The foxes-and-rabbits simulation 390 // 12.3 Abstract classes 405 // Contents // 12.4 More abstract methods 412 // 12.5 Multiple inheritance 414 // 12.6 Interfaces 417 // 12.7 A further example of interfaces 425 // 12.8 The Class class 427 // 12.9 Abstract class or interface? 427 // 12.10 Event-driven simulations 428 // 12.11 Summary of inheritance 429 // 12.12 Summary 430 // Chapter 13 Building Graphical User Interfaces 433 // 13.1 Introduction 433 // 13.2 Components, layout, and event handling 434 // 13.3 AWT and Swing 435 // 13.4 The ImageViewer example 435 // 13.5 ImageViewer 1.0: the first complete version 447 // 13.6 ImageViewer 2.0: improving program structure 461 // 13.7 ImageViewer 3.0: more interface components 467 // 13.8 Inner classes 471 // 13.9 Further extensions 476 // 13.10 Another example: MusicPIayer 478 // 13.11 Summary 481 // Chapter 14 Handling Errors 483 // 14.1 The address-book project 484 // 14.2 Defensive programming 488 // 14.3 Server error reporting 491 // 14.4 Exception-throwing principles 495 // 14.5 Exception handling 501 // 14.6 Defining new exception classes 508 // 14.7 Using assertions 510 // 14.8 Error recovery and avoidance 513 // 14.9 File-based input/output 516 // 14.10 Summary 527 // Chapter 15 Designing Applications 529 // 15.1 Analysis and design 529 // 15.2 Class design 536 // 15.3 Documentation 538 // Contents // XI // 15.4 Cooperation 539 // 15.5 Prototyping 539 // 15.6 Software growth 540 // 15.7 Using design

patterns 542 // 15.8 Summary 548 // Chapter 16 A Case Study 551 // 16.1 The case study 551 // 16.2 Analysis and design 552 // 16.3 Class design 556 // 16.4 Iterative development 561 // 16.5 Another example 570 // 16.6 Taking things further 570 // Appendix A: Working with a BlueJ Project 571 // A.1 Installing BlueJ 571 // A.2 Opening a project 571 // ?.? The BlueJ debugger 571 // A.4 Configuring BlueJ 571 // A.5 Changing the interface language 572 // A.6 Using local API documentation 572 // A.7 Changing the new class templates 572 // Appendix B: Java Data Types 573 // B.1 Primitive types 573 // B.2 Casting of primitive types 574 // B.3 Object types 574 // B.4 Wrapper classes 575 // B.5 Casting of object types 575 // Appendix C: Operators 577 // C.1 Arithmetic expressions 577 // C.2 Boolean expressions 578 // C.3 Short-circuit operators 579 // Appendix D: Java Control Structures 581 // D.1 Control structures 581 // D.2 Selection statements 581 // XII // Contents // D.3 Loops 583 // D.4 Exceptions 585 // D.5 Assertions 587 // Appendix E: Running Java without BlueJ 589 // E.1 Executing without BlueJ 589 // E.2 Creating executable .jar files 591 // E.3 Developing without BlueJ 591 // Appendix F: Using the Debugger 593 // F. 1 Breakpoints 594 // F. 2 The control buttons 594 // F3 The variable displays 595 // F. 4 The Call Sequence display 596 // F 5 The Threads display 596 // Appendix G: JUnit Unit-Testing Tools 597 // G.1 Enabling unit-testing functionality 597 // G.2 Creating a test

class 597 // G.3 Creating a test method 597 // G.4 Test assertions 598 // G.5 Running tests 598 // G.6 Fixtures 598 // Appendix H: Teamwork Tools 599 // H.1 Server setup 599 // H.2 Enabling teamwork functionality 599 // H.3 Sharing a project 599 // H.4 Using a shared project 599 // H.5 Update and commit 600 // H.6 More information 600 // Appendix 1: Javadoc 601 // 1.1 Documentation comments 601 // 1.2 BlueJ support for javadoc 603 // Appendix J; Program Style Guide 605 // J.1 Naming 605 // J.2 Layout 605 // Contents xiii // J.3 Documentation 606 // J.4 Language-use restrictions 607 // J.5 Code idioms 608 // Appendix ?: Important Library Classes 609 // K.1 The j ava. 1 ang package 609 // ?.2 The java.util package 610 // ?.? The j ava. i ? and j ava. ni o. f i 1 e packages 611 // ?.4 The j ava .util, function package 612 // ?.5 The j ava. net package 612 // ?.6 Other important packages 613 // Index 615