Introduction to Java Using RAD v7
Revision: TE1110_20071205
- Course Length:
- 5 Days
- Course Description:
- Students learn Java programming and how to develop Java applications using RAD V7. They learn the Java programming syntax, OO programming using Java, exception handling, file input/output, and servlets and JSPs. Students will develop and test Java applications using RAD V7.
- Who Should Attend:
- This course is intended for programmers who are interested in adding Java to their skills.
- Benefits of Attendance:
-
Upon completion of this course, students will be able to:
- Apply OOP principles.
- Design OO applications using abstraction, encapsulation, modularity and hierarchy.
- Use Java exceptions to guarantee graceful error recovery for your application.
- Create and use inner classes in programs.
- Perform input/output using Java.
- Create servlets and JavaServer Pages.
- Use RAD for Java application development.
- Prerequisites:
- Students must be familiar with object-oriented principals and the concept of object-oriented programming.
- Course Outline:
-
- The Agenda
- Using RAD
- Java Basics
- Branching and Looping
- Arrays and Objects
- Advanced Class Concepts
- Exceptions
- Stream I/O
- Servlets
- Java Server Pages
- EJB Programming Overview
- JDK 1.4 Features
- Introduction
- History and Goals of Java
- Java Virtual Machine
- Garbage Collection
- Overview and Migration
- The WebSphere Family
- Eclipse Platform
- The WebSphere Studio Product Family
- Rational Web Developer
- Rational Application Developer
- Key Features in RAD v7
- WebSphere Studio Application Developer Integration Edition
- WebSphere Studio Enterprise Developer
- Views, Perspective and Editor Areas
- Basic Operations with RAD Views and Perspectives
- The Java Perspective
- The Debug Perspective
- Navigator View
- Package Explorer
- Outline View
- Task and Problems View
- Build and Validation
- Import and Export Project
- Templates and Code Completion
- Searching
- Setup Compiler Class Path
- JRE Switching
- Refactoring
- Changing Class, Method, and Variable Name
- Moving a Class to a Different Package
- Extracting Code to a Method
- Pull-up Method
- Migrating Workspace from WSAD v5.x
- Project Interchange Feature
- Migrating J2EE Applications
- J2EE Migration Wizard
- Java Basics
- Comments and Blocks
- Semicolons and White Spaces
- Identifiers and Keywords
- Primitive Data Types
- Logical - boolean
- Textual – char and String
- Integral – byte, short, int, long
- Floating Point - float and double
- Understanding Objects
- Creating a New Type
- Declaring a Variable
- Creating an Object
- JVM Storage Areas
- Scope of a Variable
- Arithmetic Operators
- Using Arithmetic Operators
- Assignment Operators
- Logical Expressions
- Short-Circuit Logical Operators
- String Concatenation with +
- Bitwise Operators
- Ternary Operator
- Casting
- Branching and Looping
- Conditions
- The if Statement
- The if .. else Statement
- Logical Operators and the if..else Statement
- The switch and while Statements
- The do…while Statement
- The for loop
- Break and Continue
- Objects
- OO Programming
- Creating a Data Type
- Class Members
- Methods
- Pass-by-Value
- The this keyword
- Data Hiding
- Encapsulation
- Overloading
- Constructing and Initializing Objects
- Constructors
- Invoking an Overloaded Constructor
- Default Constructor
- Inheritance
- Constructors Are Not Inherited
- Polymorphism
- Conditions for Polymorphism
- The super Keyword
- The instanceof Operator
- Casting Objects
- Overriding
- Invoking Parent Class Constructors
- Arrays
- Arrays
- Declaring, Creating, and Accessing Arrays
- Initializing Array
- Multidimensional Arrays
- Copying Arrays
- Advanced Class Concepts
- Static Class Variables
- Class vs. Instance Variables
- Static Class Methods
- Static Initializers
- The final Keyword
- Abstract Classes
- Interface
- Access Modifiers
- Using == vs. equals()
- The toString() method
- Inner/Nested Classes
- Kinds of Inner Classes
- The Vector Class
- Exceptions
- What is an Exception?
- Benefits
- How to Work With Exception
- The try-catch-finally Statement
- Flow of Program Control
- Checked Exceptions
- Unchecked Exceptions
- Catching Multiple Exceptions
- Rethrowing Exceptions
- Exception Thrown by a Method
- The Exception Class
- Creating Exceptions
- Stream I/O
- File I/O
- The File Class
- Input Stream and Methods
- Output Stream and Methods
- DataInputStream & DataOutputStream
- FileInputStream & FileOutputStream
- FileInputStream Methods
- FileOutputStream
- FileOutputStream/DataOutputStream
- FileInputStream/DataInputStream
- Reader and Writer
- Why use Reader and Writer ?
- Servlet Basics
- History – CGI
- Server Extension APIs
- Java Servlet
- Servlet Container
- Servlet Responsibilities
- J2EE and Servlet
- The Servlet Class
- The Servlet Container
- The Servlet API
- Life Cycle – Initialization, Processing and Destroy
- User Input
- Output to Client
- Servlet Error Handling
- Threading Issues
- Create a Servlet
- Code Servlet Methods
- The Web Deployment Descriptor
- Test the Servlet
- Debug Servlets in the RAD’s WebSphere Test Environment
- JSP Basics
- JavaServer Pages
- JSP Benefits
- Evolution of Dynamic Content Technologies
- How JSP Works
- JSP Invocation
- Create, Edit, and Test a JSP with RAD
- Debugging a JSP with RAD
- JSP Scripting Elements
- Directives
- XML Vs. Non-XML Syntax
- Creating a JSP in RAD(XML Syntax)
- Creating a JSP in RAD
- Adding code to JSP
- Viewing the output
- page Directive Attributes
- page Attribute – errorPage
- page Attribute – isErrorPage
- Directives – include
- Include at compile time vs. at request time
- Request time inclusion
- Forwarding Requests
- JSP Declarations, Expressions, and Scriptlets
- JSP Comments
- JSP Implicit Objects
- The request, response, and out Objects
- EJB Overview
- Needs for EJB
- Distributed Computing, Transaction, and Security
- Main Characteristics of EJBs
- EJB Remote Method Call
- EJB Architecture Components
- EJB Client, JAR File, and Server
- EJB Container - Persistence and Transaction
- Enterprise Java Beans
- Session and Entity Beans
- Message-Driven Beans
- EJB Classes and Interfaces
- Basic Components of Entity and Session Beans
- EJB Home Interface
- EJBHome Object
- EJB Remote Interface
- EJB Local Home Interface
- EJB Local Interface
- Remote EJB Objects
- Local EJB Objects
- EJB Implementation Class
- EJB Container - Relationships
- Remote v. Local EJBs
- EJB Application Development
- Deploying Enterprise Beans
- Major Components of Deployed EJBs
- JDK 1.4 Features
- JDK 1.4 and WebSphere v5.1.x
- Migrating Specific Projects to Use JDK 1.4
- Globally Migrating to JDK 1.4
- JDK 1.4 – New Features
- Control Flow of Logging
- Loggers
- Logging API - Handlers
- Logging API – Formatters & Log Manager
- JDK 1.4 - JAXP
- JDK 1.4 - Assertions
- When to use Assertions
- Enabling Assertions
- The Agenda













