Java 6 Programming Fundamentals for OO Developers Training

Students who attend Java 6 Programming Fundamentals for OO Developers will leave this course armed with the required skills to develop solid object-oriented applications written in Java, using sound coding techniques and best coding practices. Geared for developers with prior OO development experience in languages such as C++ or SmallTalk, this course will teach students everything they need to become productive in essential Java programming.

Working within in a dynamic, hands-on learning environment, guided by our expert team, attendees will learn to:

• Understand not only the fundamentals of the Java language, but also its importance, uses, strengths and weaknesses
• Understand the basics of the Java language and how it relates to OO programming and the Object Model
• Learn to use Java multi-threading and exception handling features
• Understand and use classes, inheritance and polymorphism
• Understand and use collections, generics, autoboxing, and enumerations including new Java 6 features and capabilities
• Work with the logging API and framework that is part of the Java platform
• Use the JDBC API for database access
• Use Java for networking and communication applications
• Work with annotations
• Understand and work with the classes in the concurrent package
• Outline the options for GUI applications in Java
• Take advantage of the Java tooling that is available with the programming environment being used in the class

Throughout the five-day course, students will be led through a series of progressively advanced topics, where each topic consists of lecture, group discussion, comprehensive hands-on lab exercises, and lab review.

If your team requires more advanced Java materials or custom topics, this course may be easily adjusted to accommodate. We offer many additional advanced Java classes which may be blended with this course for a track that best suits your development objectives.

Session
Java: A First Look

Lesson - Using the JDK

• Setting Up Environment
• The Development Process
• Locating Class Files
• Compiling Package Classes
• Source and Class Files
• Applications and Applets

Lesson Writing a Simple Class

• Classes in Java™
• What Is a Class?
• Defining the Class
• Class Modifiers
• Class Instance Fields
• Instance Fields Diagram
• Primitives vs. Object References
• Creating Objects
• The main Method
• Using the Dot Operator
• Writing Output

Lesson - The Java™ Platform

• Defining Java
• Java Provides Several Platforms
• Note on Terminology
• Java SE 6
• Java SE Development Kit (JDK)
• Executing Programs
• Lifecycle of a Java Program
• Responsibilities of JVM
• Java is Dynamic: The Runtime Process
• Primary Areas of the JVM Runtime
• Garbage Collection
• Documentation and Code Reuse
• JavaDoc Provides Documentation Delivery
• In-Line Comments are Translated into HTML Rendering
• Working with Java in Your Environment

Session
Object-Oriented Concepts In Java

Lesson - Object-Oriented Programming

• The Object Oriented Way
• Real-World Objects
• Classes and Objects
• Examples of Classes and Objects
• Classes and Objects Diagram
• Object Behavior
• Methods and Messages

Lesson - Inheritance, Abstraction, and Polymorphism

• Encapsulation
• Inheritance
• Method Overriding
• Aggregation
• Type Abstraction - Grouping as Supertype
• Polymorphism
• Polymorphism Diagram

Session
Getting Started with Java™

Lesson - Adding Methods to the Class

• Instance Methods
• Passing Parameters Into Methods
• Returning a Value From a Method
• Overloaded Methods
• Overloaded Methods Diagram
• Constructors
• Defining a Constructor
• Optimizing Constructor Usage

Lesson - Language Statements

• Operators
• Comparison and Logical Operators
• Looping: The for Statement
• Looping: The while Statement
• Looping: The do Statement
• Continue and Break Statements
• The switch Statement

Lesson - Using Strings

• Strings
• String Method
• String Equality
• StringBuffer
• Strings, StringBuffer, and StringBuilder
• StringTokenizer
• Scanner
• Scanner - File Source
• Scanner - Getting Input
• Scanner - Testing for Tokens
• Scanner - Patterns for Tokens
• Formatter
• Formatter - Probable First Encounters
• Formatter - StringBuffer

Lesson - Specializing in a Subclass

• Extending a Class
• The extends Keyword
• Casting
• Overriding Superclass Methods
• Method Overriding Diagram
• Calling Superclass Methods from Subclass
• The Object Class
• The equals Method
• Default Constructor
• Implicit Constructor Chaining
• Passing Data Up Constructor Chain
• A Common Programming Mistake
• Editing Tools in Your IDE

Session
Essential Java™ Programming

Lesson - Fields and Variables

• Fields vs. Variables
• Data Types
• Default Values
• Block Scoping Rules
• Using this
• Final and Static Fields
• Static Variable Diagram

Lesson - Using Arrays

• Arrays
• Accessing the Array
• Multidimensional Arrays

Lesson - Static Methods and Fields

• Static Fields
• Simple Example of Static Fields
• Static Methods

Lesson - Java™ Packages

• The Problem
• Packages
• Class Location of Packages
• The Package Keyword
• Importing Classes
• Executing Programs
• Visibility
• Java Naming Conventions
• Packages Diagram
• Refactoring in Your IDE

Session
Advanced Java™ Programming

Lesson - Inheritance and Polymorphism

• Polymorphism
• Polymorphism: The Subclasses
• Treating Derived Classes as the Superclass
• Casting to the Derived Class
• Using instanceof For Downcasting
• Upcasting vs. Downcasting
• Calling Superclass Methods From Subclass
• The final Keyword

Lesson - Interfaces and Abstract Classes

• Separating Capability from Implementation
• Abstract Classes
• Shape as an Abstract Class
• Polymorphism With Abstract Classes
• Interfaces
• Implementing an Interface
• Extending Interfaces
• Polymorphism With Interfaces
• Type Checking
• Abstract Classes vs. Interfaces
• Interfaces Diagram

Lesson - Exceptions

• What is an Exception?
• Exception Architecture
• Handling Exceptions
• The Throwable Class
• The try Block
• The catch Block
• The finally Block
• Full Example of Exception Handling
• Generalized vs. Specialized Exceptions
• Overriding Methods
• Creating Your Own Exceptions
• Throwing Exceptions
• Re-throwing an Exception
• Checked vs. Unchecked Exceptions
• Debugging in Your IDE

Session
Java™ Developer's Toolbox

Lesson - Utility Classes

• Wrapper Classes
• The Number Class
• Numbers and Strings
• Big Decimal
• Random Numbers
• Decimal Formatting
• The Date Class

Lesson - Vector and Hashtable

• The Vector Class
• Creating and Using a Vector
• Java Collections Methods in Vector
• Hashtables
• Understanding How Hashing Works
• Creating and Using a Hashtable
• Performing Lookups

Lesson - Collections

• The Collections Framework
• Collections Feature Types
• Collections Interface Hierarchy
• Map Interfaces
• Optional Methods
• The Collection Interface
• Iterators
• The Set Interface
• SortedSet
• Set and SortedSet Example
• Comparable and Comparator
• The List Interface
• List Example
• ListIterator
• Queue Interface
• QueueExample
• BlockingQueue
• BlockingQueue Implementations
• Collections Utility Methods
• Features of the Implementation Classes
• Synchronization Wrappers
• Feature Comparison
• Using the Right Collection
• Use of Collections vs. Vector/Hashtable
• Optimizing Collection Constructors
• Copying Arrays
• Creating and Using an ArrayList
• Creating and Using a HashMap

Lesson - Generics

• Generics and Parametric Polymorphism
• Simple Generics
• The Mechanics of Generics
• Generics and Subtyping
• Compiler Restrictions on Generics and Subtyping
• Generics as Arguments in Methods
• Rationale Behind Wildcards
• Wildcards In Use
• Regular Wildcards in Method Parameters
• Bounded Wildcards
• Standard Rules Apply
• Generic Methods
• Interoperability with Legacy Code
• Raw Types
• Legacy Calls To Generics
• When Generics Should Be Used
• Build Paths in Your IDE

Lesson - Overview of Java GUIs

• JFC - Java Foundation Classes
• Categories of Classes in JFC
• Creating the Frame
• Adding Content to a Frame
• A Closer Look at Layout Managers
• BorderLayout
• JFC Provides an Event Handling Structure

Lesson - Autoboxing, Enhanced for Loop and Varargs

• Autoboxing/Unboxing
• Autoboxing/Unboxing Issues
• For() Loops and Collections
• The Enhanced for() Loop
• Another Example - Problematic
• Another Example - Enhanced for()
• Enhanced for() Loop Restrictions
• Previous Variable Argument Support
• Variable Arguments in Java SE 1.5
• Varargs rules
• Issues

Lesson - Enumerations and Static Imports

• Rationale for Enumerations
• Enumeration Syntax
• Enumerations Methods
• Enumerations as a Better Class Type
• Enumeration Code
• EnumSet
• EnumMap
• When You Should Use Enumerations
• Using Static Imports
• When You Should Use Static Imports

Lesson - Inner Classes

• Defining Inner Classes
• Member Inner Classes
• Local Inner Classes
• Anonymous Inner Classes
• Anonymous Subclassing

Lesson - Multithreading

• Principles of Multithreading
• Creating a Threaded Class
• Creating a Threaded Class Using Runnable
• Example: Threaded Class
• Example: Runnable Class
• Basic Features of the Thread Class
• Daemon Threads
• Thread Scheduling
• Signaling a Thread
• Sleeping
• Thread Synchronization
• Synchronized Methods
• Synchronized Block
• Object Synchronization

Lesson - Java I/O

• The Java I/O Mechanism
• Byte Level I/O
• Subclasses Accessing Real Data
• Filter Classes
• Reading Stream as Data Primitives
• Adding Buffering for Better Performance
• Writing Buffered Data to a File
• Character Level I/O
• Subclasses Accessing Real Data
• Reader/Writer Filter Classes
• Serialization
• Switching Java Versions in Your IDE

Lesson - Introduction to Annotations

• Annotations Overview
• Working with Java Annotations
• Example of Using @Override
• Annotations are Heavily Used in Many Technologies
• Declaring Persistence in Hibernate

Session
Java™ Application Development

Lesson - File System Access

• The File Class
• File Utility Methods
• RandomAccessFile
• Byte-Based File Access
• Text-Based File Access
• FileReader Diagram

Lesson - Networking

• Socket Programming Fundamentals
• Communicating on a Socket
• Single-Threaded Server Performance
• Creating a Threaded Server
• Sending and Receiving Objects
• Useful Methods

Lesson - JDBC ™

• What is JDBC?
• Structured Query Language (SQL)
• Connecting to the Database
• Statements
• Statement and PreparedStatement
• ResultSet
• JDBC Diagram
• Executing Inserts, Updates, and Deletes
• Controlling Transactions and Concurrency
• Mapping SQL Types to Java Types
• Database Connection Via JDBC Calls
• Rationale for Connection Pooling
• Connection Pooling in JDBC
• Database Connection Using a DataSource
• Stored Procedures Defined
• Callable Statement Syntax
• Stored Procedure Parameters
• RowSet Implementations
• JDBCRowSet
• JDBCRowSet Approach
• JDBCRowSet - Retrieving Data
• JDBCRowSet Example
• CachedRowSet
• CachedRowSet Approach
• CachedRowSet Example

Lesson - Java Logging

• Why Logging?
• Logging Framework
• Logging in Java
• Java Logging Framework
• The Logger Class
• Global Configuration
• Logging Levels
• Programmatically Setting Logging Properties
• Programmatic Handlers
• Formatters
• Logging Security & Performance

Lesson - New In Java 6

• Java 6 - Performance
• Java 6 - Security Improvements
• Java 6 - Web Services Improvements
• Java 6 - Development
• Java 6 - GUI
• Java 6 - Compression
• Java 6 - Collection Interfaces
• Java 6 - Concrete Implementation
• Java 6 - Retrofitted
• Java 6 - More on Collection
• Java 6 - I/O
• Java 6 - Internationalization
• The JAXB Difference

Appendix:
Additional Topics (Available on Request)

• Programming JavaBeans™
• Introduction to Java 2 Security
• Containers and Layout Managers
• Writing Simple Graphical Applications
• Writing Complete Graphical Applications
• Writing Java Applets

LABS: There are over 35 hands-on lab exercises and challenges laced throughout this course. Please ask us for lab details.

Case Study: A complete case study provides an incremental series of labs covering requirements analysis, design, implementation, and refactoring. A complete set of solutions are also included, enabling the case study to be used after class as a homework assignment, tool for review, or a reference.