Course description: Introduction to Java using IBM Rational Application Developer V6

Developers who are new to the Java programming language can learn the principles of Object Oriented (OO) development, the Java  (Java 2 Platform, Standard Edition (J2SE) 1.4) syntax, object creation, and key classes and their use. In the hands-on exercises that complement the lectures and are provided throughout the course, use IBM Rational Application Developer for WebSphere Software V6 as a guide to exploring the Java language.

Learn the basic concepts, syntax, and Application Programming Interfaces (API) used in developing OO Java applications, and learn how to create, debug, and run Java applications in IBM Rational Application Developer for WebSphere Software V6.

This course is an entry point into the curriculum for developers who have experience with a programming language other than Java. No knowledge of Java or IBM Rational Application Developer for WebSphere Software V6 is required, but some programming experience and some familiarity with OO programming is helpful.

This course is taught using Rational Application Developer in the Interactive Development Environment (IDE). If you are interested in using Eclipse as your interactive development tool, as alternatives, see:

• Introduction to OO Java Development for Procedural Developers Using Eclipse (JA321)
• Developing and Testing OO Applications with Java Using Eclipse (JA341)  

It should be noted that Eclipse is the basis for IBM Rational Application Developer for WebSphere Software. Java development skills learned with Eclipse are directly applicable to the more full function Rational tool.

Course Materials

This course is intended for developers who are new to the Java programming language, it will use IBM Rational Application Developer for WebSphere Software V6 as the Interactive Development Environment.

Hands-On Labs

Eleven labs are included to address the basic Java development skills.

View this course in other countries

Training Paths that reference this course are:

• Application Developer Skills for Java

Back to top

IBM Education Advantage Program eligibility:

• Yes - IBM Education Pack - online account

Back to top

This is a basic course for individuals who have experience programming in other languages and who need to develop OO Java applications using IBM Rational Application Developer for WebSphere Software V6.

Back to top

You should have some experience in structured programming and should have some knowledge of OO concepts. Experience using relational databases is also an asset.

What's Next

Move beyond the basics of developing a Java application into the following areas: Java and distributed objects, Java security, integrating Java with databases and messaging systems, performance, and testing. Take the courses recommended in the Training Path (see above).

Back to top

• Use Java syntax to develop simple applications in Java
• Describe the Java object model and its implementation
• Outline some of the important classes and interfaces available in Java, and be able to use them, including:
• Primitive wrapper classes
• Classes in the collections framework
• Utility classes
• Input/Output (I/O) classes
• Threads
• Exceptions
• Develop simple Java bean software components
• Use JDBC to access and manipulate data in a relational database, and know how to code for a DataSource using Java Naming and Directory Interface (JNDI)
• Use IBM Rational Application Developer to develop and debug Java programs

Back to top

Course introduction

This unit introduces the topics presented in this course and presents the course agenda. It also provides an opportunity for students to become acquainted with each other and with the instructor.

• Introduce a synopsis of the course material
• Review the entry level skills needed to effectively understand the course material
• Become acquainted with the students and instructor in the class

Introduction to the Java programming language

This unit introduces students to various aspects and benefits of the Java platform and describes how Java code may be used to build many types of applications and components.

• Describe the history and properties of the Java programming language
• Explain the Java execution model, including the use of bytecode and the Java virtual machine
• Outline the types of programs and components that can be built using Java

Introduction to IBM Rational Application Developer

This unit introduces the workbench of IBM Rational Application Developer and discusses the various features available through the perspectives, views, and menus of Application Developer.

• Explain the use of a workspace
• Identify the parts of the workbench
• Navigate the workbench
• Work with perspectives, views, and editors
• Create resources using wizards
• Understand what help systems are available in the workbench

OO programming

This unit introduces the concept of OO programming, including the principles of OO development. It also introduces the use of Universal Markup Language (UML) in relation to OO development, and introduces some simple UML notation used throughout the course.

• Define OO programming and contrast it with procedural programming
• Define the terms class and object
• Explain how objects communicate
• Define UML and explain how UML is used in OO programming
• Describe the support for UML in Application Developer
• Outline several OO design principles

Java syntax basics, part 1

This unit introduces the basic Java syntax for simple programming constructs, such as identifiers, primitives, operators, arrays, statements, and comments. Reserved words are identified, as is operator precedence.

• Outline naming conventions used by Java programs
• Construct a valid identifier
• Describe the Java primitive data types, and explain how and why each one is used
• Declare and initialize Java variables and arrays
• Identify reserved words

Java syntax basics, part 2

This unit introduces Java syntax for classes, objects, Strings, Stringbuffers, and conditional, looping, and branching statements. Variable scope is also discussed.

• Create and initialize objects
• Use the identity (==) operator
• Identify and use primitive wrapper classes
• Outline Java's implementation of Strings, and work with Strings
• Explain the difference between the String and StringBuffer classes
• Use conditional statements
• Use looping and branching structures
• Explain variable scope

Building classes

This unit introduces the Java syntax for classes, and shows how classes may be declared, constructed and used. Class modifiers are discussed, and memory management and garbage collection are explained.

• Declare a Java class
• Define constructors
• Create methods and fields, and set the appropriate modifier
• Explain how memory is managed in Java
• Outline the role of packages in Java

Debug applications

This unit introduces the Application Developer debugging capabilities. Learn to step through code, add and configure breakpoints, and view and modify variable values during debugging.

• Use the Debug perspective to debug Java applications
• Step through code using the Debug view toolbar
• Add and configure breakpoints in a Java application
• View and change variables during debugging
• Execute and inspect expressions during debugging

Inheritance

This unit introduces the concept and implementation of inheritance in Java. Related concepts such as overriding methods, default constructors, and polymorphism are also discussed.

• Describe the inheritance of fields and methods
• Explain the concept of a class hierarchy
• Outline how subclasses specialize superclasses
• Explain how method lookup works
• Create and use subclasses
• Describe how polymorphism is implemented

Design patterns and refactoring

This unit explains design patterns, and their role in refactoring. Refactoring is also explained, and Application Developer's support for refactoring is outlined.

• Explain what design patterns are and how they are used
• Outline the different types of design patterns and list the key elements of a design pattern
• Describe what refactoring is and why it is needed
• Outline when refactoring is performed in the development cycle
• List various strategies and techniques of refactoring
• Use Application Developer to refactor Java classes and elements

Interfaces

This unit introduces the concept of interfaces, and discusses their use, benefits, naming conventions, and implementation.:

• Explain the concept of interfaces
• Declare an interface in Java
• Declare that a class implements one or more interfaces
• Explain what a class implementing an interface must supply

Collections

This unit introduces the Java Collections Framework, and the concepts and implementation of collections in Java.

• Describe the basic concept of collections and what they represent in Java
• Identify the collection interfaces provided by Java:
• - interfaces
• - abstract types
• - concrete implementations
• List the concrete implementations of the collections and choose between various concrete implementations of collections

Threads and synchronization

This unit introduces the concept of Java threads and its implementation through the Thread class and the runnable interface. Synchronization and its implementation are also discussed.:

• Understand the difference between processes and threads
• Outline how threads are handled and implemented in Java
• Subclass the Thread class to create a new thread
• Implement the runnable interface to create a new thread
• Describe the life cycle of a thread and how its activities may be controlled
• Describe the role of daemon threads and the Java Virtual Machine (JVM) treatment of these
• Explain the notion of synchronization

Utility classes

This unit introduces the major utility classes in Java, including those found in the java.lang and java.util packages. Classes discussed include those providing conversion functions, the Math class, the System class, and the Matcher and Pattern classes. Regular expression support is discussed, as provided in the String class and in the combined use of the Matcher and Pattern classes.:

• Use the methods in the primitive wrapper classes to convert between types
• Use the math functions provided by the Math class
• Use the System and Class classes to get properties and class information
• Use the String, Pattern, and Matcher classes to drive pattern matching using regular expressions

Exceptions and exception handling

This unit describes Java facilities for raising and handling errors and other conditions that disrupt execution flow.

• Explain what a Java exception is and explain the Java exception hierarchy
• Describe the conditions that act as the source of exceptions
• Use try/catch/finally blocks to properly handle exceptional events
• Use the throw keyword to throw a predefined Throwable object or your own Exception subtype
• Describe and use assertions

I/O and serialization

This unit describes the classes, methods and techniques used in Java to perform various I/O operations, particularly the serialization of data.

• Describe the concept of streams and describe the major functions of stream-based I/O in Java
• Outline the differences between stream-based I/O and new I/O
• Explain the role of channels and buffers in new I/O
• Explain the concepts of serialization and externalization
• Write code that serializes and deserializes objects

JavaBeans

This unit describes how Java bean software components are created using the JavaBeans API.

• Explain what a Java bean is and outline the three feature sets they expose
• Describe what is provided by the JavaBeans API
• Explain several key concepts and terms associated with beans
• Describe the types of properties a bean may export, and outline what methods of a bean are exported
• Explain what an event source and event listener are
• Describe how bean information can be obtained through introspection and the BeanInfo class

JDBC Overview

This module introduces JDBC, the Java API for relational database access. JDBC concepts and implementation are explained, and examples of statement execution are provided.

• Describe how Java applications access relational databases
• Explain the JDBC architecture
• Execute a JDBC query
• Access data returned from a query in a ResultSet
• List the Java types that SQL types map to
• Use PreparedStatements and CallableStatements to create efficient queries

JNDI

This unit introduces naming and directory services, and the JNDI, which allows Java programs to access these services. An example showing how JNDI is used to access a naming service is provided.

• Explain the benefits and use of naming and directory services
• Define JNDI and explain what it is used for
• Use JNDI to access a naming service and look up a resource

DataSources

This module introduces the idea of naming and directory services and connection pooling.  The implementation of these, JNDI and DataSources, is discussed and coding examples are provided.

• Explain the rationale for connection pooling
• Describe what a connection pool provides
• Describe DataSources as the implementation of connection pooling
• Outline the benefits of using DataSources to connect to a database
• Write code to access a DataSource using JNDI

Wrap-up

This unit concludes the course and provides an outline of resources that may be appropriate for those wishing to study course topics in more detail.

• Give an overview of the topics covered by this course
• List Web sites and books that provide more information on the topics discussed in this course

Back to top

• Instructor Guide
• Instructor Lab Guide
• Student Guide
• Student Lab Guide
• Lab Setup Guide

Back to top

• Edit your profile

Easy ways to get the answers you need.

• Online text chat

or call us at
Call 1-800-426-8322

Open M-F 9AM-7PM ET.

• My enrollments

• My training plan

• How to get to class

• Subscribe to IBM Training RSS feeds

• Training paths will help you decide

• Subscribe to IBM Training News

• IBM Training Flyer (98KB)

• Certification flyer (355KB)

• Training special offers

• IBM Education Pack

  Save on training

• Get Adobe® Reader®