Java Specialists' Java Training Europehome of the java specialists' newsletter

The Java Specialist Master Course Outline

Finishing School for the Professional Java Programmer

The Java Specialist Master Course
The Java Specialist Master Course
Imagemap
1. IntroductionWelcome!Course organizationCourse contentsCourse overview2. Multi-ThreadingBasics of ThreadsThreading BackgroundThreading ModelsProcess vs threadParallel vs concurrentCreating NewThread GroupsStatesSynchronizedLocksPrioritiesTimersDaemon ThreadsThe Secrets of ConcurrencyInterrupted StatusWhat threads are doingLimiting # of ThreadsVisibility ProblemsEarly WritesCorrupt DataContentionJava Memory ModelHardware impactDeadlocksApplied Threading TechniquesExecutorsCount-down latchSemaphoreBlocking queuesAtomic VariablesVolatileExceptionsThread local variablesStopping ThreadsShutdown hooksThreading ProblemsRace ConditionsStarvationFairnessDeadlockLivelock3. Java IOObject Streams and SerializationObject SerializationSimple Object SerializationSerializable FieldsreadObject() / writeObject()Controlling SerializationExternalizableSerial Object VersioningCompatible Class ChangesIncompatible Class ChangesOverriding VersioningCircular ReferencesSerialization PerformanceSerialization PitfallsResetting StreamsJava New IO PackageMotivation for UsingWorking with BuffersAllocating BuffersBuffers AdvantagesChannelsMemory Mapped FilesNon-Blocking OperationsSelectorsNIO UsesEvent Driven ArchitectureCharacter Streams EncodingThe Unicode StandardForms of Unicode32-bit CharactersBig / Little EndianOther EncodingsOther Charsets - ISO 8859Charset ClassEncoders and DecodersCode Points4. Java MemoryGarbage CollectionOverviewGenerational SpacesGC TasksHeap FragmentationGC Pros and ConsAlgorithmsReachabilityHistoryJVM 1.4, 5, 6Young SpaceOld SpaceSummaryMeasuring GC ActivityPerformanceObject SizeUsing jConsoleManaging OutOfMemoryErrorTuning JVMJVM SwitchesNon-Standard SwitchesSizing Generational SpacesReferencesReference ObjectsObject ReachabilityUsing ReferencesSoftReferenceWeakReferencePhantomReferenceAbstractingReferenceQueueWeakHashMapSoftHashMapPerformance ImplicationsObject PoolingIntroductionReasons for not UsingThread PoolingDatabase Connection Pooling5. Reflection APIOverviewIntroductionUsefulness of ReflectionDangers of ReflectionExamining ClassesReflection PackageRetrieving Class ObjectsWorking with Class ObjectsAccessing fieldsAccessing methodsGenericsManipulating ObjectsWorking with objectsCreating new objectsGetting and Setting FieldsInvoking MethodsCasting through ReflectionFinal fieldsArraysWorking with ArraysElements' TypeCreating new ArraysGetting and Setting ElementsDynamic Proxy ClassesProxy DefinitionCreating new ProxyInvocationHandlerProxy ClassClassesWhen are Classes Loaded?How loadClass() worksImplementing own ClassLoaderThe defineClass Method6. Data StructuresBasicsIntroductionAbstract ClassesAlgorithm ComplexityData Structures & GCPrimitive Data StructuresNull ElementsType SafetyIterationIteratorsEfficiencyRandomAccessMultithreadingConcurrentModificationCopyOnWrite CollectionsNew "for-each" iterationIterable interfaceSortingCollections & ArraysSorting PerformanceComparisonsMapsTreesHashingJDK 1.4+ rehashingCompound KeysMap of MapsConcurrentHashMapLinked MapsSearchingGenericsOther StructuresMultimapQueuesDequesHeapsLRU Cache7. ExceptionsError HandlingClass HierarchyThrowable ClassException ClassError ClassStackTraceElementAbuse of ExceptionsUncaught ExceptionsAsynchronous ExceptionsCritical Errors Inside the JVMBest PracticesChecked vs. UncheckedAvoid Custom ExceptionsWriting Good ExceptionsWrap Low Level ExceptionsAvoid Catching "Programmer Bug" ExceptionsChain ExceptionsAvoid Swallowing ExceptionsCleanup After An ExceptionNever Abuse Exceptions for Flow ControlThrow Exceptions EarlyCatch Exceptions LateGood Throws ClausesDocument ExceptionsUnit Test ExceptionsAssertionsMechanism"assert" StatementDetecting if enabledWhen to UseWhen Not to UseJVM switchesWhy disable?Performance Issues8. Java OptimizationsLow LevelOverviewHigh LevelLow LevelWhen Not to UseMicrobenchmarkingFinding bottlenecksOptimization TechniquesOther OptimizationsCompilerRuntimeJust-in-TimeHotSpotProblem AreasTypical Problem AreasMethods DeclarationsObject CreationStrings and constantsLoopsBenchmarkingClass CastingGenericsOther AreasToolsProfiling ToolsHPROFHow to tune9. Dates and Time ZonesComputer TimeTime SynchronizationHuman Time InterpretationComputer SettingTime in JavaIntroductionjava.util.Datejava.util.TimeZonejava.util.Calendarjava.util.GregorianCalendarjava.util.DateFormatjava.sql.Datejava.sql.TimestampBest practices10. LoggingOverviewWhy log?Principal RequirementsMain Logging APIsJakarta Commons LoggingLog4j APIBuilding BlocksLoggerAppenderLayoutPrinciplesLogger HierarchyLevel InheritanceAppenders AdditivityConfigurationFrom ApplicationFrom XML FileBest PracticesDefining Logging SchemeLogging LevelsLog Messages FormatCentralized LoggingCode GuardsExceptionsReviewing LoggingImpact on PerformanceUnecessary StringsWriting to DiskAsynchronous Logging

The Java "Specialist" Course lasts 4 days.

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

Each days training starts at 9:00am 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

Make Enquiry

 


1. Course Overview 2. Course Outline
Extreme Java - Concurrency and Performance for Java 8
Extreme Java - Advanced Topics for Java 8
Design Patterns
In-House Courses

© 2010-2016 Heinz Kabutz - All Rights Reserved Sitemap
Oracle and Java are registered trademarks of Oracle and/or its affiliates. Other names may be trademarks of their respective owners. JavaSpecialists.eu is not connected to Oracle, Inc. and is not sponsored by Oracle, Inc.