Intermediate Java™ and OO Development

Java Training Overview

Intermediate Java and OO Development is a fast paced course suitable for programmers with some previous experience in working with Java and Object-Oriented (OO) programming (equivalent to taking our Gentle Java course). It includes a short review of basic Java concepts, and then moves on to a comprehensive coverage of more advanced topics in Java and OO programming to provide participants with a strong grounding in using Java in a sophisticated and productive manner.

This course goes well beyond the basics of Java and OO programming and covers important topics such as composition, inheritance, polymorphism, interfaces and exceptions, which are all key to creating well-structured OO systems using Java. After coverage of these important areas, it moves on to more advanced topics such as JDBC (for database access), the Java Collections Framework - including the generics capabilties introduced in Java 5, Java I/O, assertions, inner classes, and the reflection API. Finally it covers useful tools for day-to-day programming such as ant, JUnit and various logging frameworks.

This course covers far more than an introductory course, and provides participants with a comprehensive understanding of how to use Java's advanced capabilities in a more sophisticated manner. It teaches a number of useful techniques that enhance productivity and good system design - which Java programmers may otherwise take years to absorb on their own.

This course is suitable for environments using Java 5, or Java 6. All labs are doable in any of the supported Java environments. The course may be done using JDK 1.4, by skipping the labs that use Java 5+ capabilities. The course is fast-paced and interesting. Be prepared to work hard and learn a great deal! The course can be held on-site & customized to fit your needs.

Java Training Skills Gained

  • Review Java language basics
  • Review using composition and delegation to create objects from other objects
  • Review inheritance and polymorphism
  • Understand interfaces, their importance, and their uses
  • Use interfaces to implement abstraction
  • Understand & use exceptions for error handling
  • Understand the basics of using JDBC, and use it to access databases from Java
  • Use the Java 2 Collections Framework (including use of Java Generics)
  • Understand and use basic I/O streams
  • Understand and use Java assertions
  • Learn how to write and use Inner Classes
  • Be familiar with and use Java reflection
  • Understand and use ant and ant buildfiles
  • Understand test-driven development, and use JUnit for tesing Java programs
  • Be familiar with Java logging (especially log4j) and use it in your programming

50% hands-on, 50% lecture

Supported Platforms

Bare Sun JDK, IBM RAD, Eclipse

Java Training Course Duration

5 Days

Java Training Course outline

Java Review

  • Writing Java programs
  • Creating classes with fields and methods
  • Encapsulation and access protection
  • Cconstructors
  • Flow of Control
  • Strings and Arrays

Review - More Advanced OO Concepts in Java

  • Using packages to organize code
  • Using Composition to Create complex classes
  • Using Inheritance and Polymorphism to share commonality

Interfaces and Abstract Classes

  • Programming by Contract
  • Using Interfaces to Define Types
  • Interfaces and Abstract Classes
  • LABS:
    • Using Interfaces to Remove Implementation Dependencies

Error Handling

  • Exceptions
  • Exception Hierarchy
  • try and catch
  • Handling Exceptions
  • Program Flow with Exceptions
  • Finally
  • LABS:
    • Handle Exceptions
    • Define Exception Class


  • JDBC basics
  • JDBC Architecture
  • Using JDBC drivers & DriverManager
  • Class Connection and connecting to a database
  • Class Statement and executing SQL statements
  • Other statement types
  • Driver types
  • LABS: 
    • Interacting with an existing database using JDBC

Java 2 Collections Framework

  • The Collections Framework
  • Collection Interfaces
  • Collection, Set, List, Map, Iterator
  • Generics  (Java 5)
  • Processing Items With an Iterator
  • for-each Loop (Java 5)
  • Using ArrayList
  • Using HashMap
  • LABS: 
    • Using Collections
    • Iterating Over a Collection

Additional Java Features (including Java 5)

  • Assertions
  • Autoboxing
  • Type-safe Enums
  • Annotations

I/O Streams

  • Readers and Writers
  • Filter Streams
  • InputStreams and OutputStreams
  • Converting Between Streams and Readers/Writers
  • New I/O (NIO) APIs
  • LABS:
    • Using Java I/O to Read and Write

Inner Classes

  • Why Use Inner Classes?
  • Named Inner Classes
  • Static Inner Classes
  • Anonymous Inner Classes
  • LABS:
    • Using Named Inner Classes
    • Using Anonymous Inner Classes


  • The class called Class
  • Finding Fields, Methods, and Constructors
  • Accessing Fields, Invoking Methods
  • Examining Arrays
  • LABS:
    • Examining Objects Using Reflection
    • Accessing Fields and Invoking Methods via Reflection

ant: Basics

  • ant Overview, Installing and Running ant
  • Buildfiles, Projects, Targets, Tasks, Properties
  • Creating Build Files
  • Paths(e.g. CLASSPATH, PATH)
  • Resource Collections - FileSets, DirSets, Files, PatternSets
  • Other Resource Collections and Selectors
  • LABS: 
    • Running ant
    • Creating and Using Buildfiles
    • Using Basic ant Tasks
    • Working with Paths
    • Using Resource Collections

ant: Tasks

  • Overview of ant Tasks
  • <javac> and <java> Tasks in Depth
  • Creating Java Archives - <jar>, <war>, <ear>
  • File Related Tasks, Other Useful Tasks
  • LABS: 
    • Working with <javac> and <java>
    • Creating Archives
    • Working With File Tasks

ant: Modularity

  • Properties Files
  • The <ant> Task and SubProjects
  • The <import> Task For Importing Buildfiles
  • LABS: 
    • Working With Properties Files
    • Creating Modular Buildfiles

JUnit: Basics

  • JUnit Overview, Test Driven Development
  • Tests and Assertions
  • Working With Exceptions
  • LABS:
    • Writing and Running Tests
    • Testing Exceptions

JUnit: Organizing Tests

  • Writing Fixtures - @Before, @After
  • Test Suites, and Other Capabilities
  • Mock Objects
  • LABS:
    • Using Fixtures
    • Using Suites

Logging: Basics

  • Logging Overview
  • log4j Overview
  • Loggers, Appenders, Layouts
  • Configuring log4j
  • Using log4j
  • LABS:
    • Setting Up log4j
    • Using Basic log4j Logging

Logging: More On log4j

  • Logger Heirarchy
  • Logging Levels
  • Working With Appenders
  • Using PatternLayout
  • Other Logging Frameworks (Java Logging, Apache Commons Logging)
  • LABS:
    • Working With Loggers
    • Working With Appenders
    • Using Layouts

Wintrac Inc.
16523 SW McGwire Ct.
Beaverton OR 97007
© Wintrac, Inc. All rights reserved.                                                                               Site Map   |   Terms of Use   |   Privacy Policy