Advanced Java Programming (5 days)

Advanced Java Programming Overview

This course provides advanced training in developing software using the Java 2 Platform, Standard Edition, or J2SE. It is intended for students with solid experience in structured and object-oriented Java programming, including use of the Collections API and exception handling. The course software also includes an optional overlay of workspace and project files to support use of the Eclipse IDE in the classroom. (This requires that the instructor be experienced in use of Eclipse and able to walk students through basic tasks in the IDE.)

This revision of the course targets the 5.0 version of the Java language and Core API. (Java 5.0 is also known as Java 1.5, as this revision effects a transition to a new numbering scheme for the Java environment.) It has been rebuilt thoroughly, not only to cover new 5.0 language features, but also to comb out old programming techniques in favor of new ones. For training within the Java 1.4 environment, please see version 1.4 of this course; to read more about different versions of Java and for help deciding on which version of this course to use, see "Java Versions and Terminology Demystified".)

The course is organized into five modules. The first covers several general-purpose topics: using Java-5.0 generics, writing multi-threaded applications, the Reflection API and annotations, and network programming using sockets. Then the course takes up the challenge of building multi-tier applications using the standard Java platform. Multi-tier development most frequently uses the Java 2 Platform, Enterprise Edition, or J2EE, and we have a wide range of courses in that area. However it is quite possible to build lightweight multi-tier applications using only J2SE, and for some purposes the J2EE is moure trouble than it's worth.

So the course looks at each of the traditional tiers and the J2SE APIs most suited to developing them: the Java Foundation Classes, or JFC, for building graphical user interfaces (GUIs) for the presentation tier; Java RMI as a way of distributing Java objects in a separate business tier; and JDBC for the persistence tier. A J2SE multi-tier application provides a comprehensive case study that illustrates multi-tier architecture, design patterns, and best practices, and also provides a few challenge labs. Students will complete the course prepared to build distributed Java applications and to pursue JFC, RMI, or JDBC in greater depth.

Advanced Java Programming Course Goals

• Make effective use of Java generic types.
• Write multi-threaded Java applications.
• Use the Reflection API for highly generic tasks, discovery, or code-generation.
• Use standard annotations and develop custom annotations to express meta-data in Java source files.
• Communicate between processes using network sockets.
• Understand the roles of JFC, RMI, JDBC, and other Core API packages in the classic multi-tier architecture for distributed systems.
• Understand the basics of the JFC architecture.
• Build complex GUIs using various JFC controls.
• Understand the relationship between RMI and various J2EE technologies such as JNDI, EJB, and CORBA.
• Implement simple RMI clients and servers.
• Connect to a database using JDBC and perform a simple query.
• Update relational data using JDBC to execute updates, inserts and deletes.
• Use prepared statements to produce reusable database queries and optimize execution time.
• Use callable statements to access database procedures.
• Use scrollable and updatable results sets for more robust solutions.
• Use commit, rollback, and savepoint to build transactional systems.
• Use batch processing for efficient handling of large datasets.
• Use the Java 5.0 Core API and related tools to develop robust multi-tier applications.

Advanced Java Programming Course Prerequisites

Experience in the following areas is required:

• Solid Java programming experience is essential

Advanced Java Programming Course Outline

1. Advanced Java
   1. Generics
      1. Using Generics
      2. Type Erasure
      3. Type Boundaries
      4. Wildcards
      5. Generic Methods
      6. Strengths and Weaknesses of Generics
      7. Legacy Code and Generics
   2. Threads
      1. Java Thread Model
      2. Creating and Running Threads
      3. Manipulating Thread State
      4. Thread Synchronization
      5. Volatile Fields vs. Synchronized Methods
      6. wait and notify
      7. join and sleep
      8. The Concurrency API
      9. Atomic Operations
   3. Reflection
      1. Uses for Meta-Data
      2. The Reflection API
      3. The Class<T> Class
      4. The java.lang.reflect Package
      5. Reading Type Information
      6. Navigating Inheritance Trees
      7. Dynamic Instantiation
      8. Dynamic Invocation
      9. Reflecting on Generics
   4. Annotations
      1. Aspect-Oriented Programming and Java
      2. The Annotations Model
      3. Annotation Types and Annotations
      4. Built-In Annotations
      5. Annotations vs. Descriptors (XML)
   5. Sockets
      1. The OSI Reference Model
      2. Network Protocols
      3. The Socket Class
      4. The ServerSocket Class
      5. Connecting Through URL Objects
      6. HTTP and Other TCP Servers
      7. Datagram Clients and Servers
      8. Non-Blocking Sockets
2. J2SE Case Study
   1. Overview
      1. Three Tiers for J2EE
      2. Three Tiers for J2SE
      3. The Case Study
      4. Design Patterns
      5. Domain and Service Models
   2. The Presentation Tier
      1. The Standalone/Client Application
      2. JDesktopPane and JinternalFrame
      3. Adapting JList, JTable, and JTree to Services
      4. Presentation-Tier Patterns
   3. The Business Tier
      1. Distributing the Application
      2. A Chain of Services
      3. Logging
      4. Business-Tier Patterns
      5. Designing for Latency
   4. The Persistence Tier
      1. A Database is Not a Persistence Tier!
      2. Persistence Frameworks
      3. Persistent-Object Strategies
      4. Persistence-Tier Patterns
      5. Caching
3. The Java Foundation Classes
   1. Introduction to JFC
      1. Abstract Windowing Toolkit Basics
      2. Simple Layout Management
      3. Simple Event Handling
      4. Lightweight Controls
      5. JFC Feature Set
      6. JFC Architecture and Relationship to AWT
   2. JFC Application Design
      1. Role of a JFrame
      2. Building a Frame-Based JFC Application
      3. Panes
      4. Using Dialogs
   3. JFC Components
      1. JFC Component Class Hierarchy
      2. JComponent Features
      3. Simple Control Types
      4. Text Components
      5. Menus
      6. Managing Look and Feel
4. Remote Method Invocation
   1. RMI Architecture
      1. Motivation for RMI
      2. RMI, EJB, and CORBA
      3. RMI Architecture
      4. Lifetime of a Remote Method Invocation
      5. Registries
      6. Naming and URL Resolution
      7. Interface Design
      8. The Remote Interface
      9. Implementation Classes
      10. The RemoteObject and RemoteServer Classes
      11. The UnicastRemoteObject Class
      12. Server Implementation
      13. Using the Registry
      14. Client Implementation
      15. Code Deployment
   2. Practical RMI
      1. RMI Marshaling
      2. Passing Objects
      3. The Factory Pattern
      4. Serialization vs. Remote Reference
      5. Designing for Latency
      6. The Transfer Object Pattern
      7. Controlling Object Location
      8. Exception Handling
5. Java Database Connectivity
   1. Database and SQL Fundamentals
      1. Relational Databases and SQL
      2. Database, Schema, Tables, Columns and Rows
      3. SQL Versions and Vendor Implementations
      4. DDL -- Creating and Managing Database Objects
      5. DML -- Retrieving and Managing Data
      6. Sequences
      7. Stored Procedures
      8. Using SQL Terminals
   2. JDBC Fundamentals
      1. What is the JDBC API?
      2. JDBC Drivers
      3. Making a Connection
      4. Creating and Executing a Statement
      5. Retrieving Values from a ResultSet
      6. SQL and Java Datatypes
      7. Creating and Updating Tables
      8. Handling SQL Exceptions and Proper Cleanup
      9. Handling SQLWarning
   3. Advanced JDBC
      1. SQL Escape Syntax
      2. Using Prepared Statements
      3. Using Callable Statements
      4. Scrollable Result Sets
      5. Updatable Result Sets
      6. Transactions
      7. Commits, Rollbacks, and Savepoints
      8. Batch Processing
   4. Introduction to Row Sets
      1. Row Sets in GUI and J2EE programming
      2. Advantages of RowSets
      3. RowSet Specializations
      4. Using CachedRowSets

Advanced Java Programming Course Materials

In addition to a comprehensive set of materials, including course notes and all the programming examples, each student will also receive a one-year subscription to Webucator's online reference library, which contains hundreds of the most current electronic technology books - a $149.95 per student value.

Advanced Java Programming Technical Requirements

Complete Setup Instructions