Generics

Given that a foo is a bar, why is a foo collection not a bar collection?

In Java, while arrays are covariant, collections are invariant. For example, given that a Foo is a Bar, while we have a Foo[] is a Bar[], we do not have that a Collection<Foo> is a Collection<Bar>. This implies that we cannot pass in a Collection<Foo> where a Collection<Bar> is needed. Why?

Explicit type parameters for generic methods

Generic methods provide a great convenience that the compiler does the type inference on them. In most cases, we can call a generic method without specifying actual types for the type parameters. However, there are some cases the type inference does not work. In these cases, we need to specify explicit type parameters.

Curiously recurring template pattern and visitor implementation in C++/Java

The curiously recurring template pattern (CRTP) is a C++ programming idiom that powers the static polymorphism, the policy-based design and many other metaprogramming techniques. Here we try to apply CRTP to Java, implementing the visitor pattern in a similar way to a C++ implementation. We compare the behavior between the implementation, and explain how the differences in behavior could be understood in terms of the differences between C++ templates and Java generics.