Job Ready Java

About the Authors v About the Technical Writer vii About the Technical Editors vii Acknowledgments ix Introduction xxv Part I: Getting Set Up 1 Lesson 1: Installing Java 2 The Java Universe 3 The Java Development Kit 3 The Java Virtual Machine 4 The Java Runtime Environment 5 Installing OpenJDK 5 Installing OpenJDK on Microsoft Windows 6 Checking for an Existing JDK on Windows 6 Installing OpenJDK 7 Verifying the Installation 10 Installing OpenJDK on macOS 13 Checking for an Existing JDK on macOS 13 Installing OpenJDK 13 Verifying the Installation 17 Creating Your First Java Program 17 Writing the Program 18 Compiling and Running the Program 19 Dealing with Syntax Errors 21 Using the Compiler and Java Virtual Machine 22 Summary 22 Lesson 2: Installing a Development Environment: NetBeans 24 Getting Started 25 Understanding the Value of an IDE 25 Using the Source Code Editor 25 Using the Build Automation Tools 26 Using the Debugger 26 Installing NetBeans 27 Using an Installer 27 Installing on Windows 28 Installing on macOS 32 Installing Binaries 37 Installing Binaries on Windows 40 Adding the JDK 42 Running NetBeans 44 Summary 45 Lesson 3: Using an Integrated Development Environment 46 Using an IDE 47 Creating a New Project 48 Coding the “Hello, World!” Program 53 Compiling the Code in NetBeans 57 Running the Program 59 Using the Debugging Tools 60 Compilation and Syntax Errors 61 Runtime and Logic Errors 63 Understanding Source Control 67 Summary 69 Part II: Basics of Object Oriented Programming 70 Lesson 4: Using Program Statements and Variables 71 Approach 72 Concepts 73 Computers 73 Data vs. Information 73 Programs and Programming 74 Models and Metaphors 74 Objects 74 Specifications 75 Syntax vs. Semantics 75 Language Building Blocks 75 Comments 75 Single-Line Comments 76 Multiline Comments 76 Doc Comments 77 Using Comments 78 Identifiers 79 Data Types 80 Statically Typed Languages 81 Type Conversion 81 Literals 82 Variables 82 Constants 84 Operators and Expressions 84 Three Flavors of Operators 85 Operator Precedence 88 Pulling It All Together: Mathematical Expressions and Operators 89 Summary 93 Exercises 93 Exercise 1: ABeginning.java 94 Exercise 2: ProjectGutenberg.java 95 Exercise 3: CommentingCode.java 97 Exercise 4: AllTheMath.java 98 Exercise 5: BucketsOfFun.java 100 Lesson 5: Collecting and Parsing Input from the User 103 Console Input and Output 104 Adder Version 1 104 Adder Version 2 106 Declaring and Initializing Our Variables 106 Setting Up a Scanner Object 106 Understanding the Command Line 107 Getting the Values from the User 108 Going from Strings to Integers 108 Adding the Numbers Together 109 Using Loops to Gather User Input 111 Parsing Data 112 Dealing with Bad Numbers: NumberFormatException 113 Scanner Problems 115 Summary 121 Exercises 121 Exercise 1: Quest for the User Input 121 Exercise 2: Don’t Forget to Store It 123 Exercise 3: Passing the Turing Test 124 Exercise 4: Healthy Hearts 125 Exercise 5: Mini Mad Libs 126 Lesson 6: Pulling It All Together: Building a Useful Program 127 Planning the Program 128 Identifying the Variables 128 Planning the Steps 128 Creating the Code 129 Declaring the Variables 129 Getting Input 130 Converting the Strings 131 Calculating the Area and Perimeter 132 Calculating the Cost 133 Displaying the Results 133 Running the Program 135 Summary 135 Exercises 136 Exercise 1: Mapping Instructions to Code 136 Exercise 2: Adding Prompts for Costs 136 Exercise 3: Adding Multiple Windows 136 Exercise 4: Adding Validation 137 Lesson 7: Controlling Program Flow 138 What Can Our Code Do? 139 Decisions and Boolean Expressions 139 if Statements 139 if-else Statements 142 Chaining if-else Statements 144 Evaluating Multiple Conditions 146 Conditional-And and Conditional-Or Operators 147 Exclusive-Or 149 Ternary or Conditional Operator 150 switch Statement 151 Falling Through with a switch Statement 153 Comparing for Equal Strings 155 Summary 158 Exercises 159 Exercise 1: What Month is It? 159 Exercise 2: Guess Me 159 Exercise 3: Birthstones 160 Exercise 4: Trivia Night 161 Exercise 5: Space Rustlers 162 Exercise 6: Picky Eater 163 Exercise 7: Field Day 165 Lesson 8: Looping Program Flow 167 Loops 167 Using while Loops 168 Initializing the while Loop 171 Incrementing the while Loop 171 Breaking a Loop 172 Using do-while Loops 174 Making do-while Shine 176 Using for Loops 179 Initializing the for Loop 181 Terminating the for Loop 181 Incrementing a for Loop 181 Summary 184 Exercises 184 Exercise 1: Surfacing in BewareTheKraken.java 185 Exercise 2: Do or Do Not 185 Exercise 3: Guess Me Finally 186 Exercise 4: for and Twenty Blackbirds 187 Exercise 5: Spring Forward, Fall Back 188 Exercise 6: for Times 189 Exercise 7: for Times for 189 Exercise 8: Nesting for Loops 190 Exercise 9: Traditional Fizz Buzz 191 Lesson 9: Understanding Flowcharts and Algorithms 193 Flowchart Basics 194 Sequences 194 Branches 195 Loops 196 Flowcharting 197 Flowchart Example 197 Summary 198 Exercises 200 Exercise 1: A Guessing Game 200 A Possible Flowcharting Solution 201 The Guessing Game Flowchart 201 The Guessing Game Code 203 Lesson 10: Adding Randomness to Your Programs 207 Initializing the Random Object 208 Including the Random Class 208 Seeding Random Numbers 208 Generating Random Integers 209 Generating Random Doubles 210 Revisiting the Number Guessing Game 212 Other Random Options 215 Summary 215 Exercises 215 Exercise 1: A Little Chaos 216 Exercise 2: Opinionator—Making Random Choices 217 Exercise 3: High Roller 219 Exercise 4: Coin Flipper 220 Exercise 5: Guess Me More 220 Exercise 6: Fortune Cookie 221 Lesson 11: Debugging 222 Creating a File to Debug 222 Setting Breakpoints 224 Stepping through Code 226 Running the Debugger 226 Examining Variables 229 The Console and the Debugger 232 Summary 234 Exercises 234 Exercise 1: Odd Odd Numbers 234 Exercise 2: A Simple Question of If 235 Lesson 12: Adding Methods 237 Why Methods? 238 Defining Methods 238 Method Signature 239 Method Naming Conventions 239 Return Values 240 Using Return Values 241 Input Parameters 242 Matching Number of Parameters 244 Matching Parameter Types 245 Passing Parameters 246 Method Forms 248 No Return Value, No Parameters 248 Return Value, No Parameters 248 No Return Value, One or More Parameters 249 Return Value, One or More Parameters 249 The staticKeyword 249 Pulling It All Together 250 Identifying the Similarities 252 Identifying the Differences 252 Creating the Method 252 Setting the Name 252 Determining Parameters 253 Setting a Return Type 253 Our Basic Definition 253 Our Method Body 254 Using the Method 255 Scope 257 Debugging and Step Into 259 Setting a Breakpoint in a Method 260 Stepping into Code 262 Debugging and Scope 265 Summary 265 Exercises 265 Exercise 1: Method to the Madness 266 Exercise 2: Return to Sender 267 Exercise 3: MatchWork 268 Exercise 4: Barely Controlled Chaos 269 Lesson 13: Organizing with Arrays 272 What is an Array? 273 Types of Arrays 274 Element vs. Index 275 Declaring Arrays 276 Single-Dimensional Arrays 276 Rectangular Arrays 276 Jagged Arrays 277 Initializing Arrays 277 Initializing a Single-Dimensional Array 278 Initializing a Rectangular Array 279 Initializing a Jagged Array 280 Accessing Array Elements 281 Accessing Elements in a Single-Dimensional Array 281 Accessing Elements in a Multidimensional Array 283 Accessing Elements in a Jagged Array 284 Iterating through Arrays 284 Iterating through Multidimensional and Jagged Arrays 286 Sum the Elements of an Array 288 Looping Back to Front, with a Twist 289 Printing Pairs of Elements 290 Changing the Size of an Array 291 Dealing with Errors 293 Summary 293 Exercises 294 Exercise 1: A Rainbow 294 Exercise 2: Still Positive 295 Exercise 3: Fruit Basket 296 Exercise 4: Simple Combination 297 Exercise 5: Hidden Nuts 297 Exercise 6: Summative Sums 298 Part III: Fundamentals of Classes and Objects 299 Lesson 14: Object-Oriented Concepts 300 Abstraction 301 Object Orientation 301 Types 302 Public Interface/Private Implementation 302 Encapsulation and Data Hiding 303 Single Responsibility Principle and Cohesion 303 Delegation 304 Summary 304 Lesson 15: Creating Classes and Types 305 Creating New Types 305 Classes vs. Objects 307 Properties, Accessors, and Mutators 307 Dot Operator 308 this Keyword 309 Methods/Behaviors 309 Constructors 309 Object Instantiation and Method Invocation 311 Static Keyword 312 Static and the Main Method 313 Static and Constant Values 313 Static and Utility Methods 314 Pulling It All Together 315 Creating a New Class 316 Going Static 320 When to Go Static 323 Existing Static Methods 325 Summary 325 Exercises 326 Exercise 1: Class Modeling 327 Exercise 2: Refactoring 328 Exercise 3: A Multiclass Problem 330 Lesson 16: Managing Storage and Memory 331 Programs and Memory 331 The Stack 332 The Heap 334 Garbage Collection 338 Reference and Null Values 339 Summary 341 Lesson 17: Exploring Interfaces, Composition, and Inheritance 342 How Do These Tools Help? 343 Interfaces 344 Composition and Inheritance 345 Composition 345 Inheritance 346 Using Interfaces, Composition, and Inheritance 346 Summary 347 Lesson 18: Diving into Interfaces 348 What is an Interface? 349 Declaring an Interface 349 Implementing an Interface 350 Interface Restrictions 352 Implementing Multiple Interfaces 352 Extending an Interface 354 Interfaces and Polymorphism 356 Summary 357 Lesson 19: Diving into Composition 358 What is Composition? 359 Book without Composition 359 Book with Composition 360 Summary 362 Exercises 362 Exercise 1: Classroom Composition 362 Exercise 2: Cookbook 363 Lesson 20: Diving into Inheritance 365 Everything Extends Object 366 Terminology 366 Access Control 367 Inheritance 368 Code Reuse through Inheritance 371 Method Overloading 371 Method Overriding 373 Constructors 375 Polymorphism 380 Calling Methods Polymorphically 382 Abstract Base Classes 383 Summary 383 Exercises 383 Exercise 1: Working with Shape 384 Lesson 21: Understanding Collections 385 Collections in Java 385 Javadoc 386 Collections Framework Structure 387 Interface vs. Implementation 389 Iterator 390 Commonly Used Interfaces in the Collections Framework 390 Quick Look at List 390 ArrayList 390 Stack 391 Quick Look at Set 391 HashSet 391 TreeSet 392 Quick Look at Map 392 HashMap 392 TreeMap 392 Summary 393 Lesson 22: Introduction to Lists 394 List 394 Types of Lists 395 ArrayList 395 LinkedList 395 Stack 397 Understanding Generics 397 Using Lists 398 Instantiating a List 398 Adding Items to a List 401 Accessing Items in a List 402 Inserting Items into a List 403 Removing Items from a List 403 Enhanced Approaches to Access List Items 405 The Enhanced for Loop and Lists 406 Visiting Each Element: Iterators 407 Creating an Iterator 407 Using the Iterator 408 Summary 410 Exercises 410 Exercise 1: Three Threes 410 Exercise 2: Mixed-Up Animals 411 Lesson 23: Exploring Maps 412 Map Interface 412 HashMap 413 Creating and Adding Entries to a Map 413 Instantiating a Map 413 Adding Data to a Map 414 Manipulating with Entries in a Map 415 Looking Up Values in a Map 415 Replacing Data in a Map 417 Removing Values from a Map 417 Getting Keys and Listing Mapped Values in a Map 417 Listing All the Keys 417 Listing All the Values Key by Key 420 Listing All the Values: Value Collection 421 Summary 423 Exercises 423 Exercise 1: State Capitals 423 Exercise 2: A Reusable User I/O Class 424 Exercise 3: Student Quiz Scores 427 Lesson 24: Using Simple File Input and Output 429 Data Storage and Representation 430 File Format, Marshaling, and Unmarshaling 431 Student Class 432 File Format Example 433 Marshaling and Unmarshaling Approach 433 Simple File I/O 434 Writing to a File 435 Exceptions 436 The OutFile.txt File 437 Reading from a File 438 Summary 440 Exercises 440 Exercise 1: Creating State Capitals 441 Exercise 2: Hashing the State Capitals 442 Exercise 3: A State Guessing Game 442 Exercise 4: Objectifying States 443 Lesson 25: Applying Application Design 446 CRUD Applications 447 Using a Tiered Design 448 The Basic Tiers 448 The Model-View-Controller Pattern 448 Packages 449 Software Development Lifecycle Overview 450 Waterfall 450 Iterative Development 451 Agile Development 451 Project Lifecycle 452 Phase 1: Inception 452 Phase 2: Elaboration 452 Phase 3: Construction 453 Phase 4: Transition 453 Iterations 453 Summary 454 Lesson 26: Handling Exceptions 455 Exception Handling 456 Catch or Specify Requirement 459 Exception Types 459 Handling (Catching) Exceptions 459 try Block 459 catch Block 461 finally Block 462 Specifying and Throwing Exceptions 464 Exception Translation and Encapsulation 465 Summary 466 Exercises 466 Exercise 1: Keep On Asking 466 Exercise 2: Arrays Gone Bad 466 Exercise 3: Exiting Gracefully 468 Lesson 27: Pulling It All Together: Building the Class Roster App 469 Application Requirements and Use Cases 470 Understanding the Application Structure 470 Interface Relationships 471 Composition Relationships 472 Inheritance Relationships 472 Classes and Interfaces in Our Application 472 MVC Rules of the Game 473 Construction Approach 473 Setting Up the Class Roster Application Shell 474 Creating the Menu System 477 UserIO and UserIOConsoleImpl 478 ClassRosterController 482 App 483 ClassRosterView 484 ClassRosterController 485 Adding a Student Use Case 487 Student (DTO) 487 ClassRosterDao and ClassRoster-DaoFileImpl 488 ClassRosterDao 488 ClassRosterDaoFileImpl 490 ClassRosterView 491 ClassRosterController 493 Viewing All Students Use Case 494 ClassRosterDaoFileImpl 494 ClassRosterView 495 ClassRosterController 496 Getting a Student Use Case 497 ClassRosterDaoFileImpl 498 ClassRosterView 498 ClassRosterController 499 Removing a Student Use Case 501 ClassRosterDaoFileImpl 501 ClassRosterView 501 ClassRosterController 502 Handling Unknown Command and Exiting 504 ClassRosterView 504 ClassRosterController 504 Working with Dependency Injection 506 Implementation 507 ClassRosterController 507 ClassRosterView 508 App 508 Handling Application Exceptions 509 ClassRosterDaoException 509 Adding File Persistence 512 ClassRosterDaoFileImpl 512 Constants 512 unmarshalStudent 513 loadRoster 514 marshalStudent 516 writeRoster 517 addStudent 518 getAllStudents 519 getStudent 520 removeStudent 520 ClassRosterDao 521 ClassRosterView 522 ClassRosterController 522 Create roster.txt 525 Summary 527 Exercises 527 Exercise 1: DVD Library Update 527 Exercise 2: Electronic Address Book 528 Part IV: Intermediate Java 531 Lesson 28: Exploring the Service Layer 532 The Role of the Service Layer 532 Service Layer Exceptions 534 Service Layer API Design 534 New Business Rules 534 Create a Student 535 Define the Method Signature 535 Define the Return Type 535 Define the Errors That Might Occur in This Method 535 Service Layer Methods for Getting Students 536 Get All Students 536 Get a Single Student 537 Remove a Student 537 Summary 537 Lesson 29: Pulling It All Together: Coding the Class Roster Service Layer 538 Create a Service Layer Interface 539 Create New Exceptions 542 ClassRosterDuplicateIdException 542 ClassRosterDataValidation Exception 543 Refactor/Rename ClassRoster-DaoException 543 Create the Service Layer Implementation 546 Constructor and DAO Member 547 Validating Student Data 547 Create Student 548 Get All Students 549 Get One Student 549 Remove Student 550 Modify the Controller 550 Replace Member Field 551 Modify Constructor 551 Replace Calls to DAO Methods with Calls to the Service Layer Method 551 Modify the App 553 Add the Audit Log Feature 554 Audit DAO Interface and Implementation 554 Modify the Service Layer 556 Add Member Field 556 Modify the Constructor 556 Modify createStudent 556 Modify removeStudent 557 Modify App 558 Summary 559 Lesson 30: Doing Unit Testing 560 Unit Testing 561 Types of Unit Testing 561 Black-Box vs. Glass-Box Testing 562 Stateful vs. Stateless Components 562 Test-Driven Development and Red/Green/Refactor 562 Test Stubs 563 JUnit 563 Test Setup and Teardown 563 Annotations 564 Asserts 564 Given/When/Then 564 Stateless Unit Testing 565 What Makes a Good Unit Test? 565 Designing a Test Plan 565 Happy Llama Test Plan 567 Implementing Unit Tests 568 Creating the Test Class 568 Writing Happy Llama Tests 569 Running JUnit Tests 571 Summary 575 Lesson 31: Testing Stateful Code 577 Unit Testing Stateful Code 578 Separating Production and Test Data 579 Adding hashCode and equals to Student 580 Adding toString to Student 582 Creating the Test Class 583 The Set Up and Tear Down Methods 584 Arrange/Act/Assert for Stateful Code 585 Class Roster DAO Test Design 586 Add Student 586 Get Student 588 ClassRosterDaoTest: Adding and Getting a Student 589 Get All Students 590 ClassRosterDaoTest: Adding and Getting All Students 590 Remove Student 592 ClassRosterDaoTest: Adding and Removing Students 592 Unit Testing the Service Layer 594 Planning the Test Design 595 Creating the Test Class 595 Creating the DAO Stubs 596 ClassRosterAuditDaoStubImpl 597 ClassRosterDaoStubImpl 597 Test Setup 599 Test Implementation 600 testCreateValidStudent 600 testCreateStudentDuplicateId 601 testCreateStudentInvalidData 602 testGetAllStudents 603 testGetStudent 603 testRemoveStudent 604 Summary 605 Exercises 605 Exercise 1: Testing the Address Book App 605 Exercise 2: Testing the DVD Library 606 Lesson 32: Including Magic Numbers and Enums 607 Magic Numbers 608 Enums 608 Creating Enums for Fixed Constants 609 Using Enums 609 Getting Values from an Enum 611 Enum Members 612 Summary 616 Exercises 616 Exercise 1: How Many Days until Friday? 617 Exercise 2: Playing Cards 617 Lesson 33: Manipulating Dates and Times 618 ISO Calendar 619 Human Time and Machine Time 619 Local and Zoned Classes 619 Periods and Duration 620 Working with LocalDate Objects 620 Creating LocalDates 620 Converting Dates to and from Strings 622 Formatting Dates 623 Using Localization 625 Getting the Time with LocalDateTime 626 Working with Date Calculations 628 Calculating Dates in the Future and Past 628 Calculating the Time between Two Dates 630 Working with Legacy Dates 632 Converting Date Objects 632 Converting a GregorianCalendar Object 633 Summary 635 Exercises 635 Exercise 1: Birthday Calculator 635 Exercise 2: It’s The End of the World as We Know It 636 Exercise 3: Tracking Your Time 636 Lesson 34: Using the BigDecimal Class 638 Exploring BigDecimal 639 Constructing BigDecimals 639 Understanding Scale 641 Understanding Rounding Modes 641 Working with BigDecimal 642 Setting Scale 642 Setting Scale without Rounding Mode 643 Rounding BigDecimals 643 Doing Calculations with BigDecimals 645 Dividing BigDecimals 646 Summary 648 Exercises 648 Exercise 1: Interest Calculator 648 Exercise 2: Car Lot Service Layer 649 Lesson 35: Working with Lambdas and Streams 653 Using Aggregate Operations 654 Understanding Pipelines and Streams 654 Streams vs. Iteration 655 Exploring Lambdas 655 Working with Stream and Lambda Syntax 655 The forEach() Stream Method 656 The filter Stream Method 660 The map Stream Method 661 The collect Stream Method 663 Further Syntax 664 Summary 665 Exercises 665 Exercise 1: Only the Young 665 Exercise 2: DVD Library Update 666 Part V: Advanced Java 667 Lesson 36: Working with the Spring Framework 668 Dependency Injection and Programming to Interfaces 669 Why Spring? 670 Understanding the Spring Approach 670 Plain Old Java Objects 671 Templates 671 Pulling It All Together: Spring DI in Action 673 Spring DI with XML 674 XML Configuration File 675 Update the App Class 676 Spring DI with Annotations 677 Class Annotations 678 Summary 681 Lesson 37: Introducing Maven 682 What is Maven? 683 Project Object Model 683 Project Identification 685 Dependencies 685 Build Settings 686 Dependency Management 686 Maven Lifecycle 687 Summary 687 Lesson 38: Pulling It All Together: Building the Class Roster with Spring 689 Include the Spring Libraries 690 How Do I Know What My Dependency Entry Should Be? 691 Add Spring Configuration Files 692 Convert the App Class to Use Spring 693 Defining Beans 694 Modifying the App Class 696 Convert the Unit Tests to Use Spring 697 Defining Beans 698 Modifying the Test Class Constructor 699 Exception Conditions 700 Summary 701 Exercises 701 Exercise 1: DVD Library 701 Part VI: Appendices 702 Appendix A: Code Checklist 703 Functionality 703 Style 703 Appendix B: Java concepts Study List 705 Variables 705 Methods 705 Arrays 706 Making Decisions 706 Loops 706 Java/JVM 706 Objects 707 Interfaces 708 Inheritance 708 N-Tier Design 708 Collections 709 Exceptions 709 Lambdas/Streams 709 Spring Core 709 Appendix C: Agile Approach Checklist for Console CRUD Applications 710 Assumptions 710 Requirement Steps 711 Design Steps 711 Construction Steps 712 Index 714