Course Description:

Intermediate Java™ and OO Development Using Rational™ Application Developer (RAD)

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.

Course Information

Duration: 5 days

Hands-on: 50% hands-on, 50% lecture

Supported Platforms: Bare Sun JDK, IBM RAD, Eclipse

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

Course Details:

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

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

Reflection

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