Introduction to Java using IBM Rational Application Developer V6

M/UX
Boston, Chicago, United States

Course Format: Classroom | E-learning | Virtual Class | Online | On-site | Blended | Self-paced

Course Description:

'' 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.


Skills Taught

--------------------------------------------------------------------------------

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


Course outline

--------------------------------------------------------------------------------

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 disc ...''

Phone:866-700-9811

School Address:

pSeries/AIX, CISCO, Linux, Microsoft, Professional Skills, Project Management, RedHat LINUX Enrollments 866-700-9811 (Toll Free) or 916-226-2537

CICS, iSeries/OS400, Enterprise/zSeries and WebSphere Enrollments 888-689-3326 (Toll Free) or 916-226-2511

DB2 UDB, Rational Software, and Tivoli Enrollments 866-700-9817 (Toll Free) or 916-226-2533

M/UX
9245 Laguna Springs Drive
Suite 315
Elk Grove, CA 95758 USA


Jobs & Resumes: Boston, Chicago
Houses & Roommates: Boston, Chicago

IBM Tivoli Directory Server 5.2 System Administration
IBM Tivoli Identity Manager 4.5 System Administration
IBM TotalStorage Productivity Center 3.1
IBM Tivoli Monitoring 6.1 for Administrators
IBM Tivoli Access Manager for e-business 6.0 Deployment and Administration
IBM Tivoli Workload Scheduler 8.3 Administration
Developing and Testing OO Applications with Java
Introduction to Java SE 5 Using Eclipse
From J2EE Applications to Business Processes: IBM WebSphere V6 Administration
IBM WebSphere Application Server V6.1 Administration on Windows
IBM WebSphere Application Server V6.1 Administration on AIX
IBM WebSphere Application Server V6.1 Administration on Linux
Programming XML and Related Technologies with Java 1.4
Web Services Development for WebSphere Application Server V6.1 with IBM RAD V7
Servlet and JSP Development with Rational Application Developer V6.0
Developing EJBs with IBM Rational Application Developer V6.0

Notice: The course description on this page was captured from the Internet as historical reference or submitted by visitors. It was archived statically and not updated from day to day.
 

Facts: This website holds more than 300,000 training course records worldwide, with hundreds of new postings daily. All services in this website are free!