Session 1: Review - Getting Started
Writing and Running Java programs
Setting up and Using the Development Environment
Session 2: Review - Class and Object
Creating classes with fields and methods
Encapsulation and access protection
Constructors
Other Capabilities (Static Members, null, final, Wrapper Classes
Session 3: Review - Control Flow, String, and Array
Flow of Control
Strings
Arrays
Session 4: Review - Packages
Using packages to organize code
Using import
Creating Packages
Package Organization and Classpath
LABS:
Using Packages to Organize Code
Session 5: Composition and Inheritance
Using Composition to Deal With Complexity
Composition/HAS-A, Delegation
Using Inheritance and Polymorphism to share commonality
IS-A, extends, Inheriting Features, Overriding Methods, Using Polymorphism
Class Object
Abstract Classes
LABS:
(Optional) Working with Composition
Using Inheritance to Specialize Classes
Session 6: Interfaces
Programming by Contract
Using Interfaces to Define Types
Interfaces and Polymorphism
LABS:
Using Interfaces to Remove Implementation Dependencies
Session 7: Exceptions and Error Handling
Exceptions
Exception Hierarchy
try and catch
Handling Exceptions
Program Flow with Exceptions
Finally
LABS:
Handle Exceptions
Define Exception Class
Session 8: Collections and Generics
The Collections Framework
Collection Interfaces
Collection, Set, List, Map, Iterator
Generics (Java 5)
Processing Items With an Iterator
for-each Loop (Java 5)
Using ArrayList
Using HashMap
More About Generics (Inheritance, Wildcards, Assignment)
LABS:
Using Collections
Session 9: JDBC and the JPA
JDBC Overview and Architecture
JDBC Connections, Statements, and Queries
Introduction to JPA (Java Persistence API)
Object-Relational Mapping (ORM) and JPA Architecture
Entity Class Introduction
Mapping Entity classes with @Entity, @Id, @Table, and more
Persistence Units, persistence.xml, the EntityManager and EntityManagerFactory
Using JPA to Work with Persistence Entities
JPQL and Querying with JPA
LABS:
Mapping a Simple Class
Using JPA to Access Persistent Entities
Inserting, Querying, and Other Capabilities
Session 10: Additional Java Features
Assertions
Type-safe Enums
Annotations
Session 11: I/O Streams
Readers and Writers
Filter Streams
InputStreams and OutputStreams
Converting Between Streams and Readers/Writers
New I/O (NIO) APIs
LABS:
Formatting with Java I/O
Session 12: Inner Classes
Why Use Inner Classes?
Named Inner Classes
Static Inner Classes
Anonymous Inner Classes
LABS:
Using Named Inner Classes
Using Anonymous Inner Classes
Session 13: Reflection
The class called Class
Finding Fields, Methods, and Constructors
Accessing Fields, Invoking Methods
Examining Arrays
LABS:
Examining Objects Using Reflection
Accessing Fields and Invoking Methods via Reflection
Session 14: Introduction to ant
ant Overview, Installing and Running ant
Buildfiles, Projects, Targets, Tasks, Properties
Creating Build Files
Paths(e.g. CLASSPATH, PATH)
Resource Collections - FileSets, DirSets, Files, PatternSets
LABS:
Running ant
Creating and Using Buildfiles
Using Basic ant Tasks
Session 15: maven Overview
Introduction and Installation
Maven Concepts and the POM (pom.xml>
Dependencies and Repositories
Using maven to build Java projects
LABS:
Using maven
Session 16: JUnit Basics
JUnit Overview, Test Driven Development
Tests and Assertions
Working With Exceptions
LABS:
Writing and Running Tests
Testing Exceptions
Session 17: Organizing Tests with JUnit
Writing Fixtures - @Before, @After
Test Suites, and Other Capabilities
Mock Objects
LABS:
Using Fixtures
Using Suites
Session 18: Introduction to Logging and log4j
Logging Overview
log4j Overview
Loggers, Appenders, Layouts
Configuring and Using log4j
Logger Hierarchy and Logging Levels
Working With Appenders
Using PatternLayout
Other Logging Frameworks (Java Logging, Apache Commons Logging)
LABS:
Setting Up log4j
Using Basic log4j Logging
Working With Loggers
Working With Appenders
Using Layouts