Head First Java: A Brain-Friendly Guide

About the Authors
Table of Contents
Intro
	Who is this book for?
	Metacognition: thinking about thinking
	Here’s what WE did
	Here’s what YOU can do to bend yourbrain into submission
	What you need for this book
	Last-minute things you need to know
	Technical Reviewers
Chapter 1: Breaking the Surface
	The way Java works
	What you’ll do in Java
	A very brief history of Java
	Code structure in Java
	Anatomy of a class
	Writing a class with a main()
	Looping and looping and...
	Conditional branching
	Coding a serious business application
	Phrase-O-Matic
Chapter 2: A Trip to Objectville
	Chair Wars (or How Objects Can Change Your Life)
	What’s the difference betweena class and an object?
	Making your first object
	Making and testing Movie objects
	Quick! Get out of main!
	Running the Guessing Game
Chapter 3: Know Your Variables
	Declaring a variable
	“I’d like a double mocha, no, make it an int.”
	You really don’t want to spill that...
	Back away from that keyword!
	Controlling your Dog object
	An object reference is justanother variable value
	Life on the garbage-collectible heap
	An array is like a tray of cups
	Make an array of Dogs
	Control your Dog(with a reference variable)
Chapter 4: How Objects Behave
	Remember: a class describes what an object knows and what an object does
	The size affects the bark
	You can send things to a method
	You can get things back from a method
	You can send more than one thingto a method
	Java is pass-by-value. That means pass-by-copy.
	Cool things you can do with parameters and return types
	Encapsulation
	Encapsulating the GoodDog class
	How do objects in an arraybehave?
	Declaring and initializing instance variables
	The difference between instance and local variables
	Comparing variables (primitives or references)
Chapter 5: Extra-Strength Methods
	Let’s build a Battleship-style game: “Sink a Startup”
	First, a high-level design
	The “Simple Startup Game” a gentler introduction
	Developing a Class
	Writing the method implementations
	Writing test code for the SimpleStartup class
	The checkYourself() method
	Just the new stuff
	Final code for SimpleStartup and SimpleStartupTestDrive
	Prep code for the SimpleStartupGame class
	The game’s main() method
	random() and getUserInput()
	One last class: GameHelper
	Let’s play
	More about for loops
	Trips through a loop
	The enhanced for loop
	Casting primitives
Chapter 6: Using the Java Library
	In our last chapter, we left you with the cliff-hanger: a bug
	So what happened?
	How do we fix it?
	Option one is too clunky
	Option two is a little better, but still pretty clunky
	Option three
	Wake up and smell the library
	Some things you can do with ArrayList
	Comparing ArrayList to a regular array
	Let’s fix the Startup code
	New and improved Startup class
	Let’s build the REAL game: “Sink a Startup”
	What needs to change?
	Who does what in the StartupBust game (and when)
	Prep code for the real StartupBust class
	The final version of the Startup class
	Super powerful Boolean expressions
	Ready-BakeCode
	Using the Library (the Java API)
	How to discover the API
	Using the class documentation
Chapter 7: Better Living in Objectville
	Chair Wars Revisited...
	Understanding Inheritance
	Let’s design the inheritance tree for an Animal simulation program
	Using inheritance to avoid duplicating code in subclasses
	Do all animals eat the same way?
	Looking for more inheritance opportunities
	Which method is called?
	Designing an Inheritance Tree
	Using IS-A and HAS-A
	How do you know if you’ve got your inheritance right?
	When designing with inheritance, are you using or abusing?
	So what does all this inheritance really buy you?
	Inheritance lets you guarantee that all classes grouped under a certain supertype have all the methods that the supertype has*
	polymorphism in action
	Keeping the contract: rules for overriding
	Overloading a method
Chapter 8: Serious Polymorphism
	Did we forget about something when we designed this?
	What does a new Animal() object look like?
	The compiler won’t let you instantiate an abstract class
	Abstract vs. Concrete
	Abstract methods
	You MUST implement all abstract methods
	Polymorphism in action
	Uh-oh, now we need to keep Cats, too
	What about non-Animals? Why not make a class generic enough to take anything?
	So what’s in this ultra-super-megaclass Object?
	Using polymorphic references of type Object has a price...
	When a Dog won’t act like a Dog
	Objects don’t bark
	Get in touch with your inner Object
	What if you need to change the contract?
	Let’s explore some design options for reusing some of our existing classes in a PetShop program
	Interface to the rescue!
	Making and implementing the Pet interface
	Invoking the superclass version of a method
Chapter 9: Life and Death of an Object
	The Stack and the Heap: where things live
	Methods are stacked
	What about local variables that are objects?
	If local variables live on the stack, where do instance variables live?
	The miracle of object creation
	Construct a Duck
	Initializing the state of a new Duck
	Using the constructor to initialize important Duck state
	Make it easy to make a Duck
	Doesn’t the compiler always make a no-arg constructorfor you?
	Nanoreview: four things to remember about constructors
	Wait a minute...we never DID talk about superclasses and inheritance and how that all fits in with constructors
	The role of superclass constructors in an object’s life
	Making a Hippo means making the Animal and Object parts too...
	How do you invoke a superclass constructor?
	Can the child exist beforethe parents?
	Superclass constructors with arguments
	Invoking one overloaded constructor from another
	Now we know how an object is born, but how long does an object live ?
	What about reference variables?
Chapter 10: Numbers Matter
	MATH methods: as close as you’ll ever get to a global method
	The difference between regular (non-static) and static methods
	What it means to have a class with static methods
	Static methods can’t use non-static (instance) variables!
	Static methods can’t use non-static methods, either!
	Static variable: value is the same for ALL instances of the class
	Initializing a static variable
	static final variables are constants
	final isn’t just for static variables...
	Math methods
	Wrapping a primitive
	Java will Autobox primitives for you
	Autoboxing works almost everywhere
	But wait! There’s more! Wrappers have static utility methods too!
	And now in reverse...turning a primitive number into a String
	Number formatting
	Formatting deconstructed...
	The percent (%) says, “insert argument here”
	The format String uses its own little language syntax
	The format specifier
	The only required specifier is for TYPE
	What happens if I have more than one argument?
	Just one more thing...static imports
Chapter 11: Data Structures
	Tracking song popularity on your jukebox
	Your first job, sort the songs in alphabetical order
	Great question! You spotted the diamond operator
	Exploring the java.util API, List and Collections
	“Natural Ordering,” what Java means by alphabetical
	But now you need Song objects, not just simple Strings
	Changing the Jukebox code to use Songs instead of Strings
	It won’t compile!
	The sort() method declaration
	Generics means more type-safety
	Learning generics
	Using generic CLASSES
	Using type parameters with ArrayList
	Using generic METHODS
	Here’s where it gets weird...
	Revisiting the sort() method
	In generics, “extends” means “extends or implements”
	Finally we know what’s wrong... The Song class needs to implement Comparable
	The new, improved, comparable Song class
	We can sort the list, but...
	Using a custom Comparator
	Updating the Jukebox to use a Comparator
	But wait! We’re sorting in two different ways!
	Sorting using only Comparators
	Just the code that matters
	What do we REALLY need in order to sort?
	Enter lambdas! Leveraging what the compiler can infer
	Where did all that code go?
	Updating the Jukebox code with lambdas
	Uh-oh. The sorting all works, but now we have duplicates...
	We need a Set instead of a List
	The Collection API (part of it)
	Using a HashSet instead of ArrayList
	What makes two objects equal?
	How a HashSet checks for duplicates: hashCode() and equals()
	The Song class with overridden hashCode() and equals()
	If we want the set to stay sorted, we’ve got TreeSet
	What you MUST know about TreeSet...
	TreeSet elements MUST be comparable
	We’ve seen Lists and Sets, now we’ll use a Map
	Creating and filling collections
	Convenience Factory Methods for Collections
	Finally, back to generics
	But will it work with List?
	What could happen if it were allowed...?
	We can do this with wildcards
	Using the method’s generic type parameter
Chapter 12: Lambdas and Streams: What, Not How
	Tell the computer WHAT you want
	When for loops go wrong
	Small errors in common code can be hard to spot
	Building blocks of common operations
	Introducing the Streams API
	Getting started with Streams
	Streams are like recipes: nothing’s going to happen until someone actually cooks them
	Getting a result from a Stream
	Stream operations are building blocks
	Building blocks can be stacked and combined
	Customizing the building blocks
	Create complex pipelines block by block
	Yes, because Streams are lazy
	Terminal operations do all the work
	Collecting to a List
	Guidelines for working with streams
	Hello Lambda, my (not so) old friend
	Passing behavior around
	Lambda expressions are objects, and you run them by calling their Single Abstract Method
	The shape of lambda expressions
	Anatomy of a lambda expression
	Variety is the spice of life
	How can I tell if a method takes a lambda?
	Spotting Functional Interfaces
	Functional interfaces in the wild
	Lou’s back!
	Ready-Bake Code
	Lou’s Challenge #1:  Find all the “rock” songs
	Filter a stream to keep certain elements
	Let’s Rock!
	Getting clever with filters
	Lou’s Challenge #2: List all the genres
	Mapping from one type to another
	Removing duplicates
	Only one of every genre
	Sometimes you don’t even need a lambda expression
	Collecting results in different ways
	But wait, there’s more!
	Optional is a wrapper
	Don’t forget to talk to the Optional wrapper
Chapter 13: Risky Behavior
	Let’s make a Music Machine
	We’ll start with the basics
	First we need a Sequencer
	What happens when a method you want to call (probably in a class you didn’t write) is risky?
	Methods in Java use exceptions to tell the calling code, “Something Bad Happened. I failed.”
	The compiler needs to know that YOU know you’re calling a risky method
	An exception is an object...of type Exception
	If it’s your code that catches the exception, then whose code throws it?
	Flow control in try/catch blocks
	Finally: for the things you want to do no matter what
	Did we mention that a method can throw more than one exception?
	Exceptions are polymorphic
	Multiple catch blocks must be ordered from smallest to biggest
	You can’t put bigger baskets above smaller baskets
	When you don’t want to handlean exception…just duck it
	Ducking (by declaring) only delays the inevitable
	Handle or Declare. It’s the law.
	Getting back to our music code...
	Code Kitchen
	Making actual sound
	Version 1: Your very first sound player app
	Making a MidiEvent (song data)
	MIDI message: the heart of a MidiEvent
	Change a message
	Version 2: Using command-line args to experiment with sounds
	Where we’re headed with the rest of the Code Kitchens
Chapter 14: A Very Graphic Story
	It all starts with a window
	Your first GUI: a button on a frame
	But nothing happens when I click it...
	Getting a user event
	Getting a button’s ActionEvent
	Listeners, Sources, and Events
	Getting back to graphics...
	Make your own drawing widget
	Fun things to do in paintComponent()
	Behind every good Graphics reference is a Graphics2D object
	Because life’s too short to paint the circle a solid color when there’s a gradient blend waiting for you
	We can get an event. We can paint graphics. But can we paint graphics when we get an event?
	GUI layouts: putting more than one widget on a frame
	Let’s try it with TWO buttons
	Inner class to the rescue!
	An inner class instance must be tied to an outer class instance
	How to make an instance of an inner class
	Lambdas to the rescue! (again)
	ActionListener is a Functional Interface
	Using an inner class for animation
	The complete simple animation code
	Code Kitchen
	Listening for a non-GUI event
	An easier way to make messages/events
	Version One: using the new static makeEvent() method
	Version Two: registering and getting ControllerEvents
	Version Three: drawing graphics in time with the music
Chapter 15: Work on Your Swing
	Swing components
	Layout Managers
	How does the layout manager decide?
	The Big Three layout managers: border, flow, and box
	FlowLayout cares about the flow of the components
	BoxLayout to the rescue!
	Playing with Swing components
	Code Kitchen
	Making the BeatBox
Chapter 16: Saving Objects (and Text)
	Capture the beat
	Saving state
	Writing a serialized object to a file
	Data moves in streams from one place to another
	What really happens to an object when it’s serialized?
	But what exactly IS an object’s state? What needs to be saved?
	If you want your class to be serializable, implement Serializable
	Deserialization: restoring an object
	What happens during deserialization?
	Saving and restoring the game characters
	The GameCharacter class
	Version ID: A big serialization gotcha
	Using the serialVersionUID
	Writing a String to a Text File
	Text file example: e-Flashcards
	Quiz Card Builder (code outline)
	The java.io.File class
	The beauty of buffers
	Reading from a text file
	Quiz Card Player (code outline)
	Parsing with String split()
	NIO.2 and the java.nio.file package
	Path, Paths, and Files (messing with directories)
	Finally, a closer look at finally
	The try-with-resources (TWR), statement
	Autocloseable, the very small catch
	Code Kitchen
	Saving a BeatBox pattern
	Restoring a BeatBox pattern
Chapter 17: Make a Connection
	Real-time BeatBox chat
	Chat program overview
	Connecting, sending, and receiving
	1. Connect
	A TCP port is just a number...a 16-bit number that identifies a specific program on the server
	2. Receive
	3. Send
	There’s more than one way to make a connection
	The DailyAdviceClient
	DailyAdviceClient code
	Writing a simple server application
	DailyAdviceServer code
	Writing a Chat Client
	Ready-Bake Code
	Java has multiple threads but onlyone Thread class
	What does it mean to have more than one call stack?
	To create a new call stack you need a job to run
	To make a job for your thread, implement the Runnable interface
	How we used to launch a new thread
	A better alternative: don’t manage the Threads at all
	The three states of a new thread
	The thread scheduler
	How did we end up with different results?
	Putting a thread to sleep
	Using sleep to make our program more predictable
	There are downsides to forcing the thread to sleep
	Counting down until ready
	Making and starting two threads (or more!)
	Pooling Threads
	Running multiple threads
	Closing time at the thread pool
	Um, yes. There IS a dark side. Multithreading can lead to concurrency “issues.”
	New and improved SimpleChatClient
	Code Kitchen
Chapter 18: Dealing with Concurrency Issues
	What could possibly go wrong?
	Marriage in Trouble. Can this couple be saved?
	The Ryan and Monica problem, in code
	They need a lock for account access!
	We need to check the balance and spend the money as one atomic thing
	Using an object’s lock
	Using synchronized methods
	It’s important to lock the correct object
	The dreaded “Lost Update” problem
	Let’s run this code...
	Make the increment() method atomic. Synchronize it!
	Deadlock, a deadly side of synchronization
	You don’t always have to use synchronized
	Compare-and-swap with atomic variables
	Ryan and Monica, going atomic
	Writing a class for immutable data
	Using immutable objects
	Changing immutable data
	More problems with shared data
	Reading from a changing data structure causes an Exception
	Use a thread-safe data structure
	CopyOnWriteArrayList
Appendix A: Final Code Kitchen
	Final BeatBox client program
	Final BeatBox server program
Appendix B: The top ten-ish topics that didn\'t make it into the rest of the book...
	#11 JShell (Java REPL)
	#10 Packages
	#9 Immutability in Strings and Wrappers
	#8 Access levels and access modifiers (who sees what)
	#7 Varargs
	#6 Annotations
	#5 Lambdas and Maps
	#4 Parallel Streams
	#3 Enumerations (also called enumerated types or enums)
	#2 Local Variable Type Inference (var)
	#1 Records
Index