103 Java Programming Version 6.0 for Experienced Programers

As of March 29, 2010, Roger provides Java training through Webucator.

Overview:

• Experienced C and C++ programmers will find this course a good fit and if anything will find that they complete it in a less than the five-day timeline.
• Those with experience in languages less like Java, such as Visual Basic, ASP and other Web-scripting languages, and other pseudo-object-oriented languages may need more time in the early going, and this course covers its introductory topics in good depth and offers many optional and "challenge" labs to support this.
• Less experienced programmers or those coming from non-structured languages -- such as COBOL, PL/1, or 4GL tools -- will probably not cover the whole course in a week, and may want to pursue an abbreviated version at a slower pace. This too is quite feasible, but this audience may also want to consider our Introduction to the Java Programming Language for a more relaxed pace through the early material.

Prerequisites

• No prior Java experience is required, but students must be experienced programmers in another third-generation (high-level) language. See the overview for suggestions about pace and scope for different backgrounds.

Pricing:

• $1000. per day of training up to 15 participants
• $1200.00 per day of training up to 25 participants (more than 25 participants is not recommended)
• $250 per student for training materials
• Approximately $1500.00 to $2000.00 for expenses although location, availability and scheduling may effect this item

System Requirements:

1.5 GHz, 512 meg RAM, 1 gig disk space.

Tested on Windows XP Professional. Course software should be viable on all systems which support a Java 6 Developer's Kit.

Learning Objectives

• Chiefly, learn to program effectively in the Java language.
• Understand the Java software architecture, and the design decisions which make Java software portable, efficient, secure and robust.
• Learn how to configure a simple Java development environment.
• Know the grammar, data types and flow control constructs of the Java language for simple procedural programming.
• Understand Java as a purely object-oriented language, and implement software as systems of classes.
• Implement and use inheritance and polymorphism, including interfaces and abstract classes.
• Design appropriate exception handling into Java methods, and use the logging API appropriately.
• Understand the structure of streams in Java, and learn how to use streams to manage file I/O.
• Learn how to use Java Serialization to internalize and externalize potentially complex graphs of objects.
• Build unit tests for Java classes using JUnit.

Timeline:

• 5 days for those experienced in procedural programming
• 4 days for C/C++ programmers

Chapter 1. The Java Environment

• Overview of Architecture
• Forms for Java Software
• J2SE, J2EE, and J2ME Platforms
• Java Virtual Machine
• The Core API
• Java Runtime Environment
• Java Developer's Kit
• Java Class Path
• Classes
• Built-In Streams and Command-Line Parameters

Chapter 2. Language Fundamentals

• Source File Format
• Application Classes
• Code Grammar and Expressions
• Identifiers
• Literals
• Operators
• Calling Methods
• Variable Parameter Lists ("varargs")

Chapter 3. Data Types

• Strict Type Checking
• Primitive Types
• Numeric Types
• Characters and Booleans
• Enumerations
• Type Conversion
• Formatted Output
• Object References
• Comparing and Assigning References
• Strings
• Arrays

Chapter 4. Flow Control

• The main Method
• Calling and Returning from Methods
• Conditional Constructs
• Looping Constructs
• Processing Arrays
• Looping and Enumerations
• Processing Varargs
• The Flow-Control Operator
• Break and Continue
• Recursion

Chapter 5. Object-Oriented Software

• Complex Systems
• Abstraction
• Classes and Objects
• Responsibilities and Collaborators
• UML
• Relationships
• Visibility

Chapter 6. Classes and Objects

• Java Classes
• Constructors and Garbage Collection
• Naming Conventions and JavaBeans
• Relationships Between Classes
• Using this
• Visibility
• Packages and Imports
• Overloading Methods and Constructors
• JARs

Chapter 7. Inheritance and Polymorphism in Java

• UML Specialization
• Extending Classes
• Using Derived Classes
• Type Identification
• Compile-Time and Run-Time Type
• Polymorphism
• Overriding Methods
• The @Override Annotation
• Superclass Reference

Chapter 8. Using Classes Effectively

• Class Loading
• Static Members
• Statics and Non-Statics
• Static Initializers
• Static Imports
• Prohibiting Inheritance
• Costs of Object Creation
• Strings and StringBuffers
• Controlling Object Creation
• Understanding Enumerated Types
• Stateful and Behavioral Enumerations

Chapter 9. Interfaces and Abstract Classes

• Separating Interface and Implementation
• UML Interfaces and Realization
• Defining Interfaces
• Implementing and Extending Interfaces
• Abstract Classes

Chapter 10. Collections

• Dynamic Collections vs. Arrays
• UML Parameterized Type
• Generics
• Using Generics
• The Collections API
• The Collection<E> and List<E> Interfaces
• The ArrayList<E> and LinkedList<E> Classes
• Looping Over Collections: Iterable<E>
• Collecting Primitive Values: Auto-Boxing
• Using Wildcards with Generic Types
• Iterators and the Iterator<E> Interface
• Maps and the Map<K,V> Interface
• Sorted Collections
• The SortedSet<E> and SortedMap<K,V> Interfaces
• The Collections Class Utility
• Algorithms
• Conversion Utilities

Chapter 11. Exception Handling and Logging

• Reporting and Trapping Errors
• Exception Handling
• Throwing Exceptions
• Declaring Exceptions per Method
• Catching Exceptions
• The finally Block
• Catch-and-Release
• Chaining Exceptions
• The J2SE Logging API
• Severity Levels
• Log Hierarchies

Chapter 12. Inner Classes

• Passing Behavior
• Inner Classes in GUI Programming
• Named Inner Classes
• Outer Object Reference
• Static Inner Classes
• Anonymous Inner Classes

Chapter 13. The Java Streams Model

• Delegation-Based Stream Model
• InputStream and OutputStream
• Media-Based Streams
• Filtering Streams
• Readers and Writers

Chapter 14. Working with Files

• File Class
• Modeling Files and Directories
• File Streams
• Random-Access Files

Chapter 15. Advanced Stream Techniques

• Buffering
• Data Streams
• Push-Back Parsing
• Byte-Array Streams and String Readers and Writers

Chapter 16. Java Serialization

• The Challenge of Object Serialization
• Serialization API
• Serializable Interface
• ObjectInputStream and ObjectOutputStream
• The Serialization Engine
• Transient Fields
• readObject and writeObject
• Externalizable Interface

Chapter 17. Automated Unit Testing with JUnit

• Automated Testing
• JUnit and Related Tools
• The @Test Annotation
• The Assert Class Utility
• Test Runners
• Lifecycle Methods