Java Programming Fundamentals using IBM Rational Application Developer 7.5 Tooling Training

How To Take This Class

Live Instructor-Led Online Class

Cost: $2,250.00

  • Open enrollment class for individuals
  • Live class with an instructor
  • Free class retakes forever!
  • Six months of instructor email support
  • Hands-on exercises and student labs
  • Classes never cancelled due to low enrollment
  • Money-back guarantee

    Sorry, no courses are scheduled at this time. Please Contact Us to schedule this course.

Onsite or Offsite Group Training

Cost: Based on number of students

  • For groups as small as 3 people
  • Class Held at our location or yours
  • Hands-on exercises and student labs
  • Customization at no extra charge
  • Six months of instructor email support
  • All-inclusive pricing
  • Money-back guarantee
Request Group Pricing Proposal

Course Duration

5 Days

Course Description

Java Programming Fundamentals using IBM Rational Application Developer 7.5 Tooling is a five-day, comprehensive hands-on Java training course geared for developers who have little or no prior working knowledge of object-oriented programming languages (such as those working on (C, COBOL, 4GL, etc.) Throughout the course students learn the best practices for writing great object-oriented programs in Java 6, using sound development techniques, new improved features for better performance, and new capabilities for addressing rapid application development. Special emphasis is placed on working with RAD 7.5 and its Java tooling. In addition to the normal exercises that are liberally sprinkled throughout the course, there is a case study that covers the entire spectrum from use cases to object-oriented design to implemented classes. This case study supplements the course and can be used during and after the course as a reference and a tool for reviewing and practicing what was learned in class.

Course Objectives

Upon successful completion of this course, students will be able to:
  • Understand and use RAD
  • Understand and use the RAD Workbench, Perspectives, Views and Editors
  • Understand Source Code Management with RAD
  • Best practices for project builds and deployment with RAD
  • Understand RAD strengths and weaknesses
  • Debug Java programs in RAD
  • Profile Java programs in RAD
  • Understand not only the fundamentals of the Java language, but also it’s importance, uses, strengths and weaknesses
  • Understand the basics of the Java language and how it relates to OO programming and the Object Model
  • Learn to use Java logging features
  • Understand and use classes, inheritance, polymorphism
  • Understand the use of packages to organize code
  • Understand interfaces, their importance, and their uses
  • Learn good Java coding style
  • Create well structured Java programs
  • Use the core Java libraries (java.lang, java.util packages)
  • Understand exceptions and use them for error handling
  • Understand and use collections, generics, autoboxing, and enumerations including new Java 6 features and capabilities
  • Understand the basics of using JDBC (Java Database Connectivity) to access databases from Java

Course Audience

This is a beginner level Java course, designed for experienced developers who wish to get up and running with Java, or who need to reinforce sound Java coding practices, immediately.

Course Prerequisites

Attendees should have a working knowledge of developing software applications.

Course Syllabus

  1. RAD Overview
    • IBM® WebSphere® Studio Workbench
    • WebSphere Studio Family of Products
    • The RAD Product & purpose
    Lesson A Hands-On First Look
    • The WebSphere Studio Paradigm
    • J2EE Navigator View
    • Editors
    • Getting Started
    • Handy Editor Features
  2. Using the JDK
    • Setting Up Environment
    • The Development Process
    • Locating Class Files
    • Compiling Package Classes
    • Source and Class Files
    • Applications and Applets
  3. Writing a Simple Class
    • Classes in Java
    • What Is a Class?
    • Defining the Class
    • Class Modifiers
    • Class Instance Fields
    • Instance Fields Diagram
    • Primitives vs. Object References
    • Creating Objects
    • The main Method
    • Using the Dot Operator
    • Writing Output
  4. The Java Platform
    • Defining Java
    • Java Provides Several Platforms
    • Note on Terminology
    • Java SE 6
    • Java SE Development Kit (JDK)
    • Executing Programs
    • Lifecycle of a Java Program
    • Responsibilities of JVM
    • Java is Dynamic: The Runtime Process
    • Primary Areas of the JVM Runtime
    • Garbage Collection
    • Documentation and Code Reuse
    • JavaDoc Provides Documentation Delivery
    • In-Line Comments are Translated into HTML Rendering
    • Working with Java in Your Environment
  5. Object-Oriented Programming
    • The Object Oriented Way
    • Real-World Objects
    • Classes and Objects
    • Examples of Classes and Objects
    • Classes and Objects Diagram
    • Object Behavior
    • Methods and Messages
  6. Inheritance, Abstraction, and Polymorphism
    • Encapsulation
    • Inheritance
    • Method Overriding
    • Aggregation
    • Type Abstraction – Grouping as Supertype
    • Polymorphism
    • Polymorphism Diagram
  7. RAD Paradigm: Editors, Views, and Perspectives
    • Basic Workbench Concepts
    • Views
    • J2EE Navigator View
    • Outline View
    • Property View
    • Tasks View
    • Bookmarks View
    • Editors
    • Perspectives
    • Customizing Perspectives
  8. Java Development with RAD
    • The Java Development Tooling (JDT)
    • Java Perspectives
    • Java Projects
    • Project Structure on File System
    • Project Viewing Options
    • Best Practices Working with Projects
    • Importing Project Artifacts
    • Exporting Projects
    • Java Editor
    • Formatting
    • Code Assist
    • Source Code Tools
    • Java Views
    • Outline
    • Type Hierarchy
    • Preferences
    • Compiler
    • Code Generation
    • Configuring New Projects
    • Templates
    • Creating a Project, Folders and Files
    • Build Paths
    • Right Click Options
    • Working with Multiple JDKs
    • Using Scrapbooks
    • Searching
    • Help
    • Working with External JavaDocs
    • Keyboard Shortcuts
    • Sharing Projects
    • Sharing Configurations
  9. Configuring the RAD Environment
    • Modifying Editor Preferences
    • Customizing Perspectives
    • Creating New Perspectives
    • Changing the Default Perspective
  10. Adding Methods to the Class
    • Instance Methods
    • Passing Parameters Into Methods
    • Returning a Value From a Method
    • Overloaded Methods
    • Overloaded Methods Diagram
    • Constructors
    • Defining a Constructor
    • Optimizing Constructor Usage
  11. Language Statements
    • Operators
    • Comparison and Logical Operators
    • Looping: The for Statement
    • Looping: The while Statement
    • Looping: The do Statement
    • Continue and Break Statements
    • The switch Statement
  12. Using Strings
    • Strings
    • String Method
    • String Equality
    • StringBuffer
    • Strings, StringBuffer, and StringBuilder
    • StringTokenizer
    • Scanner
    • Scanner - File Source
    • Scanner - Getting Input
    • Scanner - Testing for Tokens
    • Scanner - Patterns for Tokens
    • Formatter
    • Formatter – Probable First Encounters
    • Formatter – StringBuffer
  13. Specializing in a Subclass
    • Extending a Class
    • The extends Keyword
    • Casting
    • Overriding Superclass Methods
    • Method Overriding Diagram
    • Calling Superclass Methods from Subclass
    • The Object Class
    • The equals Method
    • Default Constructor
    • Implicit Constructor Chaining
    • Passing Data Up Constructor Chain
    • A Common Programming Mistake
    • Editing Tools in Your IDE
  14. Fields and Variables
    • Fields vs. Variables
    • Data Types
    • Default Values
    • Block Scoping Rules
    • Using this
    • Final and Static Fields
    • Static Variable Diagram
  15. Using Arrays
    • Arrays
    • Accessing the Array
    • Multidimensional Arrays
  16. Static Methods and Fields
    • Static Fields
    • Simple Example of Static Fields
    • Static Methods
  17. Java Packages
    • The Problem
    • Packages
    • Class Location of Packages
    • The Package Keyword
    • Importing Classes
    • Executing Programs
    • Visibility
    • Java Naming Conventions
    • Packages Diagram
    • Refactoring in Your IDE
  18. Inheritance and Polymorphism
    • Polymorphism
    • Polymorphism: The Subclasses
    • Treating Derived Classes as the Superclass
    • Casting to the Derived Class
    • Using instanceof For Downcasting
    • Upcasting vs. Downcasting
    • Calling Superclass Methods From Subclass
    • The final Keyword
  19. Interfaces and Abstract Classes
    • Separating Capability from Implementation
    • Abstract Classes
    • Shape as an Abstract Class
    • Polymorphism With Abstract Classes
    • Interfaces
    • Implementing an Interface
    • Extending Interfaces
    • Polymorphism With Interfaces
    • Type Checking
    • Abstract Classes vs. Interfaces
    • Interfaces Diagram
  20. Exceptions
    • What is an Exception?
    • Exception Architecture
    • Handling Exceptions
    • The Throwable Class
    • The try Block
    • The catch Block
    • The finally Block
    • Full Example of Exception Handling
    • Generalized vs. Specialized Exceptions
    • Overriding Methods
    • Creating Your Own Exceptions
    • Throwing Exceptions
    • Re-throwing an Exception
    • Checked vs. Unchecked Exceptions
    • Debugging in Your IDE
  21. Utility Classes
    • Wrapper Classes
    • The Number Class
    • Numbers and Strings
    • Big Decimal
    • Random Numbers
    • Decimal Formatting
    • The Date Class
  22. Vector and Hashtable
    • The Vector Class
    • Creating and Using a Vector
    • Java Collections Methods in Vector
    • Hashtables
    • Understanding How Hashing Works
    • Creating and Using a Hashtable
    • Performing Lookups
  23. Collections
    • The Collections Framework
    • Collections Feature Types
    • Collections Interface Hierarchy
    • Map Interfaces
    • Optional Methods
    • The Collection Interface
    • Iterators
    • The Set Interface
    • SortedSet
    • Set and SortedSet Example
    • Comparable and Comparator
    • The List Interface
    • List Example
    • ListIterator
    • Queue Interface
    • QueueExample
    • BlockingQueue
    • BlockingQueue Implementations
    • Collections Utility Methods
    • Features of the Implementation Classes
    • Synchronization Wrappers
    • Feature Comparison
    • Using the Right Collection
    • Use of Collections vs. Vector/Hashtable
    • Optimizing Collection Constructors
    • Copying Arrays
    • Creating and Using an ArrayList
    • Creating and Using a HashMap
  24. Generics
    • Generics and Parametric Polymorphism
    • Simple Generics
    • The Mechanics of Generics
    • Generics and Subtyping
    • Compiler Restrictions on Generics and Subtyping
    • Generics as Arguments in Methods
    • Rationale Behind Wildcards
    • Wildcards In Use
    • Regular Wildcards in Method Parameters
    • Bounded Wildcards
    • Standard Rules Apply
    • Generic Methods
    • Interoperability with Legacy Code
    • Raw Types
    • Legacy Calls To Generics
    • When Generics Should Be Used
    • Build Paths in Your IDE
  25. Overview of Java GUIs
    • JFC – Java Foundation Classes
    • Categories of Classes in JFC
    • Creating the Frame
    • Adding Content to a Frame
    • A Closer Look at Layout Managers
    • BorderLayout
    • JFC Provides an Event Handling Structure
  26. JDBC
    • What is JDBC?
    • Structured Query Language (SQL)
    • Connecting to the Database
    • Statements
    • Statement and PreparedStatement
    • ResultSet
    • JDBC Diagram
    • Executing Inserts, Updates, and Deletes
    • Controlling Transactions and Concurrency
    • Mapping SQL Types to Java Types
    • Database Connection Via JDBC Calls
    • Rationale for Connection Pooling
    • Connection Pooling in JDBC
    • Database Connection Using a DataSource
    • Stored Procedures Defined
    • Callable Statement Syntax
    • Stored Procedure Parameters
    • RowSet Implementations
    • JDBCRowSet
    • JDBCRowSet Approach
    • JDBCRowSet – Retrieving Data
    • JDBCRowSet Example
    • CachedRowSet
    • CachedRowSet Approach
    • CachedRowSet Example
  27. Java Logging
    • Why Logging?
    • Logging Framework
    • Logging in Java
    • Java Logging Framework
    • The Logger Class
    • Global Configuration
    • Logging Levels
    • Programmatically Setting Logging Properties
    • Programmatic Handlers
    • Formatters
    • Logging Security & Performance