What You Will Learn With This eBook
Learn about high level programming concepts with simple, straightforward examples. Understand the best practices that encourage beautifully written code.
Dive into the details of the language with thorough explanations of exception handling, generics, concurrency, and memory management.
Data Structures and Algorithms
Comprehensive explanations of critical data structures in the Java Collections framework as well as the algorithms that work on them, such as searching and sorting.
Master creational, structural, and behavioral design patterns that every developer should recognize. See real examples of each pattern in the standard Java library.
How to Solve Programming Problems
Follow three simple steps to tackle high-level programming problems. Learn the process of discovering solutions rather than memorizing them with detailed sample problems.
What to Expect During the Interview
I'll walk you through a typical interview and prepare you for personal questions about your experience. I'll also tell you what questions you should ask (and which ones to avoid).
A great reference for job interviews... explanations are clear and concise.
Does exactly what it says on the tin, great book to have handy.
I like this guide because it cuts right to the chase. No fluff, and no wasted time...
Read a Sample Chapter
The Java Programming Language
Object-Oriented Programming (Part I)
Object-Oriented Programming (Part II)
The Object Superclass
Composition & Inheritance
Abstract Classes & Interfaces
Java Database Connectivity
Java Collections Framework
Creational Design Patterns
Structural Design Patterns
Behavioral Design Patterns
Abstraction is the act of perceiving an entity from a broad perspective. For example, in the context of education a person can be generalized as a student, and in the context of employment a person can be generalized as an employee. Each abstraction reduces the attributes of a person to a subset of relevant information. The goal of abstraction is to reduce complexity in software systems.
Encapsulation is a technique that encourages abstraction by purposefully hiding information. For example, the mechanical details of a car engine are encapsulated behind a steering wheel and floor pedals. Anyone familiar with this interface could drive a car without knowing what type of engine was under the hood. Java encourages encapsulation through the use of interfaces and by providing access modifiers that limit the visibility of classes, fields, and methods.
Polymorphism is a technique that encourages abstraction by allowing an entity to assume multiple forms. For example, a smartphone is polymorphic because it can assume the role of a camera, web browser, music player, or digital clock. Each application exposes a relevant interface to the user. In Java, an object can take on the form of any parent in its hierarchy or any interface in its hierarchy.
Mutability refers to the ability of an entity to change its state. An iPod is an example of a mutable entity because its contents frequently change. A vinyl record is an example of an immutable entity because its contents are permanently engraved. Immutable objects provide numerous benefits in software applications, such as stability and thread safety. Strings and all of the primitive wrapper objects are examples of immutable objects. In order to make an object immutable, the class must be final, all fields must be final, and it cannot expose any mutable fields or methods that modify mutable fields.
Coupling refers to the level of dependency that exists between two entities. For example, a cell phone battery that is soldered to a motherboard is tightly coupled because neither the battery nor the motherboard can be replaced without affecting the other component. A battery that snaps into the back of a phone is loosely coupled because both entities could be replaced independently. In software applications, decoupled components are more flexible and easier to maintain.
Cohesion refers to an entity's level of focus. For example, a Swiss Army knife is a low cohesion entity because it can do multiple things, but it can’t do them very well. A multi-tool could never match the productivity of a toolbox filled with highly cohesive tools. In software applications, cohesive components are more robust and easier to test.