Learn Java for Android Development - Migrating Java SE Programming Skills to Mobile Development.

Table of Contents
About the Authors
About the Technical Reviewer
Introduction
Fourth Edition Notes
Chapter 1: Getting Started with Java
	What Is Java?
		Java Is a Language
		Java Is a Platform
		Java SE and Java EE
	Installing the JDK and Exploring Example Applications
		Hello, World!
		DumpArgs
		EchoText
	Installing and Exploring the Eclipse IDE
	Java Meets Android
		What Is Android?
		History of Android
		Android Architecture
		Android Says Hello
	Summary
Chapter 2: Learning Language Fundamentals
	Learning Application Structure
	Learning Comments
		Single-Line Comments
		Multiline Comments
		Javadoc Comments
	Learning Identifiers
	Learning Types
		Primitive Types
		Object Types
		Array Types
	Learning Variables
	Learning Expressions
		Simple Expressions
		Compound Expressions
			Additive Operators
			Array Index Operator
			Assignment Operators
			Bitwise Operators
			Cast Operator
			Conditional Operators
			Equality Operators
			Logical Operators
			Member Access Operator
			Method Call Operator
			Multiplicative Operators
			Object Creation Operator
			Relational Operators
			Shift Operators
			Unary Minus/Plus Operators
			Precedence and Associativity
	Learning Statements
		Assignment Statements
		Decision Statements
			If Statement
			If-Else Statement
			Switch Statement
		Loop Statements
			For Statement
			While Statement
			Do-While Statement
			Looping over the Empty Statement
		Break Statements
		Continue Statements
	Summary
Chapter 3: Discovering Classes and Objects
	Declaring Classes
		Classes and Applications
	Constructing Objects
		Default Constructor
		Explicit Constructors
		Objects and Applications
	Encapsulating State and Behaviors
		Representing State via Fields
			Declaring and Accessing Class Fields
			Declaring and Accessing Instance Fields
			Reviewing Field-Access Rules
		Representing Behaviors via Methods
			Declaring and Invoking Class Methods
			Declaring and Invoking Instance Methods
			Returning from a Method via the Return Statement
				Method-Call Stack
				Chaining Together Instance Method Calls
			Passing Arguments to Methods
			Invoking Methods Recursively
			Overloading Methods
			Reviewing Method-Invocation Rules
	Hiding Information
	Initializing Classes and Objects
		Class Initializers
		Instance Initializers
		Initialization Order
	Collecting Garbage
	Revisiting Arrays
	Summary
Chapter 4: Discovering Inheritance, Polymorphism, and Interfaces
	Building Class Hierarchies
		Extending Classes
		The Ultimate Superclass
			Cloning
			Equality
			Finalization
			Hash Codes
			String Representation
		Composition
	Changing Form
		Upcasting and Late Binding
		Abstract Classes and Abstract Methods
		Downcasting and Runtime Type Identification
		Covariant Return Types
	Formalizing Class Interfaces
		Declaring Interfaces
		Implementing Interfaces
		Extending Interfaces
		Why Use Interfaces?
	Summary
Chapter 5: Mastering Advanced Language Features, Part 1
	Mastering Nested Types
		Static Member Classes
		Nonstatic Member Classes
		Anonymous Classes
		Local Classes
		Interfaces Within Classes
	Mastering Packages
		What Are Packages?
		Package Names Must Be Unique
		The Package Statement
		The Import Statement
		Searching for Packages and Types
			Compile-Time Search
			Runtime Search
		Playing with Packages
		Packages and JAR Files
	Mastering Static Imports
	Mastering Exceptions
		What Are Exceptions?
		Representing Exceptions in Source Code
			Error Codes vs. Objects
			The Throwable Class Hierarchy
			Custom Exception Classes
		Throwing Exceptions
		Handling Exceptions
			Handling Multiple Exception Types
			Rethrowing Exceptions
		Performing Cleanup
		Automatic Resource Management
	Summary
Chapter 6: Mastering Advanced Language Features, Part 2
	Mastering Annotations
		Discovering Annotations
		Declaring Annotation Types and Annotating Source Code
			Using Meta-annotations in Annotation Type Declarations
		Processing Annotations
	Mastering Generics
		Collections and the Need for Type Safety
		Generic Types
			Declaring and Using Your Own Generic Types
			Type Parameter Bounds
			Type Parameter Scope
			The Need for Wildcards
		Generic Methods
		Arrays and Generics
	Mastering Enums
		The Trouble with Traditional Enumerated Types
		The Enum Alternative
			Enhancing an Enum
		The Enum Class
			Extending the Enum Class
	Summary
Chapter 7: Exploring the Basic APIs, Part 1
	Exploring Math
	Exploring Number and Its Children
		BigDecimal
		BigInteger
		Primitive Type Wrapper Classes
			Boolean
			Character
			Float and Double
			Integer, Long, Short, and Byte
	Exploring String, StringBuffer, and StringBuilder
		String
		StringBuffer and StringBuilder
	Exploring System
	Exploring Threads
		Runnable and Thread
		Synchronization
			Mutual Exclusion, Monitors, and Locks
			Visibility
			Waiting and Notification
			Deadlock
		Thread-Local Variables
	Summary
Chapter 8: Exploring the Basic APIs, Part 2
	Exploring Random
	Exploring Reflection
		The Class Entry Point
			Obtaining a Class Object
			Instantiating a Dynamically Loaded Class
		Constructor, Field, and Method
			Accessibility of Objects
		Package
		Array
	Exploring StringTokenizer
	Exploring Timer and TimerTask
	Summary
Chapter 9: Exploring the Collections Framework
	Exploring Collections Framework Fundamentals
		Comparable vs. Comparator
		Iterable and Collection
			Iterator and the Enhanced For Loop Statement
			Autoboxing and Unboxing
	Exploring Lists
		ArrayList
		LinkedList
	Exploring Sets
		TreeSet
		HashSet
		EnumSet
	Exploring Sorted Sets
	Exploring Navigable Sets
	Exploring Queues
		PriorityQueue
	Exploring Deques
		ArrayDeque
	Exploring Maps
		TreeMap
		HashMap
		IdentityHashMap
		WeakHashMap
		EnumMap
		Exploring Sorted Maps
		Exploring Navigable Maps
	Exploring the Arrays and Collections Utility APIs
	Exploring the Legacy Collection APIs
	Summary
Chapter 10: Functional Programming
	Functions and Operators
	Lambda Calculus
	Entering a Stream
	Mapping
	Filtering
	Terminating a Stream
	Performing Actions on Each Element
	Limiting, Skipping, Sorting, and Distinct
	Ranges
	Reducing
	Collecting
	Methods As Functions
	Single-Method Interfaces
	Streams and Parallelization
	Protonpack, a Stream Utility Library
	Summary
Chapter 11: Exploring the Concurrency Utilities
	Introducing the Concurrency Utilities
	Exploring Executors
	Exploring Synchronizers
		Countdown Latches
		Cyclic Barriers
		Exchangers
		Semaphores
	Exploring the Concurrent Collections
		Exploring the Locking Framework
		Lock
		ReentrantLock
		Condition
		ReadWriteLock
		ReentrantReadWriteLock
	Exploring Atomic Variables
	Summary
Chapter 12: Performing Classic I/O
	Working with the File API
		Constructing File Instances
		Learning About Stored Abstract Pathnames
		Learning About a Pathname’s File or Directory
		Obtaining Disk Space Information
		Listing Directories
		Creating and Manipulating Files and Directories
		Setting and Getting Permissions
	Working with the RandomAccessFile API
	Working with Streams
		Stream Classes Overview
		ByteArrayOutputStream and ByteArrayInputStream
		FileOutputStream and FileInputStream
		PipedOutputStream and PipedInputStream
		FilterOutputStream and FilterInputStream
		BufferedOutputStream and BufferedInputStream
		DataOutputStream and DataInputStream
		Object Serialization and Deserialization
			Default Serialization and Deserialization
			Externalization
		PrintStream
		Standard I/O Revisited
	Working with Writers and Readers
		Writer and Reader Classes Overview
		Writer and Reader
		OutputStreamWriter and InputStreamReader
		FileWriter and FileReader
	Summary
Chapter 13: Accessing Networks
	Accessing Networks via Sockets
		Socket Addresses
		Socket Options
		Socket and ServerSocket
		DatagramSocket and MulticastSocket
	Accessing Networks via URLs
		URL and URLConnection
		URLEncoder and URLDecoder
		URI
	Accessing Network Interfaces and Interface Addresses
	Managing Cookies
	Summary
Chapter 14: Migrating to New I/O
	Working with Buffers
		Buffer and Its Children
	Working with Channels
		Channel and Its Children
	Working with Selectors
		Selector Fundamentals
		Selector Demonstration
	Working with Regular Expressions
		Pattern, PatternSyntaxException, and Matcher
		Character Classes
		Capturing Groups
		Boundary Matchers and Zero-Length Matches
		Quantifiers
		Practical Regular Expressions
	Working with Charsets
		A Brief Review of the Fundamentals
		Working with Charsets
		Charsets and the String Class
	Working with Formatter and Scanner
		Working with Formatter
		Working with Scanner
	Summary
Chapter 15: Accessing Databases
	Introducing Apache Derby
		Apache Derby Installation and Configuration
		Apache Derby Demos
		Apache Derby Command-Line Tools
		Starting an Apache Derby Server
		Embedded Apache Derby Example
	Introducing SQLite
	Accessing Databases via JDBC
		Data Sources, Drivers, and Connections
		Statements
			Statement and ResultSet
			PreparedStatement
			CallableStatement
		Metadata
	Summary
Chapter 16: Working with XML and JSON Documents
	What Is XML?
		XML Declaration
		Elements and Attributes
		Character References and CDATA Sections
		Namespaces
		Comment and Processing Instructions
		Well-Formed Documents
		Valid Documents
			Document Type Definition
			XML Schema
	Parsing XML Documents with SAX
		Exploring the SAX API
		Demonstrating the SAX API
	Parsing and Creating XML Documents with DOM
		A Tree of Nodes
		Exploring the DOM API
			Parsing XML Documents
			Creating XML Documents
	What Is JSON?
	JSON Processing in Java
		Generating JSON
		Parsing JSON
	Summary
Chapter 17: Date and Time
	The Traditional Date and Time API
		About Dates and Calendars
		Date and Time Formatters
		Parsing
	The New Date and Time API
		Local Dates and Times
		Instants
		Offset Dates and Times
		Zoned Dates and Times
		Duration and Periods
		Clock
	Summary
Appendix A: Solutions to Exercises
	Chapter 1: Getting Started with Java
	Chapter 2: Learning Language Fundamentals
	Chapter 3: Discovering Classes and Objects
	Chapter 4: Discovering Inheritance, Polymorphism, and Interfaces
	Chapter 5: Mastering Advanced Language Features, Part 1
	Chapter 6: Mastering Advanced Language Features, Part 2
	Chapter 7: Exploring the Basic APIs, Part 1
	Chapter 8: Exploring the Basic APIs, Part 2
	Chapter 9: Exploring the Collections Framework
	Chapter 10: Functional Programming
	Chapter 11: Exploring the Concurrency Utilities
	Chapter 12: Performing Classic I/O
	Chapter 13: Accessing Networks
	Chapter 14: Migrating to New I/O
	Chapter 15: Accessing Databases
	Chapter 16: Working with XML and JSON Documents
	Chapter 17: Date and Time
Index