The Hands-On Java Seminar

Second Edition (reconfigured for HTML5 in 2013)
by Bruce Eckel

Welcome to the Hands-On Java Seminar, a multimedia learning experience incorporating slides + audio lectures. This is based on Thinking in Java, Second Edition (the HTML version of the book is included in this eSeminar), published way back in 2000 for Java version 1.2.

Although I was initially hesitant to reconfigure the course for modern HTML5 browsers, upon reviewing the material I realized that most of it is still relevant for today's new Java programmers so the course continues to have significant value. To be completely clear: this is the identical content that was published in 2000, but I still think you'll find it beneficial. My apologies to everyone for misdirections in the books and elsewhere: this is the final version of this eSeminar, despite various declarations of upcoming versions.

All the lectures in the seminar are self-explanatory, and the first one (Introduction and Overview) describes what to expect throughout the course.

For beginning programmers, I've included the Thinking in C seminar by Chuck Allison, which has over 6 hours of slide + audio lectures that introduce you to programming and get you up to speed on the fundamentals of the C syntax used for both Java and C++.

This product is not copy protected so you can easily place it on all your devices. However, it is copyrighted material -- please encourage others to purchase their own copies.

The free preview of this seminar includes the first three slides of each lecture (see the top of this page).


Table of Contents
 
Installation
Introduction and Overview
1: Introduction to Objects
2: Everything is an Object
3: Controlling Program Flow
Thinking in C Seminar
4: Initialization & Cleanup
5: Hiding the Implementation
6: Reusing Classes
7: Polymorphism
8: Interfaces & Inner Classes
9: Holding Your Objects
10: Error Handling with Exceptions
11: The Java I/O System
12: Run-Time Type Identification
13: Creating Windows & Applets
14: Multiple Threads
15: Distributed Computing
A: Passing & Returning Objects
Printing the Slide Notes
Where to go next ...
Source code from examples
Thinking in Java electronic book
Compilers and Editors
Issues and Feedback
Credits

Installation

This seminar uses HTML5 which is supported by the latest Web browsers. The seminar has been tested with Chrome Version 30, FireFox Version 24, Internet Explorer Version 10, and Safari 1.5.7. One or more of those browsers has worked on Windows, Mac and Linux.

iPad: The Hands-on Java Seminar (but NOT Thinking in C, because of its use of Flash) will work on the iPad, but you must transfer it using a tool like FileApp on the iPad and its companion DiskAid on your computer.

Android Tablets: I've had some limited luck with Opera Mobile (not Mini!) but it has trouble navigating and controlling the sound, so with Android tablets you're better off using a laptop/desktop instead.

Phones: This product is not intended to work on phones.

Download the free demonstration package (at the top of this page) before buying, to ensure you can get it working on your device.

If you have any problems playing the lectures, try updating your browser or using a different browser.

NOTE: With Internet Explorer, you'll need to press the "Allow Blocked Content" button on the dialog that pops up once per browser session when running the lectures.

Once you begin playing a lecture, you will automatically move to the next slide until you reach the end of that lecture. You can also skip forward and backward using the "Next Slide" and "Previous Slide" buttons. You can move to the next lecture with the "Next Lecture" button, and return to this page using the "Home" button.

The slides in this seminar are also available in printable "handout" form, with three slides to a page and space to take notes next to each slide. This is in Adobe Acrobat PDF form, so if you haven't done so already, you'll need to go to the Adobe Site to download and install the Acrobat Reader. Other PDF readers are freely available on the Internet. Most PDF readers also provide the ability to print the slides.


Introduction and Overview

26 Minutes :: 5 Slides

Start Lecture    Book Introduction    Book Index    PDF notes

Back to Table of Contents

An overview of the course including prerequisites, what will be covered, and a brief introduction.


1. Introduction to Objects

38 Minutes :: 5 Slides

Start Lecture   Book Chapter 1    Book Index    PDF notes

Back to Table of Contents

An introduction to the concepts of Object-Oriented Programming (OOP) and a discussion of why Java is an object-oriented language, as well as an overview of the major features of Java.


2. Everything is an Object

45 Minutes :: 18 Slides

Start Lecture   Book Chapter 2    Book Index    PDF notes

Back to Table of Contents

First language details of Java, including how to create basic objects in Java. In this section you'll get enough information to write your first Java program.


3. Controlling Program Flow

1 Minute :: 1 Slide

Start Lecture      PDF notes

Back to Table of Contents

This is a placeholder for Chapter 3 in Thinking in Java, 2nd edition, which is basically a coverage of the C syntax that is common to Java. The Hands-On Java Seminar assumes you understand the fundamentals of C syntax. If you don't, use the link below to go to the Thinking in C Seminar by Chuck Allison, which covers the basics of C as a preparation for either C++ or Java. Thinking in C is a course for beginners.

Start Thinking in C Seminar   Chapter 3 of Thinking in Java (Similar Coverage)


4. Initialization & Cleanup

44 Minutes :: 18 Slides

Start Lecture   Book Chapter 4    Book Index    PDF notes

Back to Table of Contents

This lecture introduces constructors and garbage collection in Java. The constructor helps guarantee proper initialization, and the garbage collector automatically releases memory when it is no longer being used. The lecture also examines the issues of initialization and cleanup and their support in Java.


5. Hiding the Implementation

24 Minutes :: 12 Slides

Start Lecture   Book Chapter 5    Book Index    PDF notes

Back to Table of Contents

A primary consideration in object-oriented design is separating the things that change from the things that stay the same. In this lecture, you will learn about access specifiers, which allow library creators to designate what is available to client programmers and what is not.


6. Reusing Classes

78 Minutes :: 30 Slides

Start Lecture   Book Chapter 6    Book Index    PDF notes

Back to Table of Contents

Here you will learn two ways to take existing code and mold it into new forms. These mechanisms do not simply copy code and change it. Instead, they allow you to reuse code by creating new classes from existing classes that someone has already built and debugged. The first technique is called composition. Using composition you place objects of an existing class inside a new class. The second approach, inheritance, copies the form of an existing class and adds code without modifying the original class, thus creating a new type of the existing class.


7. Polymorphism

44 Minutes :: 34 Slides

Start Lecture   Book Chapter 7    Book Index    PDF notes

Back to Table of Contents

Polymorphism provides another dimension of the separation of interface from implementation, decoupling the what from the how. It allows improved code organization and readability as well as the creation of extensible programs that can be "grown" not only during the original creation of the project, but also when new features are desired. In this lecture, you will learn about polymorphism starting from the basics, with simple examples that strip away everything but the core concepts.


8. Interfaces & Inner Classes

48 Minutes :: 29 Slides

Start Lecture   Book Chapter 8    Book Index    PDF notes

Back to Table of Contents

Interfaces and inner classes provide sophisticated ways to organize and control the objects in your system. Interfaces allow you to determine the basic methods of the class that your code will work with, without over-specifying (that is, you don't have to know the exact type). Inner classes allow, among other things, the creation of objects that can "call back" into their parent objects.


9. Holding Your Objects

109 Minutes :: 68 Slides

Start Lecture   Book Chapter 9    Book Index    PDF notes

Back to Table of Contents

Java has several ways to hold objects so you can easily use them in your program. In this lecture, we look closely at the array (which was first introduced in Lecture 4), and examine container classes (also called collections) and the sophisticated ways in which they hold and manipulate objects. This lecture focuses on the "new" collections in Java 2.


10. Error Handling with Exceptions

64 Minutes :: 44 Slides

Start Lecture   Book Chapter 10    Book Index    PDF notes

Back to Table of Contents

The basic philosophy of Java is that badly formed code will not run. This lecture introduces you to Java's approach to error reporting: Exception Handling. You will learn how to use and respond to existing Java exceptions and how to create and catch your own exceptions.


11. The Java I/O System

54 Minutes :: 36 Slides

Start Lecture   Book Chapter 11    Book Index    PDF notes

Back to Table of Contents

Creating a good input/output (I/O) system is one of the more difficult tasks for the language designer. This lecture gives you an introduction to the variety of I/O classes in the standard Java library and shows you how to use them. It also examines the basic design of the I/O library in an attempt to make it more comprehensible.


12. Run-Time Type Identification

44 Minutes :: 29 Slides

Start Lecture   Book Chapter 12    Book Index    PDF notes

Back to Table of Contents

Java allows you to discover information about objects and classes at run-time. This takes two forms: "traditional" RTTI, which assumes that you have all the types available at compile-time, and the "reflection" mechanism, which allows you to discover class information solely at run-time.


13. Creating Windows & Applets

79 Minutes :: 55 Slides

Start Lecture   Book Chapter 13    Book Index    PDF notes

Back to Table of Contents

This lecture covers the Java Swing library and makes the assumption that Swing is the final destination Graphical User Interface (GUI, typically pronounced "goo-ee") library for Java. You will learn the difference between creating an applet vs. a regular application using Swing, and how to create programs that are both applets and applications so they can run either inside a browser or from the command line. The goal of this lecture is only to get you started with the essentials of Swing and to be comfortable with the concepts, rather than being a comprehensive coverage of the subject (which tends to require a thick book).


14. Multiple Threads

79 Minutes :: 42 Slides

Start Lecture   Book Chapter 14    Book Index    PDF notes

Back to Table of Contents

In this lecture you will learn the language of threads, as well as when to use them. Threads are generally useful when you have some part of your program waiting on a particular event or resource, and you don't want to tie up the rest of your program during that wait. Often, threads are used to produce a more responsive user interface.


15. Distributed Computing

90 Minutes :: 55 Slides

Start Lecture   Book Chapter 15    Book Index    PDF notes

Back to Table of Contents

This lecture is meant to familiarize you with the topics of distributed computing such as sharing and transferring information from one machine to another, connecting to a database, providing services via a Web server, and executing methods on Java objects that live on remote machines. The associated chapter in the book also covers interacting with code written in other languages, running on other architectures, isolating business logic from connectivity issues, and easily and dynamically adding and removing devices from a network representing a local system.

This section also presents a reasonably thorough introduction to Java Servlets and Java Server Pages (JSPs).


Appendix A. Passing & Returning Objects

56 Minutes :: 33 Slides

Start Lecture   Book Appendix A    Book Index    PDF notes

Back to Table of Contents

By this point in the seminar, you should be comfortable with the idea that when you're "passing" an object, you're actually passing a reference. However, there comes a point where it's important that you understand exactly what's happening as you pass objects around and manipulate them, and how to produce the effect of passing an object into a method "by value." This appendix provides that insight, and in particular explains Java's somewhat arcane clone().


Printing the Slide Notes

PDF Files with slide notes

Back to Table of Contents

The slides in this seminar are also available in printable "handout" form, with three slides to a page and space to take notes next to each slide. This is in Adobe Acrobat PDF form, so if you don't already have the free Acrobat Reader,you'll need to go to the Adobe Site to download and install it (other PDF viewers are freely available on the Internet).


Where to go next ...

Back to Table of Contents

The appendices in the book have further information that you may find valuable:

Book Appendix A
Book Appendix B
Book Appendix C
Book Appendix D
Book Index

Be sure to visit MindView to download other books, and to learn about other seminars and products.


Source Code

Back to Table of Contents

All the Java source code files are available in a ZIP file, which can be unzipped directly onto your computer. The unzipping process creates all the appropriate files and directories. All modern operating systems include a tool for unzipping; if you don't have one they are freely available on the Internet.


Thinking in Java Electronic Book

Back to Table of Contents

This package also includes an electronic version of the book Thinking in Java, 2nd edition. Click here to open the book. Note that a link to the corresponding chapter for each lecture is provided above, in the lecture introductions.


Compilers and Editors

Back to Table of Contents

This package does not include any editing or compilation tools for Java. It is your responsibility to download and install the tools of your choice.

To install the free Java Development Kit (JDK), go here.

If you don't know which editor to choose, try Sublime Text, which is available for an unlimited free trial.


Issues and Feedback

Back to Table of Contents

If you run into problems or would like to make comments about this eSeminar, you can give feedback


Credits

Back to Table of Contents

Course development, slide creation, recording, production, and post-processing: Bruce Eckel

Graphic Design: Daniel Will-Harris

Sound Editing, Editing assistance: Sharlynn Cobaugh