Running on Java 24-ea+24-2960 (Preview)
Home of The JavaSpecialists' Newsletter

Extreme Java - Advanced Topics Course

Finishing School for the Professional Java Programmer

Using Java 21

Duration of 2 Days


During this 2-day course, we will study over 300 slides of advanced Java topics. Each major section is followed by practical hands-on exercises to apply what you have learned. Even the most experienced Java programmer will be stimulated and challenged.

This course is ideally suited to the professional Java programmer with at least 2 years experience, who would like to learn how to truly master the Java Programming Language.

Is this course for you?

If you answer "yes!" to any of these questions, then this course is for you:

  • Would you like to learn some advanced techniques for writing Java code?
  • Would you like to understand Java NIO?
  • Would you like to understand the intricacies of Java memory, including tips on how to diagnose problems?
  • Have you ever wondered what possibilities exist in the reflection API?
  • Or wondered what data structures would be best suited to your application?
  • Or looked for better ways of managing exceptions?

"This course embodies my Java knowledge and experience gained publishing 250+ advanced Java newsletters, teaching hundreds of seminars and writing hundreds of thousands of lines of Java code."
Heinz Kabutz, The Java Specialists Newsletter

Extreme Java - Advanced Topics Course Enquiry


Prerequisites

This course is ideally suited to the professional Java programmer with at least 2 years experience, who would like to learn how to program advanced core Java.

  • Previous Training: Design Patterns Course (Recommended).
  • Required Experience: At least two years of professional Java programming.

Pricing Options

We have several options for you to join this course:

1. Virtual In-house Course:

Presented via video conference to your team of programmers by the author of the course. Price is €5500 for up to 10 students, above that is an additional €500 per student.

  • Example 1: Course with 8 students taught remotely via video conference, price is €5500. Price per student is €687.
  • Example 2: Course with 12 students taught remotely via video conference, price is €6500. Price per student is €541.
  • Example 3: Course with 24 students taught remotely via video conference, price is €12500. Price per student is €520.

Please contact us if you have any questions.

2. In-person In-house Course:

Presented at your company in-person by one of our Certified JavaSpecialist Instructors. Price is €8100 for up to 10 students, above that is an additional €810 per student, plus the travel expenses of the instructor. Note that for in-person in-house courses, we need a minimum of three consecutive training days.

  • Example 1: Course with 8 students taught on-site at your company, price is €8100. Price per student is €1012.
  • Example 2: Course with 12 students taught on-site at your company, price is €9720. Price per student is €810.
  • Example 3: Course with 18 students taught on-site at your company, price is €14580. Price per student is €810.

Please contact us if you have any questions.

2. Open Enrollment Classroom Course:

We occasionally offer this course as a classroom course in Chania on the Island of Crete. Price for the course is €1749 per student.

We also offer this course as an open enrollment live remote course that you can attend from anywhere. Price is €1189 per student.

Please contact us if you have would like to make a booking or if you have any questions.

4. Self-Paced Course:

This course is also available as a self-paced course.

Please contact us if you have any questions.

* Prices exclude EU VAT and withholding taxes where applicable. Please contact us for an exact quote for your country.

Open Courses

All our courses are offered as in-house courses. Please contact us on heinz@javaspecialists.eu.

* Price is excluding EU VAT where applicable. Please contact us for an exact quote for your country.

Detailed Outline

Extreme Java - Advanced Topics
Extreme Java - Advanced Topics
Imagemap
1. IntroductionWelcome!Course organizationCourse overview2. Java IOObject Streams and SerializationObject SerializationSimple Object SerializationSerializable FieldsResetting StreamsreadObject() / writeObject()Controlling SerializationSerial Object VersioningOverriding VersioningSerialization PerformanceSerialization PitfallsJava New IO PackageMotivation for UsingWorking with BuffersAllocating BuffersBuffers AdvantagesChannelsMemory Mapped FilesNon-Blocking Operations3. Java MemoryGarbage CollectionOverviewGenerational SpacesGC TasksHeap FragmentationEscape AnalysisGC Pros and ConsMeasuring GC ActivityPerformanceObject SizeTuning JVMPerformance TuningMemory LeaksLoitering ObjectsObject ChurnHeap SizingFinalizersHow it worksPerformance ImplicationsOther references4. Reflection APIOverviewIntroductionUsefulness of ReflectionDangers of ReflectionExamining ClassesReflection PackageRetrieving Class ObjectsWorking with Class ObjectsAccessing fieldsAccessing methodsManipulating ObjectsCreating new objectsGetting and Setting FieldsFinal fieldsInvoking MethodsWorking with Arrays5. Data StructuresTime ComplexityAlgorithm ComplexityExamples from JavaIterationIterators"for-each" iterationIterable interfaceConcurrentModificationCopyOnWrite CollectionsHashingHow Hashing WorksJDK 1.4+ rehashingCompound KeysLinked MapsSortingDefining Natural OrderComparatorsTreesQueuesQueuesPriorityQueueBlockingQueueDeques6. ExceptionsError HandlingClass HierarchyException ClassError ClassBest PracticesChecked vs. UncheckedAvoid Custom ExceptionsWriting Good ExceptionsWrap Low Level ExceptionsAvoid Catching "Programmer Bug" ExceptionsPerformance of ExceptionsChain ExceptionsAvoid Swallowing ExceptionsCleanup After An ExceptionJava 7 try-with-resourceLosing an Exception in finallyNever Abuse Exceptions for Flow ControlThrow Exceptions EarlyCatch Exceptions LateGood Throws ClausesDocument ExceptionsUnit Test ExceptionsAssertionsMechanism"assert" StatementWhen to UseWhen Not to UseJVM switches7. Dates and Time ZonesComputer TimeTime SynchronizationHuman Time InterpretationTime in JavaIntroductionjava.util.DateJSR310 vs Joda Timejava.util.TimeZonejava.util.DateFormat8. LoggingOverviewWhy log?Principal RequirementsMain Logging APIsBest PracticesDefining Logging SchemeLogging LevelsLog Messages FormatCentralized LoggingCode GuardsExceptionsReviewing LoggingImpact on PerformanceUnecessary StringsWriting to DiskAsynchronous Logging9. ConclusionWhere to next?Never stop learning!

The "Extreme Java - Advanced Topics" Course lasts 2 days.

We spend approximately 50% 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.


  • 1. Introduction
    • Welcome!
    • Course organization
    • Course overview

  • 2. Java IO
    • Object Streams and Serialization
      • Object Serialization
      • Simple Object Serialization
      • Serializable Fields
      • Resetting Streams
      • readObject() / writeObject()
      • Controlling Serialization
      • Serial Object Versioning
      • Overriding Versioning
      • Serialization Performance
      • Serialization Pitfalls
    • Java New IO Package
      • Motivation for Using
      • Working with Buffers
      • Allocating Buffers
      • Buffers Advantages
      • Channels
      • Memory Mapped Files
      • Non-Blocking Operations

  • 3. Java Memory
    • Garbage Collection
      • Overview
      • Generational Spaces
      • GC Tasks
      • Heap Fragmentation
      • Escape Analysis
      • GC Pros and Cons
      • Measuring GC Activity
      • Performance
        • Object Size
    • Tuning JVM
      • Performance Tuning
      • Memory Leaks
      • Loitering Objects
      • Object Churn
      • Heap Sizing
    • Finalizers
      • How it works
      • Performance Implications
      • Other references

  • 4. 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
    • Manipulating Objects
      • Creating new objects
      • Getting and Setting Fields
      • Final fields
      • Invoking Methods
      • Working with Arrays

  • 5. Data Structures
    • Time Complexity
      • Algorithm Complexity
      • Examples from Java
    • Iteration
      • Iterators
      • "for-each" iteration
      • Iterable interface
      • ConcurrentModification
      • CopyOnWrite Collections
    • Hashing
      • How Hashing Works
        • JDK 1.4+ rehashing
      • Compound Keys
      • Linked Maps
    • Sorting
      • Defining Natural Order
      • Comparators
      • Trees
    • Queues
      • Queues
        • PriorityQueue
        • BlockingQueue
      • Deques

  • 6. Exceptions
    • Error Handling
      • Class Hierarchy
      • Exception Class
      • Error Class
    • Best Practices
      • Checked vs. Unchecked
      • Avoid Custom Exceptions
      • Writing Good Exceptions
      • Wrap Low Level Exceptions
      • Avoid Catching "Programmer Bug" Exceptions
      • Performance of Exceptions
      • Chain Exceptions
      • Avoid Swallowing Exceptions
      • Cleanup After An Exception
        • Java 7 try-with-resource
      • Losing an Exception in finally
      • Never Abuse Exceptions for Flow Control
      • Throw Exceptions Early
      • Catch Exceptions Late
      • Good Throws Clauses
      • Document Exceptions
      • Unit Test Exceptions
    • Assertions
      • Mechanism
      • "assert" Statement
      • When to Use
      • When Not to Use
      • JVM switches

  • 7. Dates and Time Zones
    • Computer Time
      • Time Synchronization
      • Human Time Interpretation
    • Time in Java
      • Introduction
      • java.util.Date
      • JSR310 vs Joda Time
      • java.util.TimeZone
      • java.util.DateFormat

  • 8. Logging
    • Overview
      • Why log?
      • Principal Requirements
      • Main Logging APIs
    • 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

  • 9. Conclusion
    • Where to next?
    • Never stop learning!


About the Author

Heinz Kabutz Java Conference Speaker

Java Champion, author of the Javaspecialists Newsletter, conference speaking regular... About Heinz

Superpack '23

Superpack '23 Our entire Java Specialists Training in one huge bundle more...

Free Java Book

Dynamic Proxies in Java Book

110% Money-back Guarantee

Should you not be satisfied with the quality of the training or the delivery, we will gladly refund you 100% of the course fees. This needs to be brought to our attention within the first 4 hours of the course and a chance should be given to correct whatever you are not satisfied with. If you are still not satisfied, we will refund you 100% of the course fees, plus we will pay our own travel expenses. The training material then remains the property of JavaSpecialists.EU.


Cancellation Policy

If the course is cancelled more than two weeks before the start of the course, a 10% cancellation fee of the fees will apply, plus any non-refundable travel expenses incurred by the trainer.

If the course is cancelled within two weeks of the start of the course, a 50% cancellation fee of the fees will apply, plus any non-refundable travel expenses incurred by the trainer.

No refund will be given to cancellations during the course.


Java Training

We deliver relevant courses, by top Java developers to produce more resourceful and efficient programmers within their organisations.

Java Consulting

We can help make your Java application run faster and trouble-shoot concurrency and performance bugs...