The target audeince spansindividuals who have basicmathematical, logical, andanalytical problem solving skills and who want tobegin learning the Javaprogramming language (the 110A target). It also encompasses the 275A audience ofexperienced C++, C, COBOL, orVisual BASIC programmers who are interested in addingthe Java programminglanguage to their skill set. And those students who are preparing for the Sun Certified Programmer for Java 2 Platform Exam or theSunCertified Developer for Java 2 Platform Exam. The third entity (the 310audinece) includesprogram managers, businessanalysts, and project managers whorequire a rapid introduction toobject-oriented software development, the Javaprogramming language, and how theJ2EE technology set addresses distributed applications.

• 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 platformsupports 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

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 programminglanguage 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

• Define modeling concepts: abstraction, encapsulation, and packages
• 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 they work together to build a GUI
• Use layout managers
• Use the FlowLayout, BorderLayout

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(tm) 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 platform 1.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 applicationand 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