TrainingPage

Please Note: This class is subject to a ten percent increase. Please contact a TrainingPage representative for verification of price increase.

Description:

Are you already familiar with the basics of the Java language? Are you interested in moving toward certification in Java?

Move beyond the fundamental skills of Java syntax and logic flow into concepts:

  • Design flexible and maintainable applications with interfaces
  • Create Graphical User Interfaces (GUI) for stand-alone applications and applets using Swing
  • Learn to manipulate and manage data using Java's Collection Application Programming Interface (API)
  • Create threads of execution for multithreaded applications
  • Create simple distributed object systems through Java's Networking API and Java Remote Method Invocation (RMI)

In the hands-on labs, follow a case study to create a simple online exam delivery system using an IBM tool to assist you in your coding. By writing code you gain the skills you need to develop code for real-world applications. Write, compile and run Java applications.

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.

This course uses the open source Eclipse Development Platform as the Interactive Development Environment (IDE) for hands-on labs. If you wish to use WebSphere Studio V5.1 for the IDE, see:

  • Developing and Testing OO Applications with Java Using WebSphere Studio V5.1 (JA349)

If you wish to use IBM Rational Application Developer as the IDE, see the soon to be released course:

  • Introduction to Java using IBM Rational Application Developer V6 (JA351)

Note: Starting May 16, 2005, all publicly scheduled JA341 course offerings will make use of the open source Eclipse Platform for the IDE for the hands-on lab tasks. Any JA341 course offerings before that date will use WebSphere Studio Application Developer V5.1 as the IDE.

Course Materials

The course material moves beyond the fundamental skills of Java syntax and logic flow into concepts using the open source Eclipse Platform V3.0.1 as the IDE.

Hands-On Labs

Nine labs are included to address the skills transfer beyond the fundamental skills of Java syntax and logic flow into concepts using the open source Eclipse Platform V3.0.1 as the IDE.

Certification

Prepare for the Sun Certified Programmer for the Java 2 Platform examination.

IACET Continuing Education Units: 3.6

Audience:

This is a basic course for Information Technology (IT) architects, designers, and developers.

Objectives:

  • Describe Java Virtual Machine (JVM) memory allocation and garbage collection
  • Understand how to override the finalize() method
  • Write code to access system properties
  • Use arrays to store data
  • Create an abstract class and use inheritance to develop a class hierarchy
  • Override inherited methods
  • Implicitly utilize inherited methods and constructors
  • Utilize inherited methods and constructors through use of the keyword: super
  • Define and use interfaces
  • Use the final keyword to define constants
  • Use the Collection API to manage and store objects
  • Create and use data streams
  • Use the file class
  • Make an object persist through serialization
  • Define an custom exception
  • State the difference between run-time and checked exceptions
  • Architect methods so that exception handling takes advantage of throwing exceptions
  • Understand how to handle exceptions without disrupting your existing program logic
  • Create a basic graphical user interface
  • Describe Java's event-handling model
  • Create an anonymous inner class to refine event handling
  • Augment an existing graphical user interface to run in a Web browser as an applet
  • Define a class that implements the runnable interface
  • Launch and control separate threads of execution
  • Describe and use the Networking API and RMI in Java
  • Access a server from a client application to retrieve information
  • Code RMI interfaces
  • Use the RMI compiler (rmic) and the rmiregistry
  • Use the RMI lookup facilities
  • Convert an application into a client/server application

Prerequisites:

You should complete:

  • Introduction to Developing OO Applications with Java for Procedural Developers (JA321) or
  • Java for the OO Programmer: An Introduction (JA311) or
  • Intro. to Devel. OO Appls. w/Java for Procedural Dev. (self-paced virtual class) (JA327)
  • or have equivalent skills and knowledge

You should be able to define basic Object-Oriented (OO) concepts and terminology and code a simple Java application with assistance.

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

Topics:

Java review

  • differentiate between stand-alone applications, applets, and servlets
  • describe the role of the JVM
  • describe Java development cycle
  • describe the components of a class in Java
  • describe encapsulation and class instantiation, and their benefits to Java programming
  • create an Instance
  • identify keywords, operators, and primitive data types
  • differentiate between implicit and explicit casting
  • use the String class
  • identify the block structure of Java
  • use conditional statements
  • use iteration statements
  • create and use arrays
  • use command line parameters
  • describe the purpose and value of wrapper classes

Java development environment

  • explain the purpose of the basic Java 2 Platform, Standard Edition (J2SE) Software Development Kit (SDK) tools
  • list the additional SDK tools
  • explain the basics of JVM memory allocation
  • describe the JVM garbage collection process
  • use the finalize() method correctly
  • use the System class to obtain platform information
  • use the Runtime class to issue operating system commands

Inheritance, interfaces, and abstract classes

  • apply the concept of inheritance
  • create a new class using inheritance
  • define a superclass and a subclass
  • use the keywords relevant to subclassing
  • use override methods
  • describe the principle of dynamic binding
  • use dynamic binding in applications

Manipulating objects using Java utility classes

  • describe the basic Java collection mechanisms
  • introduce the hierarchy of interfaces and classes for dealing with collections
  • describe the use of the appropriate concrete class, or interface for the task
  • introduce date management classes
  • introduce text management classes

Streams

  • define a stream
  • differentiate between byte streams and character streams
  • recognize the abstraction of byte streams through the InputStream and OutputStream classes
  • recognize the abstraction character streams through the Reader and Writer classes
  • nest streams using wrapper classes to enhance basic stream behavior
  • perform file Input/Output (I/O)
  • define object serialization
  • use serialization to save an object to a file, then deserialize that object
  • describe the use of the transient keyword

Exceptions

  • understand the throwable hierarchy
  • distinguish between errors and exceptions
  • distinguish between runtime and checked exceptions
  • use try/catch/finally constructs to handle exceptions
  • use throw and throws to pass propagate exceptions
  • create user-defined exceptions
  • use overriding with exceptions

User interfaces Abstract Window Toolkit (AWT) and Swing components

  • define AWT and Swing
  • identify the general organization of the AWT and Swing class structures
  • describe the Component class hierarchy
  • describe graphical widgets
  • define Java layout managers
  • describe the process of setting a container layout manager
  • effectively describe the layout managers used to achieve proper GUI layout
  • describe the concept of a containment hierarchy

Applets

  • compare and contrast applets and applications
  • describe the life cycle of an applet and its inherited methods
  • embed an applet into an Hypertext Markup Language (HTML) document
  • pass parameters from an HTML document to its contained applet
  • explain applet security restrictions
  • convert an applet into an application
  • convert an application into an applet

Security

  • explain the Java-related security concepts
  • describe the Java security model
  • introduce the concept of digital signatures
  • explain the use of digital certificates

Threads and synchronization

  • create and instantiate threads using two different techniques
  • control single-thread flow using many thread methods
  • describe the four thread states and their relationships to thread methods
  • define synchronization in relation to object monitors
  • explain the differences between synchronized methods and blocks
  • describe and control thread racing using thread synchronization
  • explain thread deadlock
  • describe the system event queue

Networking and RMI

  • use Socket APIs in java.net
  • use support for URL-named network resources
  • describe the RMI concept
  • use RMI methods
  • code the RMI interfaces
  • use the RMI lookup facilities
  • convert an application to a client/server application

View Dates & Enroll Online