Product Description

Product Outline/Details

Product ID:

Duration:

Price:

IJP (on hotel)

4 days

IDR 3,500,000

IJP – Night (off hotel)

8 days

IDR 2,500,000

Prerequisites

Skills Gained

Course Content

Day 1

Chapter 1 - Java Technology Overview

• Describe key concepts of the Java programming language
• List the Java technology products used with this course
• Summarize each of the seven steps in the application development lifecycle

Chapter 2 - Object-Oriented Analysis and Design

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

Chapter 3 - Introduction to Developing and Testing Classes

• Identify the parts of a class
• Use the main method in a test class to run a Java program from the command-line
• Compile and execute a Java program

Day 2

Chapter 4 - Variables

• Identify uses for variables and define variable syntax
• List the eight Java programming language primitive types
• Declare, set and use variables and constants according to Java programming rules and coding standards
• Modify variable values using operators
• Use promotion and casting to ensure proper storage allocation

Chapter 5 - Objects and Object Reuse

• Declare, initialize, and use object reference variables
• Compare how object reference variables are stored in relation to primitive variables
• Use a class included in the Java software development kit
• Use the Java 2 Platform, Standard Edition API documentation to learn about other classes in the Java 2 Platform, Standard Edition API

Chapter 6 - Operators and Decision Constructs

• Identify logical and boolean operators
• Examine the basic parts of if and if/else statements
• Use the switch statement

Day 3

Chapter 7 - Loop Constructs

• Create and identify appropriate uses for the while, for and do loops
• Determine when to end loop iteration using continue

Chapter 8 - Methods

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

Chapter 9 - Encapsulation and Constructors

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

Day 4

Chapter 10 - Arrays

• Define, and explain the use for, arrays
• Code a primitive-type single-dimension array
• Developing reference-type arrays
• Find the bounds of an array and use the bounds to set array values
• Create two-dimensional arrays

Chapter 11 - Inheritance

• Implement inheritance and abstraction to support object-oriented reuse
• Include Java class libraries

Product Description

Product Outline/Details

Product ID:

Duration:

Price:

JPL (on hotel)

5 days

IDR 4,000,000

JPL – Night (off hotel)

10 days

IDR 3,000,000

Prerequisites

Skills Gained

Course Content

Day 1

Chapter 1: Getting Started

• List the key features of the Java programming language
• Describe the Java virtual machine (JVM)
• Explain how garbage collection works
• Describe how security features work
• Write a simple Java application, compile and run it

Chapter 2: Object-Oriented Programming

• Describe the terms class, object, attribute, method, and constructor
• Write code to define a method
• Access the member variables of an object using the dot notation
• Write code to create and initialize an object
• Use the this keyword to access the "current" object
• Use private and public access modifiers
• Write code to invoke a method on a particular object
• Write class constructors and invoke particular constructors using new with arguments
• Understand the use of the package and import statements for library access
• Use the Java Application Programming Interface (API) online documentation

Chapter 3: Identifiers, Keywords, and Types

• Use comments in a program
• Distinguish between valid and invalid identifiers
• Recognize the keywords in the Java programming language
• List the eight primitive types
• Define literal values for numeric and textual types
• Describe the coding conventions for classes, interfaces, methods, variables, constants, and control structures
• Create a class definition for a simple class containing primitive member variables
• Declare variables of class type
• Describe the significance of a reference variable and state the consequences of assignment between variables of class type

Day 2

Chapter 4: Expressions and Flow Control

• Distinguish between member and automatic variables
• Describe the initialization of member variables
• Recognize and correct a Possible reference before assignment compiler error
• Recognize, describe, and use operators
• Distinguish between legal and illegal assignments of primitive types
• Recognize Boolean expressions and state the requirement for these in control constructs
• Recognize assignment compatibility and required casts in fundamental types
• Make appropriate use of if, switch, for, while, and do constructions and the labeled forms of break and continue

Chapter 5: Arrays

• Declare and create arrays of primitive, class, or array types
• Explain why and show how to initialize the elements of an array
• Determine the number of elements in any array
• Write code to copy arrays

Chapter 6: Class Design

• Describe encapsulation, polymorphism, and inheritance
• Use sub-classing
• Create and use heterogeneous collections
• Create and use methods that accept generic argument types
• Use access control levels
• Invoke overloaded methods and constructors
• Write overriding methods in a subclass and describe execution flow when executing an overridden method
• Invoke overridden methods and describe how the method is chosen
• Invoke overridden constructors
• Control invocation of parent class constructors
• Use wrapper classes
  

Day 3

Chapter 7: Advanced Class Features

• Declare and use static variables and methods
• Declare and use final classes, methods, and variables
• Use abstract methods and interfaces
• Use inner classes

Chapter 8: Exceptions

• Define exceptions
• Describe the use of the keywords try, catch, and finally
• Describe exception categories
• Identify common exceptions
• Write code to handle your own exceptions

Chapter 9: Text-Based Applications

• Write code to access command-line arguments and system properties
• Examine and manipulate files and directories
• Read and write text to file streams
• Describe the Collections API
• Use iterator
• Identify deprecated classes and describe how to handle them during migration to Java 2 SDK
  

Day 4

Chapter 10: Building Java GUIs

• Describe the Abstract Windowing Toolkit (AWT) package and its components
• Explain containers, components and layout managers, and how they work together to build a GUI
• Use the flow and border layout managers to achieve a desired dynamic layout
• Use the frame and panel containers
• Place panels inside other containers to build complex layouts

Chapter 11: GUI Event Handling

• Write code to handle events that occur in a user interface
• Create the appropriate interface and handler method for a variety of event types
• Determine the user action that originated the event from the event object details
• Determine how and when to use the appropriate adapter class to select a subset of event handlers for an event listener

Chapter 12: GUI-Based Applications

• Identify the key AWT components and the event types that they produce
• Control the colors and font used by an AWT component
• Understand the purpose of the Swing GUI library

Chapter 13: Threads

• Describe a thread
• Create separate threads, controlling the code and data that are used by that thread
• Control the execution of a thread and write platform-independent code with threads
• Describe some of the difficulties that arise when multiple threads share data
• Use the keyword synchronized to protect data from corruption
• Use wait() and notify() to communicate between threads

Chapter 14: Advanced I/O Streams

• Use the Streams version of the java.io package
• Construct and use node streams
• Distinguish Readers and Writers from Streams, and select appropriately between them
• Construct and use processing streams
• Understand how to create your own processing stream classes
• Read, write, and update data in random access files
• Use the Serialization interface to encode the state of an object to a stream and to implement object persistence

Chapter 15: Networking

• Create a minimal TCP/IP client
  

Product Description

Product Outline/Details

Product ID:

Duration:

Price:

IJ2EE (on hotel)

5 days

IDR 4,500,000

IJ2EE – Night (off hotel)

10 days

IDR 3,500,000

Prerequisites

Skills Gained

Course Content

Day 1

Chapter 1: Placing the J2EE Model in Context

• Describe the needs of enterprise applications and how the J2EE platform addresses these 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

Chapter 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 J2EE application
• Compare the different methods and tools available for developing a J2EE application and related components
• Describe how to configure and package J2EE applications

Chapter 3: Using J2EE Development Tools

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

Chapter 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 their elements

Day 2

Chapter 5: Developing Session Beans

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

Chapter 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-managed persistence (CMP) entity EJB component
  

Day 3

Chapter 7: Developing CMP Entity Beans

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

Chapter 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 component?s environment
• Use application client containers

Chapter 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

Day 4

Chapter 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

Chapter 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

Chapter 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

Chapter 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

Chapter 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
• Describe the effect of exceptions on transaction state

Chapter 15: Implementing a Security Policy

• Exploit container-managed security
• Define user roles and responsibilities
• Create a role-based security policy
• Use the security API
• Configure authentication in the web tier

Product Description

Product Outline/Details

Product ID:

Duration:

Price:

MJBCD (on hotel)

5 days

IDR 4,500,000

MJBCD – Night (off hotel)

10 days

IDR 3,750,000

Prerequisites

Skills Gained

Course Content

Day 1

Chapter 1 - Examining EJB Components

• 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

Chapter 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

Chapter 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
  

Day 2

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

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

Chapter 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

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

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

Day 3

Chapter 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

Chapter 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

Chapter 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

Day 4

Chapter 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 bean's methods
• Handle exceptions in an enterprise bean's client code
• Review specific issues relating to exception handling in EJB technology applications

Chapter 11 - Using Timer Services

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

Chapter 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

Chapter 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

Chapter 14 - Implementing Web Service Endpoint Interfaces

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

Chapter 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

Product Description

Product Outline/Details

Product ID:

Duration:

Price:

MJWCD (on hotel)

5 days

IDR 4,500,000

MJWCD – Night (off hotel)

10 days

IDR 3,500,000

Prerequisites

Skills Gained

Course Content

Day 1

Chapter 1 - Introduction to Web Application Technologies

• Describe Internet services
• Describe the World Wide Web service
• Distinguish between Web applications and Web sites
• Describe Java servlet technology
• Describe JavaServer Page technology
• Describe the Java 2 Platform, Enterprise Edition (J2EE)

Chapter 2 - Developing a Simple Servlet

• Develop a simple generic servlet
• Develop servlets that access request headers
• Develop servlets that manipulate response headers
• Describe the Hypertext Transfer Protocol (HTTP)
• Develop a simple HTTP servlet
• Deploy a simple HTTP servlet

Chapter 3 - Developing a Simple Servlet that Use HTML Forms

• Describe the structure of HTML FORM tags
• Describe how HTML forms send data using Common Gateway Interface (CGI)
• Develop an HTTP servlet that accesses form data

Chapter 4 - Developing a Web Application

• Describe the requirements of a robust Web application models
• Deploy a Web application using a deployment descriptors

Day 2

Chapter 5 - Configuring Servlets

• Describe the servlet life cycle
• Describe servlet initialization parameters
• Write servlet code to access the configured initialization parameters and their use with individual servlet instances

Chapter 6 - Sharing Resources Using the Servlet Context

• Describe the purpose and features of a servlet context
• Develop a servlet context listener that manages a shared Web application resource

Chapter 7 - Developing Web Applications Using the MVC Pattern

• List the limitations of simple Web applications
• Develop a Web application using a variation on the Model-View-Controller (MVC) pattern

Chapter 8 - Developing Web Applications Using Session Management

• Describe the purpose of session management
• Design a Web application using session management
• Develop servlets using session management
• Describe the cookies implementation of session management
• Describe the Universal Resource Locator-rewriting (URL-rewriting) implementation of session management

Day 3

Chapter 9 - Handling Errors in Web Applications

• Describe the types of errors that can occur in a Web application
• Declare an HTTP error page using the Web application deployment descriptor
• Declare a Java exception error handler page in the deployment descriptor
• Create an error handling servlet
• Write servlet code to log exceptions
• Write servlet code to capture a Java technology exception and forward it to an error handling servlet

Chapter 10 - Configuring Web Application Security

• Explain the importance of Web security
• Use the deployment descriptor to configure authorization for a Web application resource
• Use the deployment descriptor to configure authentication of users of a Web application

Chapter 11 - Understanding Web Application Concurrency Issues

• Describe why servlets need to be thread safe
• Understand the attribute scope rules and the corresponding concurrency issues
• Describe the single thread model
• Design a Web application for concurrency

Chapter 12 - Integrating Web Applications With Databases

• Understand what a database management system does
• Design Web application to integrate with a database
• Develop a Web application using a connection pool
• Develop a Web application using a data source and Java Naming and Directory Interface

Day 4

Chapter 13 - Developing JSP Pages

• Describe the JSP technology
• Write JSP syntax using scripting elements
• Write JSP syntax using the courier page directive
• Create and use JSP error pages
• Describe what the Web container does behind the scene

Chapter 14 - Developing a Web Application Using the Model 1 Architecture

• Design a Web application using the Model 1 architecture
• Develop a Web application using the Model 1 architecture

Chapter 15 - Developing a Web Application Using the Model 2 Architecture

• Design a Web application using the Model 2 architecture
• Develop a Web application using the Model 2 architecture

Chapter 16 - Building Reusable Web Presentation Components

• Describe how to build Web page layouts from reusable presentation components
• Write JSP technology syntax using the include directive
• Write JSP technology syntax using the jsp:include standard action
  

Chapter 17 - Developing JSP Pages Using Custom Tags

• Describe the problem with JSP technology scriptlet code
• Given an existing custom tag library, develop a JSP page using the library

Chapter 18 - Developing a Simple Custom Tag

• Describe the structure and execution of a custom tag in a JSP page
• Develop the tag handler class for a simple empty custom tag
• Develop a custom tag that includes its body in the contour of the HTTP response
• Write the tag library description for a simple, empty custom tag

Chapter 19 - Developing Advanced Custom Tags

• Develop a custom tag in which the body is conditionally included
• Develop a custom tag in which the body is iteratively included

Chapter 20 - Integrating Web Applications With Enterprise JavaBeans

• Understand the Java 2 Platform, Enterprise Edition (J2EE) at a high level
• Develop a Web application that integrates when an EJB component using the Business Delegate pattern