C++
    RELIABLE C++
    EFFECTIVE STL
    TEMPLATES
    EXCEPTIONS
    IOSTREAMS
    C++ FOR C
    C++ FOR JAVA
    C++ INTRO   
 

This is a best-practice seminar for Java programmers who want to explore Java in greater depth. It is best attended after some initial exposition to Java. 

Java was marketed to the software development community as a simple and easy-to-use programming language.  In practice it turned out that even this supposedly easy language has its traps and pitfalls, has less commonly known advanced language features, and has Java-specific programming idioms that are not evident from just the language features. 

This advanced seminar takes an in-depth look at some of the core concepts of the Java programming language:

Implementing classes correctly, including supposedly trivial infrastructure such as equals() and clone() . 

Support for release of resources (other than memory) is not ideal in Java; the seminar explains Java's support for initialisation and finalisation.

Advanced language features such as dynamic proxies, anonymous inner classes and weak references. 

Java-specific programming idioms, such as the immutability adapters, the support-class idiom, and function-like objects.

If you want to stay ahead of your time and keep your knowledge above average, then this is the right course for you.

This is a course for Java programmers who want to explore Java in greater depth and is best attended after some initial exposition to Java. In this advanced Java seminar we aim to provide in-depth information about the core of the Java programming language. For development of  industrial strength software semantic correctness of classes and methods, proper release of resources, and a sound knowledge of advanced Java programming idioms are important. The courses are designed to build on existing expertise as Java programmers and take your skills one step further. Prerequisite for these seminars is at least 1 year of experience with Java or equivalent knowledge. 
 

PERFORMANCE OBJECTIVES

	Learn how to build industrial strength software in Java
	Know what to expect of Java
	Avoid common errors in Java
	Understand best-practice Java idioms

BUSINESS OBJECTIVES

	Equip your software professionals with industrial-strength Java skills
	Make your Java software more reliable
	Get the most out of Java

The course is designed by Klaus Kreft & Angelika Langer and backed by years of experience in teaching  Java and C++ related topics and more than a decade of real-world experience in industrial software development both in C++ and Java.
Angelika Langer is a freelance trainer/mentor in the area of object-oriented software development in C++ and Java. She is a recognized author and speaker at OO conferences worldwide. 
Klaus Kreft is a senior consultant for more than 15 years and has served as the lead architect on several successful industry projects. He has been working in C++ for many year and works in Java since 1995. He is a regular speaker at OO conferences in Germany.

Together they wrote columns for C+ Report and C/C++ Users Journal,  are authors of the  book "Standard C++ IOStreams and Locales". They  publish articles on C++ and Java topics in various computer magazines worldwide, including the column "Effective Java" in the German JavaSpektrum magazine.  In addition they wrote the widely appreciated "Java Generics FAQ" , an online resource discussing generic and parameterized types in Java.

• Construction & Initialization
• Destruction vs. Finalization

• Object Equality (Implementing equals() )
• Hashing Objects (Implementing hashCode() )
• Comparing Objects (Implementing compareTo () )
• Copying Objects (Implementing clone() )

• Immutability (final + constness)
• Immutability in Java
• The Dual Class Idiom
• Function Redefinition (final + polymorphism)
• Principles of Method Overlodas Resolution
• Pitfalls In Using Overloading and Overriding

• The abstract Language Feature
• Idioms for Use of Abstract Classes and Interfaces
• Express Common Behavior via Interfaces
• Generic Programming via Interfaces
• Abstract Classes for Default Implementation
• Multiple Inheritance

• finally and the Control Flow
• Problems With The throws Clause
• Hiding of Exceptions
• Object Integrity  and Resource Leaks

• Language Features
• Nested Top-Level Classes and Interfaces
• Member Classes
• Local Classes
• Anonymous Classes
• Idioms for Use of Inner Classes
• Namespace and Access Scope Management 
• Function Objects
• Interfaces
• Callbacks

• Java Type System and the Reflection API
• Static vs. Dynamic Typing
• Class Related Information
• The Reflecion API
• Dynamic Proxies
• Class Proxy and the Invocation Handler
• Sample Usages of Proxies in Practice
• Generic Pre-/Post-Processing
• Class Extensions 
• Annotations and Meta Data
• Declaring Annotation Types
• Annotating Program Elements
• Standard Annotations
• Processing Annotations

• Autoboxing
• Static Import
• For-Each Loop
• Variable Argument List
• Enumeration Types
• Syntax and Byte Code Representation
• Usage Patterns
• Pitfalls

• Syntax and Byte Code Representation (Type Erasure)
• Wildcards
• Raw Types and Compatibility
• Pitfalls In Using Parameterized Types
• Pitfalls In Using Type Variables
• Usage Patterns and Programming Idioms
• Type Argument Inferencence
• Overriding and Overloading of Generic Methods
• Generics and Reflection
• Pitfalls and Surprises

• Features
• Reachability
• The Superclass Reference
• Soft References
• Weak References
• Phantom References
• Reference Queues
• Idioms Using Soft, Weak, and Phantom References
• Avoid Unwanted References
• Implement Caches
• Post-Mortem Processing

• Principles of Garbage Collection
• Reference Counting
• Mark-and-Sweep
• Mark-and-Compact
• Mark-and-Copy
• Generational Garbage Collection
• Parallel and Concurrent Garbage Collection
• Profiling (with GCViever)
• Tuning the Garbage Collector (Sun JVM)

• Classic Collection Support 
• Enumeration
• Dictionary, Hashtable, Stack, Vector
• Built-In Arrays
• Collection Framework
• The Interfaces
• The Implementations
• Algorithms
• User-Defined Collections
• Generic Collections 

• Default Serialization
• Custom Serialization
• Object Stream Support

• Class Loader Basics
• Class Loader Relationships
• Custom Class Loader

• Calling Native Functions from Java
• Implementing native Methods
• Function Names and Type Mapping
• JNI Interface Functions
• Parameter Passing and Field Access
• Calling Java from Native Code
• Java Exceptions in Native Code
• Local and Global References
• Starting a VM - The Invocation API