Job Ready Java

Cover
Title Page
Copyright
About the Authors
About the Technical Writer
About theTechnical Editors
Acknowledgments
Contents
Part 1 Getting Set Up
	Lesson 1 Installing Java
		The Java Universe
			The Java Development Kit
			The Java Virtual Machine
			The Java Runtime Environment
		Installing OpenJDK
			Installing OpenJDK on Microsoft Windows
				Checking for an Existing JDK on Windows
				Installing OpenJDK
				Verifying the Installation
			Installing OpenJDK on macOS
				Checking for an Existing JDK on macOS
				Installing OpenJDK
				Verifying the Installation
		Creating Your First Java Program
			Writing the Program
			Compiling and Running the Program
			Dealing with Syntax Errors
		Using the Compiler and Java Virtual Machine
		Summary
	Lesson 2 Installing a Development Environment: NetBeans
		Getting Started
		Understanding the Value of an IDE
			Using the Source Code Editor
			Using the Build Automation Tools
			Using the Debugger
		Installing NetBeans
			Using an Installer
				Installing on Windows
				Installing on macOS
			Installing Binaries
				Installing Binaries on Windows
				Adding the JDK
		Running NetBeans
		Summary
	Lesson 3 Using an Integrated Development Environment
		Using an IDE
			Creating a New Project
			Coding the “Hello, World!” Program
			Compiling the Code in NetBeans
			Running the Program
		Using the Debugging Tools
			Compilation and Syntax Errors
			Runtime and Logic Errors
		Understanding Source Control
		Summary
Part 2 Basics of Object Oriented Programming
	Lesson 4 Using Program Statements and Variables
		Approach
		Concepts
			Computers
			Data vs. Information
			Programs and Programming
			Models and Metaphors
			Objects
			Specifications
			Syntax vs. Semantics
		Language Building Blocks
			Comments
				Single-Line Comments
				Multiline Comments
				Doc Comments
				Using Comments
			Identifiers
			Data Types
				Statically Typed Languages
				Type Conversion
			Literals
			Variables
			Constants
			Operators and Expressions
				Three Flavors of Operators
				Operator Precedence
			Pulling It All Together: Mathematical Expressions and Operators
		Summary
		Exercises
			Important!
			Exercise 1: ABeginning.java
			Exercise 2: ProjectGutenberg.java
			Exercise 3: CommentingCode.java
			Exercise 4: AllTheMath.java
			Exercise 5: BucketsOfFun.java
	Lesson 5 Collecting and Parsing Input from the User
		Console Input and Output
			Adder Version 1
			Adder Version 2
				Declaring and Initializing Our Variables
				Setting Up a Scanner Object
				Understanding the Command Line
				Getting the Values from the User
				Going from Strings to Integers
				Adding the Numbers Together
			Using Loops to Gather User Input
		Parsing Data
		Dealing with Bad Numbers: NumberFormatException
		Scanner Problems
		Summary
		Exercises
			Exercise 1: Quest for the User Input
			Exercise 2: Don’t Forget to Store It
			Exercise 3: Passing the Turing Test
			Exercise 4: Healthy Hearts
			Exercise 5: Mini Mad Libs
	Lesson 6 Pulling It All Together: Building a Useful Program
		Planning the Program
			Identifying the Variables
			Planning the Steps
		Creating the Code
			Declaring the Variables
			Getting Input
			Converting the Strings
			Calculating the Area and Perimeter
			Calculating the Cost
			Displaying the Results
		Running the Program
		Summary
		Exercises
			Exercise 1: Mapping Instructions to Code
			Exercise 2: Adding Prompts for Costs
			Exercise 3: Adding Multiple Windows
			Exercise 4: Adding Validation
	Lesson 7 Controlling Program Flow
		What Can Our Code Do?
		Decisions and Boolean Expressions
			if Statements
			if-else Statements
			Chaining if-else Statements
			Evaluating Multiple Conditions
				Conditional-And and Conditional-Or Operators
				Exclusive-Or
		Ternary or Conditional Operator
		switch Statement
			Falling Through with a switch Statement
		Comparing for Equal Strings
		Summary
		Exercises
			Exercise 1: What Month Is It?
			Exercise 2: Guess Me
			Exercise 3: Birthstones
			Exercise 4: Trivia Night
			Exercise 5: Space Rustlers
			Exercise 6: Picky Eater
			Exercise 7: Field Day
	Chapter 8 Looping Program Flow
		Loops
		Using while Loops
			Initializing the while Loop
			Incrementing the while Loop
			Breaking a Loop
		Using do-while Loops
			Making do-while Shine
		Using for Loops
			Initializing the for Loop
			Terminating the for Loop
			Incrementing a for Loop
		Summary
		Exercises
			Exercise 1: Surfacing in BewareTheKraken.java
			Exercise 2: Do or Do Not
			Exercise 3: Guess Me Finally
			Exercise 4: for and Twenty Blackbirds
			Exercise 5: Spring Forward, Fall Back
			Exercise 6: for Times
			Exercise 7: for Times for
			Exercise 8: Nesting for Loops
			Exercise 9: Traditional Fizz Buzz
	Lesson 9 Understanding Flowcharts and Algorithms
		Flowchart Basics
			Sequences
			Branches
			Loops
		Flowcharting
		Flowchart Example
		Summary
		Exercises
			Exercise 1: A Guessing Game
			A Possible Flowcharting Solution
				The Guessing Game Flowchart
				The Guessing Game Code
	Lesson 10 Adding Randomness to Your Programs
		Initializing the Random Object
			Including the Random Class
			Seeding Random Numbers
		Generating Random Integers
		Generating Random Doubles
		Revisiting the Number Guessing Game
		Other Random Options
		Summary
		Exercises
			Exercise 1: A Little Chaos
			Exercise 2: Opinionator—Making Random Choices
			Exercise 3: High Roller
			Exercise 4: Coin Flipper
			Exercise 5: Guess Me More
			Exercise 6: Fortune Cookie
	Lesson 11 Debugging
		Creating a File to Debug
		Setting Breakpoints
			Stepping through Code
			Running the Debugger
				Examining Variables
				The Console and the Debugger
		Summary
		Exercises
			Exercise 1: Odd Odd Numbers
			Exercise 2: A Simple Question of If
	Lesson 12 Adding Methods
		Why Methods?
		Defining Methods
			Method Signature
			Method Naming Conventions
			Return Values
				Using Return Values
			Input Parameters
				Matching Number of Parameters
				Matching Parameter Types
				Passing Parameters
		Method Forms
			No Return Value, No Parameters
			Return Value, No Parameters
			No Return Value, One or More Parameters
			Return Value, One or More Parameters
			The static Keyword
		Pulling It All Together
			Identifying the Similarities
			Identifying the Differences
			Creating the Method
				Setting the Name
				Determining Parameters
				Setting a Return Type
				Our Basic Definition
				Our Method Body
			Using the Method
		Scope
		Debugging and Step Into
			Setting a Breakpoint in a Method
			Stepping into Code
			Debugging and Scope
		Summary
		Exercises
			Exercise 1: Method to the Madness
			Exercise 2: Return to Sender
			Exercise 3: MatchWork
			Exercise 4: Barely Controlled Chaos
	Lesson 13 Organizing with Arrays
		What Is an Array?
			Types of Arrays
			Element vs. Index
		Declaring Arrays
			Single-Dimensional Arrays
			Rectangular Arrays
			Jagged Arrays
		Initializing Arrays
			Initializing a Single-Dimensional Array
			Initializing a Rectangular Array
			Initializing a Jagged Array
		Accessing Array Elements
			Accessing Elements in a Single-Dimensional Array
			Accessing Elements in a Multidimensional Array
			Accessing Elements in a Jagged Array
		Iterating through Arrays
			Iterating through Multidimensional and Jagged Arrays
			Sum the Elements of an Array
			Looping Back to Front, with a Twist
			Printing Pairs of Elements
		Changing the Size of an Array
		Dealing with Errors
		Summary
		Exercises
			Exercise 1: A Rainbow
			Exercise 2: Still Positive
			Exercise 3: Fruit Basket
			Exercise 4: Simple Combination
			Exercise 5: Hidden Nuts
			Exercise 6: Summative Sums
Part 3 Fundamentals of Classes and Objects
	Lesson 14 Object-Oriented Concepts
		Abstraction
		Object Orientation
		Types
		Public Interface/Private Implementation
		Encapsulation and Data Hiding
		Single Responsibility Principle and Cohesion
		Delegation
		Summary
	Lesson 15 Creating Classes and Types
		Creating New Types
		Classes vs. Objects
		Properties, Accessors, and Mutators
		Dot Operator
		this Keyword
		Methods/Behaviors
		Constructors
		Object Instantiation and Method Invocation
		static KEYWORD
			static and the Main Method
			static and Constant Values
			static and Utility Methods
		Pulling It All Together
			Creating a New Class
			Going Static
			When to Go Static
			Existing Static Methods
		Summary
		Exercises
			Exercise 1: Class Modeling
			Exercise 2: Refactoring
			Exercise 3: A Multiclass Problem
	Lesson 16 Managing Storage and Memory
		Programs and Memory
			The Stack
			The Heap
		Garbage Collection
		Reference and Null Values
		Summary
	Lesson 17 Exploring Interfaces, Composition, and Inheritance
		How Do These Tools Help?
		Interfaces
		Composition and Inheritance
			Composition
			Inheritance
		Using Interfaces, Composition, and Inheritance
		Summary
	Lesson 18 Diving into Interfaces
		What Is an Interface?
		Declaring an Interface
		Implementing an Interface
		Interface Restrictions
		Implementing Multiple Interfaces
		Extending an Interface
		Interfaces and Polymorphism
		Summary
	Lesson 19 Diving into Composition
		What Is Composition?
			Book without Composition
			Book with Composition
		Summary
		Exercises
			Exercise 1: Classroom Composition
			Exercise 2: Cookbook
	Lesson 20 Diving into Inheritance
		Everything Extends Object
		Terminology
		Access Control
		Inheritance
		Code Reuse Through Inheritance
		Method Overloading
		Method Overriding
		Constructors
		Polymorphism
		Calling Methods Polymorphically
		Abstract Base Classes
		Summary
		Exercises
			Exercise 1: Working with Shape
	Lesson 21 Understanding Collections
		Collections in Java
		Javadoc
		Collections Framework Structure
		Interface vs. Implementation
		Iterator
		Commonly Used Interfaces in the Collections Framework
			Quick Look at List
				ArrayList
				Stack
			Quick Look at Set
				HashSet
				TreeSet
			Quick Look at Map
				HashMap
				TreeMap
		Summary
	Lesson 22 Introduction to Lists
		List
		Types of Lists
			ArrayList
			LinkedList
			Stack
		Understanding Generics
		Using Lists
			Instantiating a List
			Adding Items to a List
			Accessing Items in a List
			Inserting Items into a List
			Removing Items from a List
		Enhanced Approaches to Access List Items
			The Enhanced for Loop and Lists
			Visiting Each Element: Iterators
				Creating an Iterator
				Using the Iterator
		Summary
		Exercises
			Exercise 1: Three Threes
			Exercise 2: Mixed-Up Animals
	Lesson 23 Exploring Maps
		Map Interface
		HashMap
		Creating and Adding Entries to a Map
			Instantiating a Map
			Adding Data to a Map
		Manipulating with Entries in a Map
			Looking Up Values in a Map
			Replacing Data in a Map
			Removing Values from a Map
		Getting Keys and Listing Mapped Values in a Map
			Listing All the Keys
			Listing All the Values Key by Key
			Listing All the Values: Value Collection
		Summary
		Exercises
			Exercise 1: State Capitals
			Exercise 2: A Reusable User I/O Class
			Exercise 3: Student Quiz Scores
	Lesson 24 Using Simple File Input and Output
		Data Storage and Representation
		File Format, Marshaling, and Unmarshaling
			Student Class
			File Format Example
			Marshaling and Unmarshaling Approach
		Simple File I/O
			Writing to a File
				Exceptions
				The OutFile.txt File
			Reading from a File
		Summary
		Exercises
			Exercise 1: Creating State Capitals
			Exercise 2: Hashing the State Capitals
			Exercise 3: A State Guessing Game
			Exercise 4: Objectifying States
	Lesson 25 Applying Application Design
		CRUD Applications
			Using a Tiered Design
			The Basic Tiers
		The Model-View-Controller Pattern
		Packages
		Software Development LifecycleOverview
			Waterfall
			Iterative Development
		Agile Development
			Project Lifecycle
				Phase 1: Inception
				Phase 2: Elaboration
				Phase 3: Construction
				Phase 4: Transition
			Iterations
		Summary
	Lesson 26 Handling Exceptions
		Exception Handling
		Catch or Specify Requirement
		Exception Types
		Handling (Catching) Exceptions
			try Block
			catch Block
			finally Block
		Specifying and Throwing Exceptions
		Exception Translation and Encapsulation
		Summary
		Exercises
			Exercise 1: Keep On Asking
			Exercise 2: Arrays Gone Bad
			Exercise 3: Exiting Gracefully
	Lesson 27 Pulling It All Together: Building the Class Roster App
		Application Requirements and Use Cases
		Understanding the Application Structure
			Interface Relationships
			Composition Relationships
			Inheritance Relationships
			Classes and Interfaces in Our Application
			MVC Rules of the Game
			Construction Approach
		Setting Up the Class Roster Application Shell
		Creating the Menu System
			UserIO and UserIOConsoleImpl
			ClassRosterController
			App
			ClassRosterView
			ClassRosterController
		Adding a Student Use Case
			Student (DTO)
			ClassRosterDao and ClassRosterDaoFileImpl
				ClassRosterDao
				ClassRosterDaoFileImpl
			ClassRosterView
			ClassRosterController
		Viewing All Students Use Case
			ClassRosterDaoFileImpl
			ClassRosterView
			ClassRosterController
		Getting a Student Use Case
			ClassRosterDaoFileImpl
			ClassRosterView
			ClassRosterController
		Removing a Student Use Case
			ClassRosterDaoFileImpl
			ClassRosterView
			ClassRosterController
		Handling Unknown Command and Exiting
			ClassRosterView
			ClassRosterController
		Working with Dependency Injection
			Implementation
				ClassRosterController
				ClassRosterView
				App
		Handling Application Exceptions
			ClassRosterDaoException
		Adding File Persistence
			ClassRosterDaoFileImpl
				Constants
				unmarshalStudent
				loadRoster
				marshalStudent
				writeRoster
				addStudent
				getAllStudents
				getStudent
				removeStudent
			ClassRosterDao
			ClassRosterView
			ClassRosterController
			Create roster.txt
		Summary
		Exercises
			Exercise 1: DVD Library Update
			Exercise 2: Electronic Address Book
Part 4 Intermediate Java
	Lesson 28 Exploring the Service Layer
		The Role of the Service Layer
		Service Layer Exceptions
		Service Layer API Design
		New Business Rules
		Create a Student
			Define the Method Signature
			Define the Return Type
			Define the Errors That Might Occur in This Method
		Service Layer Methods for Getting Students
			Get All Students
			Get a Single Student
			Remove a Student
		Summary
	Lesson 29 Pulling It All Together: Coding the Class Roster Service Layer
		Create a Service Layer Interface
		Create New Exceptions
			ClassRosterDuplicateIdException
			ClassRosterDataValidationException
			Refactor/Rename ClassRosterDaoException
		Create the Service Layer Implementation
			Constructor and DAO Member
			Validating Student Data
			Create Student
			Get All Students
			Get One Student
			Remove Student
		Modify the Controller
			Replace Member Field
			Modify Constructor
			Replace Calls to DAO Methods with Calls to the Service Layer Method
		Modify the App
		Add the Audit Log Feature
			Audit DAO Interface and Implementation
			Modify the Service Layer
				Add Member Field
				Modify the Constructor
				Modify createStudent
				Modify removeStudent
			Modify App
		Summary
	Lesson 30 Doing Unit Testing
		Unit Testing
		Types of Unit Testing
			Black-Box vs. Glass-Box Testing
			Stateful vs. Stateless Components
			Test-Driven Development and Red/Green/Refactor
			Test Stubs
		JUnit
			Test Setup and Teardown
			Annotations
			Asserts
		Given/When/Then
		Stateless Unit Testing
			What Makes a Good Unit Test?
			Designing a Test Plan
				Happy Llama Test Plan
		Implementing Unit Tests
			Creating the Test Class
			Writing Happy Llama Tests
			Running JUnit Tests
		Summary
	Lesson 31 Testing Stateful Code
		Unit Testing Stateful Code
		Separating Production and Test Data
			Adding hashCode and equals to Student
			Adding toString to Student
			Creating the Test Class
				The Set Up and Tear Down Methods
				Arrange/Act/Assert for Stateful Code
		Class Roster DAO Test Design
			Add Student
			Get Student
				ClassRosterDaoTest: Adding and Getting a Student
			Get All Students
				ClassRosterDaoTest: Adding and Getting All Students
			Remove Student
				ClassRosterDaoTest: Adding and Removing Students
		Unit Testing the Service Layer
			Planning the Test Design
			Creating the Test Class
			Creating the DAO Stubs
				ClassRosterAuditDaoStubImpl
				ClassRosterDaoStubImpl
			Test Setup
			Test Implementation
				testCreateValidStudent
				testCreateStudentDuplicateId
				testCreateStudentInvalidData
				testGetAllStudents
				testGetStudent
				testRemoveStudent
		Summary
		Exercises
			Exercise 1: Testing the Address Book App
			Exercise 2: Testing the DVD Library
	Lesson 32 Including Magic Numbers and Enums
		Magic Numbers
		Enums
			Creating Enums for Fixed Constants
			Using Enums
			Getting Values from an Enum
		Enum Members
		Summary
		Exercises
			Exercise 1: How Many Days until Friday?
			Exercise 2: Playing Cards
	Lesson 33 Manipulating Dates and Times
		ISO Calendar
		Human Time and Machine Time
		Local and Zoned Classes
		Periods and Duration
		Working with LocalDate Objects
			Creating LocalDates
			Converting Dates to and from Strings
			Formatting Dates
			Using Localization
		Getting the Time with LocalDateTime
		Working with Date Calculations
			Calculating Dates in the Future and Past
			Calculating the Time between Two Dates
		Working with Legacy Dates
			Converting Date Objects
			Converting a GregorianCalendar Object
		Summary
		Exercises
			Exercise 1: Birthday Calculator
			Exercise 2: It\'s The End of the World as We Know It
			Exercise 3: Tracking Your Time
	Lesson 34 Using the BigDecimal Class
		Exploring BigDecimal
			Constructing BigDecimals
			Understanding Scale
			Understanding Rounding Modes
		Working with BigDecimal
			Setting Scale
			Setting Scale without Rounding Mode
			Rounding BigDecimals
		Doing Calculations with BigDecimals
			Dividing BigDecimals
		Summary
		Exercises
			Exercise 1: Interest Calculator
			Exercise 2: Car Lot Service Layer
	Lesson 35 Working with Lambdas and Streams
		Using Aggregate Operations
		Understanding Pipelines and Streams
		Streams vs. Iteration
		Exploring Lambdas
		Working with Stream and Lambda Syntax
			The forEach() Stream Method
			The filter Stream Method
			The map Stream Method
			The collect Stream Method
			Further Syntax
		Summary
		Exercises
			Exercise 1: Only the Young
			Exercise 2: DVD Library Update
Part 5 Advanced Java
	Lesson 36 Working with the Spring Framework
		Dependency Injection and Programming to Interfaces
		Why Spring?
		Understanding the Spring Approach
			Plain Old Java Objects
				Templates
		Pulling It All Together: Spring DI in Action
			Spring DI with XML
				XML Configuration File
				Update the App Class
			Spring DI with Annotations
				Class Annotations
		Summary
	Lesson 37 Introducing Maven
		What Is Maven?
		Project Object Model
			Project Identification
			Dependencies
			Build Settings
		Dependency Management
		Maven Lifecycle
		Summary
	Lesson 38 Pulling It All Together: Building the Class Roster with Spring
		Include the Spring Libraries
			How Do I Know What My Dependency Entry Should Be?
		Add Spring Configuration Files
		Convert the App Class to Use Spring
			Defining Beans
			Modifying the App Class
		Convert the Unit Tests to Use Spring
			Defining Beans
			Modifying the Test Class Constructor
		Exception Conditions
		Summary
		Exercises
			Exercise 1: DVD Library
Part 6 Appendices
	Appendix A Appendix A: Code Checklist
		Functionality
		Style
	Appendix B Appendix B: Java Concepts Study List
		Variables
		Methods
		Arrays
		Making Decisions
		Loops
		Java/JVM
		Objects
		Interfaces
		Inheritance
		N-Tier Design
		Collections
		Exceptions
		Lambdas/Streams
		Spring Core
	Appendix C Appendix C: Agile Approach Checklist for Console CRUD Applications
		Assumptions
		Requirement Steps
		Design Steps
		Construction Steps
Index
EULA