Advanced Java Programming

Revision: TE2403_20071201

(8.09 KB) View, Download, or Print Catalog as a PDF.

Course Length:

5 Days

Course Description:

Advanced Java is a comprehensive study of many advanced Java topics. These include assertions, collection classes, searching and sorting, regular expressions, logging, bit manipulation, serialization, threads, networking with sockets, Remote Method Invocation, and Java Database Connectivity.

Who Should Attend:

This course is intended for programmers who have been programming in Java and who wish to write programs in Java using many of the advanced Java features.

Benefits of Attendance:

Upon completion of this course, students will be able to:

• Document and package a Java application
• Use may of the new enhancements added to the Java API
• Use assertions to write robust Java code.
• Use regular expressions for efficient pattern matching.
• Choose appropriate data structures from the Java Collection API.
• Sort and search arrays and lists using a variety of techniques.
• Capture configuration and debugging information using the Java Logging APIs.
• Use Generics to create type safe collections.
• Serialize Java objects.
• Use features of the New I/O API.
• Write TCP/IP Client Server applications using sockets.
• Write multi-threaded Java applications.
• Execute methods on a remote object using RMI.
• Perform database queries and updates using JDBC.

Prerequisites:

Students should have completed a beginning Java course or have programmed in Java for at least three - six months.

Course Outline:

• Chapter 1: Review of Java Fundamentals
  1. The Java Environment
  2. Data Types
  3. Strings
  4. StringBuffers
  5. Arrays
  6. Passing Data Types to a Method
  7. Constructors and Initialization
  8. Inheritance
  9. Abstract Classes
  10. Interfaces
  11. Static Data, Methods and Blocks
  12. Wrapper Classes
• Chapter 2: Packaging a Java Application
  1. Introduction
  2. Packages
  3. Managing Source and Class Files
  4. jar Files
  5. The Manifest File
  6. The javadoc Utility
  7. Documenting Classes and Interfaces
  8. Documenting Fields
  9. Documenting Constructors and Methods
• Chapter 3: Miscellaneous Enhancements
  1. Enhanced for Loop
  2. Autoboxing and Auto-Unboxing
  3. Static Imports
  4. Varargs
  5. Typesafe Enums
  6. Formatted Strings
  7. Format Specifier Syntax
  8. Format Specifier Conversions
  9. Format Specifier Flags
  10. Formatted Integers Example
  11. Formatted Floating Points Example
  12. Formatted Strings Example
  13. Formatted Dates Example
  14. Complex Formatted Example
• Chapter 4: Assertions
  1. Introduction
  2. Assertion Syntax
  3. Compiling with Assertions
  4. Enabling and Disabling Assertions
  5. Assertion Usage
• Chapter 5: Regular Expressions
  1. Regular Expressions
  2. String Literals
  3. Character Classes
  4. Quantifiers
  5. Capturing Groups and Backreferences
  6. Boundary Matchers
  7. Pattern and Matcher
• Chapter 6: The Java Collection Classes
  1. Introduction
  2. The Arrays Class
  3. Searching and Sorting Arrays of Primitives
  4. Sorting Arrays of Objects
  5. The Comparable and Comparator Interfaces
  6. Sorting - Using Comparable
  7. Sorting - Using Comparator
  8. Collections
  9. Lists and Sets
  10. Iterators
  11. Lists and Iterators Example
  12. Maps
  13. Maps and Iterators Example
  14. The Collections Class
  15. Rules of Thumb
• Chapter 7: Generics
  1. Introduction
  2. Defining Simple Generics
  3. Generics and Subtyping
  4. Wildcards
  5. Bounded Wildcards
  6. Generic Methods
• Chapter 8: Advanced I/O
  1. Introduction
  2. Basic File I/O Example
  3. Buffered I/O
  4. The Console Class
  5. Object Serialization
  6. Serialization Issues
  7. Compressed Files
  8. Zip File Example
  9. Writing Your Own I/O Classes
  10. Property Files
  11. The Preferences Class
  12. Exercises
• Chapter 9: Enhanced I/O
  1. Introduction
  2. Channels
  3. Buffers
  4. Typed Buffers
  5. Direct Buffers
• Chapter 10: Logging API
  1. Introduction
  2. Loggers
  3. Logger Levels
  4. Logger Handlers
  5. Specifying Handlers and Formatters
  6. Configuring Handlers
  7. LogManager
• Chapter 11: Networking
  1. Networking Fundamentals
  2. The Client/Server Model
  3. InetAddress
  4. URLs
  5. Sockets
  6. A Time-of-Day Client
  7. Writing Servers
  8. Client/Server Example
• Chapter 12: Threads and Concurrency
  1. Review of Fundamentals
  2. Creating Threads by Extending Thread
  3. Creating Threads by Implementing Runnable
  4. Advantages of Using Threads
  5. Daemon Threads
  6. Thread States
  7. Thread Problems
  8. Synchronization
  9. Performance Issues
  10. Exercises
• Chapter 13: Remote Method Invocation (RMI)
  1. Introduction
  2. RMI Architecture
  3. The Remote Interface
  4. The Remote Object
  5. Writing the Server
  6. The RMI Compiler
  7. Writing the Client
  8. Remote Method Arguments and Return Values
  9. Dynamic Loading of Stub Classes
  10. Remote RMI Client Example
  11. Running the Remote RMI Client Example
  12. Exercises
• Chapter 14: Java Database Connectivity (JDBC)
  1. Introduction
  2. Relational Databases
  3. Structured Query Language
  4. A Sample Program
  5. Transactions
  6. Meta Data
  7. Exercises