Intermediate Java 7 Using Rational Application Developer (RAD) Training

Answers to Popular Questions:

Yes, this class can be tailored to meet your specific training needs.
Yes, we provide Java Programming consulting services.
Yes, group discounts are provided.

Course Description

This 5-day course 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 and JPA 2 (for database access), the Java Collections Framework - including the important generics capabilities, Java I/O, assertions, inner classes, and the reflection API. Finally it covers useful tools for day-to-day programming such as ant, maven, 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.
Course Length: 5 Days
Course Tuition: $2090 (US)


Suitable for programmers with some previous experience in working with Java and Object-Oriented (OO) programming (equivalent to taking our Gentle Java course).

Course Outline

Session 1: Review - Getting Started
Writing and Running Java programs
Setting up and Using the Development Environment
Session 2: Review - Class and Object
Creating classes with fields and methods
Encapsulation and access protection
Other Capabilities (Static Members, null, final, Wrapper Classes
Session 3: Review - Control Flow, String, and Array
Flow of Control
Session 4: Review - Packages
Using packages to organize code
Using import
Creating Packages
Package Organization and Classpath
Using Packages to Organize Code
Session 5: Composition and Inheritance
Using Composition to Deal With Complexity
Composition/HAS-A, Delegation
Using Inheritance and Polymorphism to share commonality
IS-A, extends, Inheriting Features, Overriding Methods, Using Polymorphism
Class Object
Abstract Classes
(Optional) Working with Composition
Using Inheritance to Specialize Classes
Session 6: Interfaces
Programming by Contract
Using Interfaces to Define Types
Interfaces and Polymorphism
Using Interfaces to Remove Implementation Dependencies
Session 7: Exceptions and Error Handling
Exception Hierarchy
try and catch
Handling Exceptions
Program Flow with Exceptions
Handle Exceptions
Define Exception Class
Session 8: Collections and Generics
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
More About Generics (Inheritance, Wildcards, Assignment)
Using Collections
Session 9: JDBC and the JPA
JDBC Overview and Architecture
JDBC Connections, Statements, and Queries
Introduction to JPA (Java Persistence API)
Object-Relational Mapping (ORM) and JPA Architecture
Entity Class Introduction
Mapping Entity classes with @Entity, @Id, @Table, and more
Persistence Units, persistence.xml, the EntityManager and EntityManagerFactory
Using JPA to Work with Persistence Entities
JPQL and Querying with JPA
Mapping a Simple Class
Using JPA to Access Persistent Entities
Inserting, Querying, and Other Capabilities
Session 10: Additional Java Features
Type-safe Enums
Session 11: I/O Streams
Readers and Writers
Filter Streams
InputStreams and OutputStreams
Converting Between Streams and Readers/Writers
New I/O (NIO) APIs
Formatting with Java I/O
Session 12: Inner Classes
Why Use Inner Classes?
Named Inner Classes
Static Inner Classes
Anonymous Inner Classes
Using Named Inner Classes
Using Anonymous Inner Classes
Session 13: Reflection
The class called Class
Finding Fields, Methods, and Constructors
Accessing Fields, Invoking Methods
Examining Arrays
Examining Objects Using Reflection
Accessing Fields and Invoking Methods via Reflection
Session 14: Introduction to ant
ant Overview, Installing and Running ant
Buildfiles, Projects, Targets, Tasks, Properties
Creating Build Files
Resource Collections - FileSets, DirSets, Files, PatternSets
Running ant
Creating and Using Buildfiles
Using Basic ant Tasks
Session 15: maven Overview
Introduction and Installation
Maven Concepts and the POM (pom.xml>
Dependencies and Repositories
Using maven to build Java projects
Using maven
Session 16: JUnit Basics
JUnit Overview, Test Driven Development
Tests and Assertions
Working With Exceptions
Writing and Running Tests
Testing Exceptions
Session 17: Organizing Tests with JUnit
Writing Fixtures - @Before, @After
Test Suites, and Other Capabilities
Mock Objects
Using Fixtures
Using Suites
Session 18: Introduction to Logging and log4j
Logging Overview
log4j Overview
Loggers, Appenders, Layouts
Configuring and Using log4j
Logger Hierarchy and Logging Levels
Working With Appenders
Using PatternLayout
Other Logging Frameworks (Java Logging, Apache Commons Logging)
Setting Up log4j
Using Basic log4j Logging
Working With Loggers
Working With Appenders
Using Layouts

Course Directory [training on all levels]

Upcoming Classes
Gain insight and ideas from students with different perspectives and experiences.

Interesting Reads Take a class with us and receive a book of your choosing for 50% off MSRP.