Head First Java

1. Java's Foundation: Classes, Objects, and the JVM

Kathy and Bert’s ‘Head First Java’ transforms the printed page into the closest thing to a GUI you’ve ever seen.

Classes and Objects. Java is fundamentally object-oriented, meaning everything revolves around classes and objects. A class serves as a blueprint, defining the structure and behavior of objects. Objects, on the other hand, are instances of a class, each possessing its own unique state (data) and the ability to perform actions (methods).

The Java Virtual Machine. The JVM is the engine that executes Java bytecode, the compiled form of Java source code. This bytecode is platform-independent, allowing Java applications to run on any device with a JVM. The JVM is responsible for memory management, including garbage collection, which automatically reclaims memory occupied by objects that are no longer in use.

Compilation and Execution. The Java development process involves writing source code in .java files, compiling it into bytecode using the javac compiler, and then running the bytecode on the JVM using the java command. The JVM interprets the bytecode and translates it into machine code that the underlying operating system can understand and execute.

2. Variables: Primitives, References, and Memory

Variables come in two flavors: primitive and reference.

Primitive Types. Java offers eight primitive data types for storing basic values: boolean, char, byte, short, int, long, float, and double. Each primitive type has a specific size and range of values it can hold. Primitive variables store the actual values directly in memory.

Reference Variables. Reference variables, on the other hand, do not store the object itself. Instead, they hold a reference, a pointer, or an address that indicates where the object is located in memory (on the heap). Multiple reference variables can point to the same object.

The Heap and the Stack. Objects are created and stored on the heap, a region of memory managed by the JVM's garbage collector. Local variables, including method parameters, are stored on the stack, a region of memory used for method invocations and temporary data. Understanding the distinction between the heap and the stack is crucial for understanding memory management and object lifecycles in Java.

3. Methods: Behavior, Arguments, and Return Types

Methods use object state (bark different).

Methods and Object Behavior. Methods define the actions that an object can perform. They operate on the object's state, represented by its instance variables. The behavior of a method can vary depending on the object's state.

Arguments and Parameters. Methods can accept arguments, which are values passed into the method when it is called. The method declares parameters, which are local variables that receive the argument values. Java is pass-by-value, meaning that the argument value is copied into the parameter variable.

Return Types. Methods can also return values, which are sent back to the caller of the method. The return type of a method must be declared in the method signature. If a method does not return a value, its return type is void.

4. Leveraging the Java API: Pre-Built Classes and Packages

You don’t have to reinvent the wheel if you know how to find what you need from the Java library, commonly known as the Java API.

The Java API. The Java API is a vast collection of pre-built classes and interfaces that provide a wide range of functionality, from basic data structures to networking and GUI components. By leveraging the API, developers can avoid reinventing the wheel and focus on building custom features for their applications.

Packages. Classes in the Java API are organized into packages, which are namespaces that help prevent naming collisions and provide a logical structure for the library. To use a class from the API, you must either import the package containing the class or use the fully-qualified name of the class.

Exploring the API. The Java API documentation is an invaluable resource for learning about the available classes and methods. The documentation provides detailed information about each class, including its purpose, methods, and usage examples. Reference books and online resources can also be helpful for exploring the API.

5. Object-Oriented Design: Inheritance and Polymorphism

When you get on the Polymorphism Plan, you’ll learn the 5 steps to better class design, the 3 tricks to polymorphism, the 8 ways to make flexible code, and if you act now—a bonus lesson on the 4 tips for exploiting inheritance.

Inheritance. Inheritance allows you to create new classes (subclasses) that inherit the properties and behaviors of existing classes (superclasses). This promotes code reuse and reduces redundancy. Subclasses can add new methods and instance variables, as well as override methods inherited from the superclass.

Polymorphism. Polymorphism enables you to treat objects of different classes in a uniform way. This is achieved through inheritance and interfaces. A superclass reference can refer to an object of any of its subclasses, and you can call methods on that reference without knowing the exact type of the object.

IS-A Relationship. The IS-A test is a useful guideline for determining whether inheritance is appropriate. If it makes sense to say "A is a B," then class A should inherit from class B. For example, a Dog IS-A Animal, so Dog should extend Animal.

6. Abstract Classes and Interfaces: Achieving Flexibility

Inheritance is just the beginning.

Abstract Classes. Abstract classes cannot be instantiated directly. They serve as blueprints for subclasses, defining common properties and behaviors. Abstract classes can contain both abstract methods (methods without implementation) and concrete methods (methods with implementation).

Interfaces. Interfaces define a contract that classes can implement. An interface specifies a set of methods that a class must implement if it claims to implement the interface. Interfaces cannot contain instance variables or concrete methods (except for default methods, introduced in Java 8).

Polymorphism with Interfaces. Interfaces provide a powerful way to achieve polymorphism. You can declare a reference variable of an interface type and assign it an object of any class that implements that interface. This allows you to write code that works with objects of different classes in a uniform way.

7. Exception Handling: Managing Risky Operations

Exceptions say “something bad may have happened...”

Exceptions. Exceptions are events that disrupt the normal flow of a program's execution. They typically indicate errors or exceptional conditions that the program cannot handle in the usual way. Java provides a robust exception-handling mechanism to deal with these situations.

Try-Catch Blocks. To handle exceptions, you can enclose risky code in a try block. If an exception occurs within the try block, the program jumps to the corresponding catch block, where you can take appropriate action, such as logging the error, displaying a message to the user, or attempting to recover from the problem.

Checked and Unchecked Exceptions. Java distinguishes between checked and unchecked exceptions. Checked exceptions must be either handled in a catch block or declared in the method signature using the throws keyword. Unchecked exceptions, which are subclasses of RuntimeException, do not require explicit handling or declaration.

8. Swing and GUIs: Creating Interactive Applications

Face it, you need to make GUIs.

Swing Components. Swing is a GUI toolkit that provides a rich set of components for building interactive applications. Swing components are lightweight, platform-independent, and highly customizable.

Layout Managers. Layout managers are responsible for arranging components within a container, such as a JFrame or JPanel. Different layout managers have different policies for determining the size and position of components. Common layout managers include BorderLayout, FlowLayout, and BoxLayout.

Event Handling. Event handling is the process of responding to user actions, such as button clicks, mouse movements, and keyboard input. To handle events, you must implement a listener interface, register the listener with the event source, and define the event-handling method.

9. Data Structures: Collections and Generics

Sorting is a snap in Java.

Collections Framework. The Java Collections Framework provides a set of interfaces and classes for storing and manipulating groups of objects. Common collection types include List, Set, and Map.

Generics. Generics allow you to specify the type of objects that a collection can hold. This improves type safety and reduces the need for casting. For example, ArrayList<String> declares a list that can hold only String objects.

Sorting. The Collections.sort() method provides a convenient way to sort lists. To sort objects of a custom class, the class must implement the Comparable interface or you must provide a custom Comparator.

10. Packaging and Deployment: Releasing Your Code

It’s time to let go.

JAR Files. A JAR (Java Archive) file is a compressed archive that bundles all the class files, resources, and metadata for a Java application into a single file. JAR files make it easier to distribute and deploy Java applications.

Executable JARs. To make a JAR file executable, you must include a manifest file that specifies the main class of the application. The manifest file is a simple text file that contains key-value pairs.

Java Web Start. Java Web Start (JWS) is a technology that allows you to deploy stand-alone Java applications over the Web. JWS applications are launched from a web browser and run outside the browser sandbox, providing access to system resources.

11. Distributed Computing: RMI and Remote Services

Being remote doesn’t have to be a bad thing.

Remote Method Invocation (RMI). RMI is a Java API that allows you to invoke methods on objects running in a different JVM, potentially on a different machine. RMI simplifies the process of building distributed applications.

RMI Architecture. RMI involves several key components: the remote interface, the remote implementation, the stub (client-side proxy), and the skeleton (server-side proxy). The client interacts with the stub, which handles the communication with the server. The server receives the request and invokes the method on the remote implementation.

RMI Registry. The RMI registry is a naming service that allows clients to locate remote objects. The server registers its remote objects with the registry, and clients can look up those objects by name.

Last updated: July 23, 2025