The Java Specialist Master Course - Course Outline

Finishing School for the Professional Java Programmer

The Java Specialist Master Course

The Java "Specialist" Course lasts 4 days.

We spend approximately 43% doing active hands-on labs.

Each days training starts at 8:30am and ends at 17:00, with about one hour of lunch and 30 minutes of tea / coffee / nicotene breaks.

Day 1:

Introduction: 0h
Multi-Threading: 4h lectures, 3h labs

Day 2:

Java IO: 2h lectures, 1.5h labs
Java Memory: 2h lectures, 1.5h labs

Day 3:

Reflection: 1h lectures, 45m labs
Data Structures: 2h lectures, 1.5h labs
Exceptions: 1h lectures, 45m labs

Day 4:

Java Optimizations: 2h lectures, 1.5h labs
Dates & Time Zones: 1h lectures, 45m labs
Logging: 1h lectures, 45m labs
Conclusion: 0h

Total lecturing: 16 hours

Total labs: 12 hours

1. Introduction

Welcome!

Course organization

Course contents

Course overview

2. Multi-Threading

Basics of Threads

Threading Background

Threading Models

Process vs thread

Parallel vs concurrent

Creating New

Thread Groups

States

Synchronized

Locks

Priorities

Timers

Daemon Threads

The Secrets of Concurrency

Interrupted Status

What threads are doing

Limiting # of Threads

Visibility Problems

Early Writes

Corrupt Data

Contention

Java Memory Model

Hardware impact

Deadlocks

Applied Threading Techniques

Executors

Count-down latch

Semaphore

Blocking queues

Atomic Variables

Volatile

Exceptions

Thread local variables

Stopping Threads

Shutdown hooks

Threading Problems

Race Conditions

Starvation

Fairness

Deadlock

Livelock

3. Java IO

Object Streams and Serialization

Object Serialization

Simple Object Serialization

Serializable Fields

readObject() / writeObject()

Controlling Serialization

Externalizable

Serial Object Versioning

Compatible Class Changes

Incompatible Class Changes

Overriding Versioning

Circular References

Serialization Performance

Serialization Pitfalls

Resetting Streams

Java New IO Package

Motivation for Using

Working with Buffers

Allocating Buffers

Buffers Advantages

Channels

Memory Mapped Files

Non-Blocking Operations

Selectors

NIO Uses

Event Driven Architecture

Character Streams Encoding

The Unicode Standard

Forms of Unicode

32-bit Characters

Big / Little Endian

Other Encodings

Other Charsets - ISO 8859

Charset Class

Encoders and Decoders

Code Points

4. Java Memory

Garbage Collection

Overview

Generational Spaces

GC Tasks

Heap Fragmentation

GC Pros and Cons

Algorithms

Reachability

History

JVM 1.4, 5, 6

Young Space

Old Space

Summary

Measuring GC Activity

Performance

Object Size

Using jConsole

Managing OutOfMemoryError

Tuning JVM

JVM Switches

Non-Standard Switches

Sizing Generational Spaces

References

Reference Objects

Object Reachability

Using References

SoftReference

WeakReference

PhantomReference

Abstracting

ReferenceQueue

WeakHashMap

SoftHashMap

Performance Implications

Object Pooling

Introduction

Reasons for not Using

Thread Pooling

Database Connection Pooling

5. Reflection API

Overview

Introduction

Usefulness of Reflection

Dangers of Reflection

Examining Classes

Reflection Package

Retrieving Class Objects

Working with Class Objects

Accessing fields

Accessing methods

Generics

Manipulating Objects

Working with objects

Creating new objects

Getting and Setting Fields

Invoking Methods

Casting through Reflection

Final fields

Arrays

Working with Arrays

Elements' Type

Creating new Arrays

Getting and Setting Elements

Dynamic Proxy Classes

Proxy Definition

Creating new Proxy

InvocationHandler

Proxy Class

Classes

When are Classes Loaded?

How loadClass() works

Implementing own ClassLoader

The defineClass Method

6. Data Structures

Basics

Introduction

Abstract Classes

Algorithm Complexity

Data Structures & GC

Primitive Data Structures

Null Elements

Type Safety

Iteration

Iterators

Efficiency

RandomAccess

Multithreading

ConcurrentModification

CopyOnWrite Collections

New "for-each" iteration

Iterable interface

Sorting

Collections & Arrays

Sorting Performance

Comparisons

Maps

Trees

Hashing

JDK 1.4+ rehashing

Compound Keys

Map of Maps

ConcurrentHashMap

Linked Maps

Searching

Generics

Other Structures

Multimap

Queues

Deques

Heaps

LRU Cache

7. Exceptions

Error Handling

Class Hierarchy

Throwable Class

Exception Class

Error Class

StackTraceElement

Abuse of Exceptions

Uncaught Exceptions

Asynchronous Exceptions

Critical Errors Inside the JVM

Best Practices

Checked vs. Unchecked

Avoid Custom Exceptions

Writing Good Exceptions

Wrap Low Level Exceptions

Avoid Catching "Programmer Bug" Exceptions

Chain Exceptions

Avoid Swallowing Exceptions

Cleanup After An Exception

Never Abuse Exceptions for Flow Control

Throw Exceptions Early

Catch Exceptions Late

Good Throws Clauses

Document Exceptions

Unit Test Exceptions

Assertions

Mechanism

"assert" Statement

Detecting if enabled

When to Use

When Not to Use

JVM switches

Why disable?

Performance Issues

8. Java Optimizations

Low Level

Overview

High Level

Low Level

When Not to Use

Microbenchmarking

Finding bottlenecks

Optimization Techniques

Other Optimizations

Compiler

Runtime

Just-in-Time

HotSpot

Problem Areas

Typical Problem Areas

Methods Declarations

Object Creation

Strings and constants

Loops

Benchmarking

Class Casting

Generics

Other Areas

Tools

Profiling Tools

HPROF

How to tune

9. Dates and Time Zones

Computer Time

Time Synchronization

Human Time Interpretation

Computer Setting

Time in Java

Introduction

java.util.Date

java.util.TimeZone

java.util.Calendar

java.util.GregorianCalendar

java.util.DateFormat

java.sql.Date

java.sql.Timestamp

Best practices

10. Logging

Overview

Why log?

Principal Requirements

Main Logging APIs

Jakarta Commons Logging

Log4j API

Building Blocks

Logger

Appender

Layout

Principles

Logger Hierarchy

Level Inheritance

Appenders Additivity

Configuration

From Application

From XML File

Best Practices

Defining Logging Scheme

Logging Levels

Log Messages Format

Centralized Logging

Code Guards

Exceptions

Reviewing Logging

Impact on Performance

Unecessary Strings

Writing to Disk

Asynchronous Logging

Enquire

	© 2007 Heinz Kabutz - All Rights Reserved	Sitemap		seo web design Catch22 Marketing