All audiences for CDJ-110A, CDJ-275A, CDJ-310, CDJ-310A, CDJ-314A, CDJ-351A, CDJ-450, CDJ-455, CDJ-460

• CDJ-110A:
  
  • Create and edit text files using a text editor
  • Use a World Wide Web (WWW) browser
  • Solve logic problems
  • Describe the concept of a variable
  • Execute commands using a command-line interface

• CDJ-275A

• CDJ-110A:
  • Demonstrate knowledge of Java technology, the Java programming language, and the product life cycle
  • Use various Java programming language constructs to create several Java technology applications
  • Use decision and looping constructs and methods to dictate program flow
  • Implement intermediate Java technology programming and object-oriented (OO)concepts in Java technology programs
• CDJ-275A:
  • Create Java technology applications that leverage the object-oriented features of the Java language, such as encapsulation, inheritance, and polymorphism
  • Execute a Java technology application from the command line
  • Use Java technology data types and expressions
  • Use Java technology flow control constructs
  • Use arrays and other data collections
  • Implement error-handling techniques using exception handling
  • Create an event-driven graphical user interface (GUI) using Java technology GUI components: panels, buttons, labels, text fields, and text areas
  • Implement input/output (I/O) functionality to read from and write to data and text files
  • Create multithreaded programs
  • Create a simple Transmission Control Protocol/Internet Protocol (TCP/IP)networked client that communicates with a server through sockets
• CDJ-310:
  • List and describe several best practices of Object-Oriented Software Development
  • Describe the key features of the Java programming language
  • Understand why distributed computing is important and how the Java platform supports distributed systems
  • Compare the benefits of the J2EE and .NET platforms
  • List and describe the four main tiers of a J2EE architecture
  • Describe how web services are used in a distributed architecture
• CDJ-310A:
  • Describe the application model for the J2EE platform and the context for the model
  • Develop and test an EJB technology application
  • Develop a web-based user interface to an EJB technology application
  • Configure the J2EE platform services layer
• CDJ-314A:
  • Write Java servlets
  • Create robust web applications using Struts, session management, filters, anddatabase integration
  • Write JSP pages
  • Create easy to maintain JSP pages using the Expression Language, JSP Standard Tag Library (JSTL), and the Struts Tiles framework
  • Create robust web applications that integrate Struts and JSP pages
• CDJ-351A:
  • Implement business-tier functionality using EJB technology
  • Describe best practices and other advanced issues in business componentdevelopment with EJB technology
  • Assemble and deploy EJB technology business-tier components on an applicationserver
  • Integrate an EJB technology based application using Java Messaging Service API, the Java Connector Architecture and web services
• CDJ-450:
  • Describe the developments in wireless technologies
  • Recognize a successful wireless solution
  • Analyze the technologies involved in the wireless and device markets
  • Evaluate the impact of wireless technologies on business models and technologyenvironments
  • Devise and plan a wireless solution that delivers tangible business value
  • Describe the configurations, profiles and standard packages found in J2ME
  • Illustrate a J2ME wireless architecture
• CDJ-455:
  • Create GUI components using AWT
  • Write code to handle events that occur at the user interface
  • Create GUI-based applications and applets
  • Describe the developments in wireless technologies
  • Analyze the technologies involved in the wireless and device markets
  • Devise and plan a wireless solution that delivers tangible business value
  • Describe the configurations, profiles and standard packages found in the J2MEplatform
  • Illustrate a J2ME wireless architecture
  • Describe the differences between the Foundation, Personal Basis, and PersonalProfiles
  • Code and compile Personal Profile application
• CDJ-460:
  • Locate and download the J2ME Wireless Toolkit (WTK) 2.0
  • Use the WTK for developing MIDP 1.0 and 2.0 applications
  • Describe the new Mobile Media and Wireless Messaging APIs
  • Describe the new Game, Audio Building Block (ABB), and Enhanced User InterfaceAPIs
  • Integrate the WTK into an IDE
  • Provide an overview of Java Technology for the Wireless Industry (JTWI)architecture, required components, and benefits
  • Describe the relationship of the mandatory and conditional components withinJTWI, and list and describe their requirements
  • List and describe common JTWI best practices

Module 1 - Explaining Java Technology CDJ-110A

• Describe key concepts of the Java programming language
• List the three Java technology product groups
• Summarize each of the seven stages of the product life cycle

Module 2 - Analyzing a Problem and Designing a Solution

• Analyze a problem using object-oriented analysis
• Design classes from which objects will be created

Module 3 - Developing and Testing a Java Technology Program

• Identify the four components of a class in the Java programming language
• Use the main method in a test class to run a Java technology program from thecommand line
• Compile and execute a Java technology program

Module 4 - Declaring, Initializing, and Using Variables

• Identify the uses for variables and define the syntax for a variable
• List the eight Java programming language primitive data types
• Declare, initialize, and use variables and constants according to Java programming language guidelines and coding standards
• Modify variable values using operators
• Use promotion and type casting

Module 5 - Creating an Using Objects

• Declare, instantiate, and initialize object reference variables
• Compare how object reference variables are stored in relation to primitive variables
• Use a class (the String class) included in the Java Software Developers Kit (SDK)
• Use the Java 2 Platform, Standard Edition (J2EE) class library specification tolearn about other classes in this application programming interface (API)

Module 6 - Using Operators and Decision Constructs

• Identify relational and conditional operators
• Create if and if/else constructs
• Use the switch construct

Module 7 - Using Loop Constructs

• Create while loops
• Develop for loops
• Create do/while loops

Module 8 - Developing and Using Methods

• Describe the advantages of methods and define worker and calling methods
• Declare and invoke a method
• Compare object and static methods
• Use overloaded methods

Module 9 - Implementing Encapsulation and Constructors

• Use encapsulation to protect data
• Create constructors to initialize objects

Module 10 - Creating and Using Arrays

• Code one-dimensional arrays
• Set array values using the length attribute and a loop
• Pass arguments to the main method for use in a program
• Create two-dimensional arrays

Module 11 - Implementing Inheritance

• Define and test your use of inheritance
• Explain abstraction
• Explicitly identify class libraries used in your code

Module 1 - Getting Started CDJ-275A

• Describe the key features of Java technology
• Write, compile, and run a simple Java technology application
• Describe the function of the Java Virtual Machine (JVM)NOTE: The terms "JavaVirtual Machine" and "JVMA" mean a Virtual Machine for the Java platform
• Define garbage collection
• List the three tasks performed by the Java platform that handle code security

Module 2 - Object-Oriented Programming

• Discuss why you can reuse Java technology application code
• Define class, member, attribute, method, constructor, and package
• Use the access modifiers private and public as appropriate for the guidelines ofencapsulation
• Invoke a method on a particular object
• Use the Java technology application programming interface (API) online documentation

Module 3 - Identifiers, Keywords, and Types

• Use comments in a source program
• Distinguish between valid and invalid identifiers
• Recognize Java technology keywords
• List the eight primitive types
• Define literal values for numeric and textual types
• Define the terms primitive variable and reference variable
• Declare variables of class type
• Construct an object using new
• Describe default initialization
• Describe the significance of a reference variable
• State the consequence of assigning variables of class type

Module 4 - Expressions and Flow Control

• Distinguish between instance and local variables
• Describe how to initialize instance variables * Identify and correct a Possiblereference before assignment compiler error
• Recognize, describe, and use Java software operators
• Distinguish between legal and illegal assignments of primitive types
• Identify Boolean expressions and their requirements in control constructs
• Recognize assignment compatibility and required casts in fundamental types
• Use if, switch, for, while, and do constructions and the labeled forms of break and continue as flow control structures in a program

Module 5 - Arrays

• Declare and create arrays of primitive, class, or array types
• Explain why elements of an array are initialized
• Explain how to initialize the elements of an array
• Determine the number of elements in an array
• Create a multidimensional array
• Write code to copy array values from one array to another

Module 6 - Class Design

• Define inheritance, polymorphism, overloading, overriding, and virtual methodinvocation
• Use the access modifiers protected and the default (package-friendly)
• Describe the concepts of constructor and method overloading
• Describe the complete object construction and initialization operation

Module 7 - Advanced Class Features

• Create static variables, methods, and initializers
• Create final classes, methods, and variables
• Create and use enumerated types
• Use the static import statement
• Create abstract classes and methods
• Create and use an interface

Module 8 - Exceptions and Assertions

• Define exceptions
• Use try, catch, and finally statements
• Describe exception categories
• Identify common exceptions
• Develop programs to handle your own exceptions
• Use assertions
• Distinguish appropriate and inappropriate uses of assertions
• Enable assertions at runtime

Module 9 - Text-Based Applications

• Write a program that uses command-line arguments and system properties
• Write a program that reads from standard input
• Describe the C-type formatted input and output
• Write a program that can create, read, and write files
• Describe the basic hierarchy of collections in the Java 2 Software Development Kit (Java 2 SDK)
• Write a program to iterate over a collection
• Write a program that uses generic collections

Module 10 - Building Java GUIs

• Describe the Abstract Window Toolkit (AWT) package and its components
• Define the terms containers, components, and layout managers, and describe how theywork together to build a GUI
• Use layout managers
• Use the FlowLayout, BorderLayout, and

WJT-3101: Modern Software Development Practices CDJ-310

• Module 1 Object-Oriented Software Development and Architectural Concerns
• Module 2 Object Oriented Programming Principles
• Module 3 Tools for J2EE Development
• Module 4 Software Patterns

WJT-3102: Distributed Computing with Java Technology

• Mod 1 Exploring the Java Programming Language
• Mod 2 Distributed Computing Using the Java Programming Language
• Mod 3 J2EE and .NET comparisons

WJT-3103: J2EE Software in a Distributed System

• Module 1 Examining the Client Tier
• Module 2 Examining the Presentation Tier: Servlets and JavaServer Pages
• Module 3 Examining the Business Tier: Enterprise JavaBeans
• Module 4 Examining Web Services
• Module 5 Examining Integration Issues

Module 1 - Placing the J2EE Model in Context CDJ-310A

• Describe the needs of enterprise applications and how the J2EE platform addressesthese needs
• Describe the Java2 Platform, Enterprise Edition 1.4 Specification (J2EE platform1.4) application programming interfaces (APIs) and supporting services
• Describe the J2EE platform tiers and architectures
• Describe how to simplify J2EE application development using architecture patterns

Module 2 - J2EE Component Model and Development Steps

• Describe the principles of a component-based development model
• Describe the asynchronous communication model
• Describe the process used and roles involved when developing and executing a J2EEapplication
• Compare the different methods and tools available for developing a J2EE application and related components
• Describe how to configure and package J2EE applications

Module 3 - Using J2EE Development Tools

• Describe the benefits of the Sun Java Studio Standard Integrated DevelopmentEnvironment (formerly Sun ONE Studio 5, Standard Edition IDE) tools
• Describe the IDE tool
• Configure the IDE tool for deployment to an application server

Module 4 - EJB Component Model

• Describe the role of EJB components in a J2EE application
• Describe the EJB component model
• Identify the proper terminology to use when discussing EJB components and theirelements

Module 5 - Developing Session Beans

• Describe the role of session beans
• Describe the function and operational characteristics of stateless and statefulsession EJB components
• Describe the life cycle of session EJB components
• Implement a session bean

Module 6 - Basics of Entity Beans

• Describe the role of entity beans in a J2EE application
• Describe the persistence management options available when implementing entity EJB components
• Describe the elements of an entity EJB component
• Describe the life cycle and operational characteristics of a container-managedpersistence (CMP) entity EJB component

Module 7 - Developing CMP Entity Beans

• Implement CMP entity beans
• Write finder methods with the use of query language for EJB technology (EJB QL)

Module 8 - Assembling EJB Components Into an Application

• Exploit reusable components
• Package components appropriately
• Use the java:comp/env namespace
• Resolve resource and EJB component references
• Use the EJB components environment
• Use application client containers

Module 9 - Developing Message-Driven Beans

• Benefit from the use of enterprise messaging
• Describe the use of the JMS API
• Describe the role of message-driven beans
• Describe the object cardinality, life cycle, and pooling of message-driven beans
• Implement message-driven beans

Module 10 - Web Component Model

• Describe the role of web components in a J2EE application
• Define the HTTP request-response model
• Compare Java servlets and components and JSP components
• Describe the basic session management strategies
• Manage thread safety issues in web components

Module 11 - Developing Servlets

• Describe the servlet API
• Use the request and response APIs
• Forward control and pass data
• Use the session management API
• Call EJB components from servlets

Module 12 - Developing With JavaServer Pages Technology

• Evaluate the role of JSP technology as a presentation mechanism
• Author JSP pages
• Process data received from servlets in a JSP page
• Describe the use of custom tag libraries

Module 13 - Using Web-Tier Design Patterns

• Manage complexity in the web tier
• Define the Model-View-Controller design paradigm
• Use the Service-to-Worker, Dispatcher View, and Business Delegate patterns to provide a web-tier framework

Module 14 - Implementing a Transaction Policy

• Describe transaction semantics
• Compare programmatic and declarative transaction scoping
• Use Java Transaction API (JTA) to scope transactions programmatically
• Implement a container-managed transaction policy
• Predict the effect of transaction scope on application performance

Module 1 - Introduction to Web Application Technologies CDJ-314A

• Describe Internet services
• Describe the World Wide Web
• Distinguish between web applications and web sites
• Describe Java servlet technology and list three benefits of this technology compared to traditional Common Gateway Interface (CGI) scripting
• Describe JavaServer Pages technology and list three benefits of JSP pages technology over rival template page technologies
• Describe the Java 2 Platform, Enterprise Edition (J2EE platform)

Module 2 - Developing a View Component

• Design a view component
• Describe the Hypertext Transfer Protocol
• Describe the web container behavior
• Develop a view servlet
• Configure and deploy a servlet

Module 3 - Developing a Controller Component

• Design a controller component
• Create an HTML form
• Describe how HTML form data is sent in the Hypertext Transfer Protocol (HTTP) request
• Develop a controller servlet
• Dispatch from a controller servlet to a view servlet

Module 4 - Developing Dynamic Forms

• Describe the servlet life cycle
• Customize a servlet with initialization parameters
• Explain error reporting within the web form
• Repopulating the web form

Module 5 - Sharing Application Resources Using the Servlet Context

• Describe the purpose and features of the servlet context
• Develop a servlet context listener to initialize a shared application resource

Module 6 - Designing the Business Tier

• Describe the Analysis model
• Design entity components
• Design service components

Module 7 - Developing Web Applications Using Struts

• Design a web application using the Struts MVC framework
• Develop a Struts action class
• Configure the Struts action mappings

Module 8 - Developing Web Applications Using Session Management

• Describe the purpose of session management
• Design a web application that uses session management
• Develop servlets using session management
• Describe the cookies implementation of session management
• Describe the Uniform Resource Locator (URL)-rewriting implementation of session management

Module 9 - Using Filters in Web Applications

• Describe the web container request cycle
• Describe the Filter API
• Develop a filter class
• Configure a filter in the web.xml file

Module 10 - Integrating Web Applications With Databases

• Understand what a database management system (DBMS) does
• Design a web application to integrate with a DBMS
• Configuring a DataSource and Java Naming and Directory Interface(TM) (JNDI) API

Module 11 - Developing JSP Pages

• Describe JSP technology
• Write JSP code using scripting elements
• Write JSP code using the page directive
• Write JSP code using standard tags
• Write JSP code using the Expression Language (EL)
• Configure the JSP environment in the web.xml file

Module 12 - Developing JSP Pages Using Custom Tags

• Understand the job roles involved in web application development
• Understand the rationale in using custom tags
• Develop a JSP page using an existing custom tag library

Module 13 - Developing Web Applications Using Struts Action Forms

• Describe the components in a Struts application
• Develop an ActionForm class
• Develop a JSP page for a View form
• Configure the View forms

Module 14 - Building Reusable Web Presentation Components

• Describe how to build web page layouts from reusable presentation components
• Include JSP segments
• Develop layouts using the Struts Tiles framework

Module 1 - Examining EJB Components CDJ-351A

• Describe EJB component client interfaces
• Compare EJB component types
• Describe the basic characteristics of session beans
• Describe the basic characteristics of entity beans
• Describe the life cycle of stateless and stateful session beans and entity beans
• Describe container callback methods for session beans and entity beans

Module 2 - Packaging and Deploying EJB Components

• Examine the enterprise bean application packaging and deployment process
• Create the EJB component archive (EJB JAR) files
• Create the preliminary application client archive (initial client JAR) file
• Create the deployable application archive (application EAR) file
• Deploy applications built with J2EE technology (J2EE applications)
• Examine Vendor Specific Deployment Issues

Module 3 - Introducing the Auction Application

• Describe the auction application
• Define the domain objects of the auction application
• Describe the implementation model for the auction system

Module 4 - Implementing EJB 2.0 Container-Managed Persistence (CMP)

• Model business data
• Implement EJB 2.0 CMP
• Describe the CMP code examples

Module 5 - Implementing Container-Managed Relationships (CMR)

• Model business relationships in the data model
• Model business relationships in the object model
• Define relationships
• Implement one-to-one CMR
• Implement many-to-many CMR
• Change partner entities in CMR

Module 6 - Using the EJB Query Language (EJB QL)

• Implement finder methods
• Implement Enterprise bean Select methods
• Implement home methods
• Write queries using EJB QL

Module 7 - Developing J2EE Applications Using Messaging

• Describe the roles of the participants in the JMS API messaging system
• Write a message producer
• Write an asynchronous message listener
• Write a synchronous message listener
• List the messaging capabilities and limitations of session, entity, and message-driven beans

Module 8 - Developing Message-Driven Beans

• Describe the properties and life cycle of message-driven beans
• Create a JMS message-driven bean
• Create a non JMS message-driven bean

Module 9 - Implementing Transactions

• Describe the transaction demarcation task
• Implement Container-Managed Transactions (CMT)
• Interact programmatically with an ongoing CMT transaction
• Implement Bean-Managed Transactions (BMT)
• Apply transactions to messaging

Module 10 - Handling Exceptions

• Introduce exceptions in J2EE applications
• Describe the exception path in a J2EE application environment
• Describe EJB container exception handling
• Handle exceptions in an enterprise beans methods
• Handle exceptions in an enterprise beans client code
• Review specific issues relating to exception handling in EJB technology applications

Module 11 - Using Timer Services

• Create a timer callback notification
• Process a timer callback notification
• Manage timer objects

Module 12 - Implementing Security

• Understand the J2EE security architecture
• Authenticate the caller
• Examine J2EE authorization strategies
• Use declarative authorization
• Use programmatic authorization
• Examine the responsibilities of the deployer

Module 13 - Integrating With Legacy Systems

• Examine the requirements for EIS connectivity modules
• Compare alternative implementations of EIS connectivity modules
• Describe the J2EE technology connector architecture
• Use the Common Client Interface (CCI) API interfaces
• Use a message-driven bean resource adapter
• Describe the interoperability between the EJB technology and Common Object Request Broker Architecture (CORBA) protocols

Module 14 - Implementing Web Service Endpoint Interfaces

• Examine the enterprise bean web service implementation model
• Implement web services using stateless session beans

Module 15 - Using EJB Technology Best Practices

• Define best practices and state the benefits of using EJB technology best practices
• Select and apply known patterns to J2EE application design

WD-1100: Introduction to Wireless Technologies CDJ-450

• Module 1 - What is Wireless?
• Module 2 - How Wireless is Hardwired
• Module 3 - Wireless Benefits for Business Operations
• Module 4 - Planning a Wireless Solution

WJT-1500: An Overview of the J2ME Platform

• Module 1: Overview of the J2ME Platform
• Module 2: J2ME Configurations
• Module 3: J2ME Profiles
• Module 4: Optional J2ME Packages
• Module 5: Future Directions

WJ-2755: Designing Graphical User Interfaces with Java Technologies CDJ-455

• Module 1: Organizing Graphical User Interface (GUI)
• Module 2: Handling Events
• Module 3: Creating GUI-Based Applications
• Module 4: Working With Java Technology Applets

WJT-1500: An Overview of the J2ME Platform

• Module 1: Overview of the J2ME Platform
• Module 2: J2ME Configurations
• Module 3: J2ME Profiles
• Module 4: Optional J2ME Packages
• Module 5: Future Directions

WJT-3601: Developing Mobile Desktop Applications

• Module 1: CDC and CVM Technical Overview
• Module 2: Examining the Foundation Profile
• Module 3: Developing applications with the Personal Basis Profile
• Module 4: Developing applications with the Personal Profile
• Module 5: Future Directions

WJ-2754: Handling and Optimizing Java Technology Code CDJ-460: COURSES INCLUDED IN BUNDLE

• Module 1: Exception Handling in Java Technology
• Module 2: Threading in Java Technology

WJ-2755: Designing Graphical User Interfaces with Java Technologies

• Module 1: Organizing Graphical User Interface (GUI)
• Module 2: Handling Events
• Module 3: Creating GUI-Based Applications
• Module 4: Working With Java Technology Applets

WJT-3701: Working with the J2ME Wireless Toolkit 2.0

• Module 1- Inventory of new features in MIDP 2.0
• Module 2- Overview of the Game, ABB and Enhanced User Interface APIs
• Module 3- Tool support for: Security model and Pause/Resume
• Module 4- Network Protocols overview and network monitor support
• Module 5- Overview of Push Registry and tool support
• Module 6- Mobile Media API
• Module 7- Wireless Messaging API and tool support
• Module 8- Dynamically configuring API subsets and monitoring MIDlet performance
• Module 9- IDE integration and potential pitfalls

WJT-3702: Java Technologies for the Wireless Industry (JTWI): Architecture and Implementation

• Module 1 - JTWI 1.0 Specification Overview
• Module 2 - The JTWI 1.0 Mandatory Specifications
• Module 3 - The JTWI 1.0 Conditional Specifications
• Module 4 - Examining Common JTWI Best Practices

WJT-3703: JTWI Standard Extensions for Mobile Media & Wireless Messaging

• Module 1 - JTWI Optional Packages Overview
• Module 2 - Wireless Messaging API Package
• Module 3 - Mobile Media API Package
• Module 4 - Developing Applications With the MMAPI