104. Intermediate Java Programming

Rev. 5.0.2

 

This course is now available directly from our partner, Capstone Courseware.

This course teaches programming in the Java language – the Java 2 Standard or J2SE platform.  It is intended for students with previous Java experience or training, who already know the fundamentals of the Java architecture and basic procedural programming.  This course provides in-depth coverage of object-oriented concepts and how to apply them to Java software design and development.  The latter part of the course moves key parts of the J2SE Core API, including collections, exception-handling, logging, streams, and object serialization.  The course software also includes an optional overlay of workspace and project files to support use of the Eclipse IDE in the classroom.  (This requires that the instructor be experienced in use of Eclipse and able to walk students through basic tasks in the IDE.)

 

This revision of the course targets the 5.0 version of the Java language and Core API.  (Java 5.0 is also known as Java 1.5, as this revision effects a transition to a new numbering scheme for the Java environment.)  It has been rebuilt thoroughly, not only to cover new 5.0 language features, but also to comb out old programming techniques in favor of new ones.  A special appendix to the course addresses practical issues of compatibility between 1.4 and 5.0 code, compilers, and runtimes, and discusses migration strategies.  (For training within the Java 1.4 environment, please see version 1.4.3 of this course, which works to the old version but looks ahead to some 5.0 language features; to read more about different versions of Java and for help deciding on which version of this course to use, see “Java Versions and Terminology Demystified”.)

 

LEARNING OBJECTIVES

 

·         Chiefly, learn to program effectively in the Java language.

·         Understand Java as a purely object-oriented language, and implement software as systems of classes.

·         Implement and use inheritance and polymorphism, including interfaces and abstract classes.

·         Design appropriate exception handling into Java methods.

·         Use the standard logging API to write diagnostic information at runtime.

·         Understand the structure of streams in Java, and learn how to use streams to manage file I/O.

·         Learn how to use Java Serialization to internalize and externalize potentially complex graphs of objects.

 

Course Duration:  5 days 

 

Prerequisites:  Students must be able to write, compile, test, and debug simple Java programs, using structured programming techniques, strong data types, and flow-control constructs such as conditionals and loops.  Object Innovations’ Course 102 is ideal preparation for this course.

 

1. Review of Java Fundamentals

The Java Architecture

Forms for Java Software

Three Platforms

The Java Language

Numeric Types

Characters and Booleans

Enumerations

Object References

Strings and Arrays

Conditional Constructs

Looping Constructs

Varargs

 

2. Object-Oriented Software

Complex Systems

Abstraction

Classes and Objects

Responsibilities and Collaborators

UML

Relationships

Visibility

 

3. Classes and Objects

Java Classes

Constructors and Garbage Collection

Naming Conventions and JavaBeans

Relationships Between Classes

Using this

Visibility

Packages and Imports

Overloading Methods and Constructors

JARs

 

4. Inheritance and Polymorphism in Java

UML Specialization

Extending Classes

Using Derived Classes

Type Identification

Compile-Time and Run-Time Type

Polymorphism

Overriding Methods

Superclass Reference

 

5. Using Classes Effectively

Class Loading

Static Members

Statics and Non-Statics

Static Initializers

Static Imports

Prohibiting Inheritance

Costs of Object Creation

Strings and StringBuffers

Controlling Object Creation

Understanding Enumerated Types

Stateful and Behavioral Enumerations

 

6. Interfaces and Abstract Classes

Separating Interface and Implementation

UML Interfaces and Realization

Defining Interfaces

Implementing and Extending Interfaces

Abstract Classes

 

7. Collections

Dynamic Collections vs. Arrays

UML Parameterized Type

Generics

Using Generics

The Collections API

The Collection<E> and List<E> Interfaces

The ArrayList<E> and LinkedList<E> Classes

Looping Over Collections: Iterable<E>

Collecting Primitive Values: Auto-Boxing

Using Wildcards with Generic Types

Iterators and the Iterator<E> Interface

Maps and the Map<K,V> Interface

Sorted Collections

The SortedSet<E> and SortedMap<K,V> Interfaces

The Collections Class Utility

Algorithms

Conversion Utilities

 

8. Exception Handling and Logging

Reporting and Trapping Errors

Exception Handling

Throwing Exceptions

Declaring Exceptions per Method

Catching Exceptions

The finally Block

Catch-and-Release

Chaining Exceptions

The J2SE Logging API

Severity Levels

Log Hierarchies

 

9. Inner Classes

Passing Behavior

Inner Classes in GUI Programming

Named Inner Classes

Outer Object Reference

Static Inner Classes

Anonymous Inner Classes

 

10. The Java Streams Model

Delegation-Based Stream Model

InputStream and OutputStream

Media-Based Streams

Filtering Streams

Readers and Writers

 

11. Working with Files

File Class

Modeling Files and Directories

File Streams

Random-Access Files

 

12. Advanced Stream Techniques

Buffering

Data Streams

Push-Back Parsing

Byte-Array Streams and String Readers and Writers

 

13.  Java Serialization

The Challenge of Object Serialization

Serialization API

Serializable Interface

ObjectInputStream and ObjectOutputStream

The Serialization Engine

Transient Fields

readObject and writeObject

Externalizable Interface

 

17.  Automated Unit Testing with JUnit

Automated Testing

JUnit and Related Tools

TestCases and TestSuites

TestRunners

TestResults and Asserts

Developing JUnit Tests

 

Appendix A.  Learning Resources

 

Appendix B.  Compatibility and Migration

Compatibility: Compiler and Runtime

Mixing 1.4 and 5.0 Classes

Compatibility with Generics: Type Erasure

Compatibility with Enumerations and Varargs

Migrating 1.4 Code to 5.0

Runtime Type Safety with “Checked” Collections

 

 

System Requirements

 

Hardware – minimal:                     Pentium 500MHz, 128 meg RAM, 500 meg HD.

Hardware – recommended:           Pentium 1.5gHz, 512 meg RAM, 1 gig HD.

 

Operating system:                          Tested on Windows XP Professional.  The course software should be viable on all Windows or Linux systems which support J2SE 5.0.

 

Software:                                       All free downloadable tools.