Java University Program

Created and delivered by Sun certified instructors who are experts in Java technology, these intensive courses are designed to boost your knowledge of the language and platform and are designed exclusively for the 2005 Conference.

Choose from one of the following in-depth classes:

	The Java Programming Language
	Developing Applications for the J2EE Platform
	GUI Construction With Java Foundation Classes
	Web Component Development With Servlet and JSP Technologies

If you are a beginner, intermediate or advanced level developer using Java technology, you will benefit from these valuable, full-day classes. The special price of $795 covers any one of the Java University program classes offered. Seeating is limited, so register now.

Course Level: New programmer
Instructor Name: Carl Linkletter, Sun Certified Instructor, Java Technology Expert

Course Description:
This introductory course provides students with information about the syntax of the Java programming language; object-oriented programming with the Java programming language; and creating graphical user interfaces (GUIs), exceptions, file input/output (I/O), and threads and networking. Programmers familiar with object-oriented concepts can learn how to develop Java technology applications. The course uses the Java 2 Software Development Kit (Java[TM] 2 SDK).

Course Approach:
Through a series of proof-of-concepts code this course teaches the fundamental constructs of the java programming language.

Skills Gained
Upon completion of this course, students should have an understanding of:

  
• Java technology applications that leverage the object-oriented features of the Java language, such as encapsulation, inheritance, and polymorphism   
• Execute and run a Java technology application   
• Java technology data types and expressions   
• Java technology flow control constructs   
• Use arrays and other data collections   
• Implementing error-handling techniques using exception handling   
• Create event-driven GUI using Java technology GUI components: panels, buttons, labels, text fields, and text areas   
• Implement I/O functionality to read from and write to data and text files.   
• How to create multithreaded programs   
• How to create a simple Transmission Control Protocol/Internet Protocol (TCP/IP) client that communicate through sockets

Course Outline
I. Getting Started

  
• Describe the key features of Java technology   
• Write, compile, and run a simple Java technology application   
• Describe the Java virtual machine's (JVM[TM] machine's) function

II. Object-Oriented Programming

  
• Define class, member, attribute, method, constructor, and package   
• Use the access modifiers private and public as appropriate for the guidelines of encapsulation - Invoke a method on a particular object

III. Identifiers, Keywords, and Types

  
• Recognize Java technology keywords   
• List the eight primitive types   
• Construct an object using new   
• Describe default initialization   
• Describe the significance of a reference variable

IV. Expressions and Flow Control

  
• Identify and correct a Possible reference before assignment compiler error   
• Recognize, describe, and use Java software operators   
• Distinguish between legal and illegal assignments of primitive types   
• 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

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

VI. Class Design

  
• Describe the concepts of constructor and method overloading   
• Describe the complete object construction and initialization operation

VII. Advanced Class Features

  
• Describe static variables, methods, and initializers   
• Describe final classes, methods, and variables   
• Distinguish between static and non-static nested classes   
• Explain how and when to use an interface

VIII. Exceptions and Assertions

  
• Define exceptions   
• Use try, catch, and finally statements   
• Develop programs to handle your own exceptions   
• Use assertions   
• Disable assertions at runtime

IX. Threads

  
• Define a thread   
• Create separate threads in a Java technology program, controlling the code and data that are used by that thread   
• Use wait and notify to communicate between threads   
• Use synchronized to protect data from corruption

X. Advanced I/O Streams

  
• Construct node and processing streams, and use them appropriately

XI. Networking

  
• Use ServerSocket and Socket classes for implementing TCP/IP clients and servers

Course Level: Intermediate programmer
Instructor Name: Joe Boulenouar, Sun Certified Instructor, Sun Center of Learning Excellence

Course Description:
This intermediate-level course provides students with the knowledge to build and deploy enterprise applications that comply with Java 2 Platform, Enterprise Edition (J2EE) platform standards. The enterprise components presented in this course include Enterprise JavaBeans (EJB) technology, servlets, and JavaServer Pages (JSP) technology, and the Java technology clients that use them. Students gain hands-on experience through labs that build an end-to-end, distributed business application. The labs explore session EJB components, which implement the Session Facade pattern and provide a front end to entity EJB components using container-managed persistence. The labs also explore message-driven EJB components, which act as Java Message Service (JMS) consumers. Students use web and Java technology clients to access Java technology-based enterprise services using servlets and pages created with JSP technology. Students are taught how to assemble an application from reusable components and how to deploy an application into the J2EE platform runtime environment.

Course Approach:
Through focused discussion on the J2EE platform, this course provides students with an understanding of how to build and deploy enterprise applications.

Skills Gained
Upon completion of this course, students should have an understanding of:

  
• The application model for the J2EE platform and the context for the model   
• Developing and testing an EJB technology application   
• Developing a web-based user interface to an EJB technology application   
• Configuring the J2EE platform services layer

Course Outline
I. 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

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

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

IV. Developing CMP Entity Beans

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

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

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

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

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

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

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

Course Level: Intermediate programmer
Instructor Name: Steve Stelting, Sun Certfied Instructor, , Sun Center of Learning Excellence

Course Description:
This intermediate-level course provides students with information about how to build effective user interfaces using the Java Foundation Classes and Swing components (“J.F.C./Swing”). J.F.C./Swing technology was added to the core platform of the Java programming language to enable developers to produce top-quality professional graphical user interfaces (GUI) without using third-party class libraries.

Designing a human interface for computer systems is an essential part in creating applications. This course provides a technical introduction to the Java technology interface controls that implement effective user interfaces.

Course Approach:
Through explanation of key components, this course provides students with an understanding of requirements for building effective user interfaces using the J.F.C./Swing components.

Skills Gained:
Upon completion of this course, students should have an understanding of:

  
• The features of the Abstract Window Toolkit (AWT) and J.F.C./Swing components to make design choices for a project   
• How to program reactions to user interactions with GUI components   
• How to handle keyboard and mouse input, including non-ASCII (American Standard Code for Information Interchange) character sets   
• How to control the focus handling of a program   
• How to create displays that use scrolling and autoscrolling   
• How to control the look and feel of a GUI, by installing a pre-written look and feel, and by using borders (the course does not discuss the detailed issues of creating a new look and feel)   
• How to create custom components for specialized GUI needs   
• How to generate hard copy output under program control   
• How to understand and correctly use the Model View Controllers (MVC) design pattern   
• How to write programs that run appropriately under different language/locales   
• How to apply character encoding conversion techniques   
• How to use localized resources to present messages in the users' language   
• How to program drag-and-drop and cut-and-paste operations

COURSE OUTLINE
I. Introduction

  
• Outline the features of the J.F.C./Swing components

II. J.F.C./Swing Technology

  
• Name the J.F.C./Swing components that are direct substitutes for the AWT components   
• Recognize basic J.F.C./Swing components and use them in interfaces

III. Basic J.F.C./Swing Components

  
• Use icons in J.F.C./Swing components   
• Discuss the Icon interface

IV. More J.F.C./Swing Technology Foundations

  
• Create accessible user interfaces using J.F.C./Swing components   
• Write code to implement keystroke handling   
• Write code to use predefined Action objects in J.F.C./Swing components

V. J.F.C./Swing MVC Components

  
• Write code to use the JList class initialized with data in either a Vector or an Object array   
• Write code to use the ListModel interface, AbstractListModel, or DefaultListModel classes   
• Write code to obtain the ListModel in use by a JList   
• Write code to extend AbstractListModel, implementing the list model itself and providing a controller interface   
• Describe the significance of Action and KeyStroke classes to the model and controller roles of MVC   
• Implement the Action interface as a means of creating a controller interface on a model

VI. Jtable and Jtree

  
• Describe the Jtable   
• Describe the Jtree

VII. More J.F.C./Swing Technology Features

  
• Describe the reasons for J.F.C./Swing components' single-threading rule   
• List the exceptions to J.F.C./Swing components' single-threading rule   
• Write code that uses Border objects to modify the appearance of J.F.C./Swing components, including using nested borders   
• Write programs that enable users or system administrators to install a look and feel according to their preference   
• Write code to control the default focus, and keyboard focus traversal order, of a GUI

VIII. Utility Panes

  
• Create programs that use the J.F.C./Swing component containers JTabbedPane, JSplitPane, and JScrollPane   
• Create programs that can build a JFileChooser to display the files in a directory   
• Create programs that use the JOptionPane to display dialog boxes

IX. Creating Custom Components

  
• Create new lightweight components by subclassing java.awt.Component or J.F.C./Swing components

Course Level: Advanced Programmer
Instructor Name: Bob Kellogg, Sun Certified Instructor, Sun Center of Learning Excellence

Course Description:
JavaServer Pages (JSP) and servlets are the key web tier technologies defined in the Java 2 Platform, Enterprise Edition (J2EE platform). This advanced course provides experienced Java technology developers a way to obtain the knowledge and skills necessary to quickly build web applications from JSP and servlet technologies using the Tomcat web container. Students are exposed to the current methods for analyzing, designing, developing, and deploying web applications with Java technologies. Real-world lab exercises provide students with experience in constructing and deploying the small to medium scale web applications found in intranet and low-volume commercial sites.

This course also is an ideal method of preparing for the revised Sun Certified Web Component Developer (SCWCD) for J2EE 1.4 technology certification examination. However, before taking the exam, an SCWCD candidate should also spend six months building real-world web applications using the JSP and servlet technologies before taking the exam.

Course Approach:
Through focused discussion this course provides experienced Java technology programmers with aa deeper understanding of servlet and JSP[tm] technologies.

Skills Gained:
Upon completion of this course, students should have an understanding of:

  
• How to write Java servlets   
• How to create robust web applications using session management, filters, and database integration   
• How to write JSP pages   
• How to create easy to maintain JSP pages using the Expression Language, JSP Standard and Tag Library (JSTL)   
• How to create robust web applications

Course Outline I. 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

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

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

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

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

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

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

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