anchor.diff:  annotation nodes that will be added to the node annotated with the meta-annotation. In this example, we return a
   single one corresponding to `@CompileStatic(TypeCheckingMode.SKIP)`.
   
  -=== Inheritance
  -
  -(TBD)
  -
  -
   [[generics]]
   === Generics
   
  
positive.code: <1> abstract classes must be declared with `abstract` keyword
  <2> abstract methods must also be declared with `abstract` keyword
  
  Abstract classes are commonly compared to interfaces. But there are at least two important differences of choosing one or another. First, while abstract classes may contain fields/properties and concrete methods, interfaces may contain only abstract methods (method signatures). Moreover, one class can implement several interfaces, whereas it can extend just one class, abstract or not. 
  
  === Interface
  
  An interface defines a contract that a class needs to conform to. An interface only defines a list of methods that need
  to be implemented, but does not define the methods implementation.
  
  [source,groovy]
  ----
  
negative.code:  * They provide a good organization, by grouping classes that are used by only one class.
   * They lead to more maintainable codes, since inner classes are near the classes that use them.
  
  It is common for an inner class to be an implementation of some interface whose method(s) are needed by the outer class.
  The code below illustrates this typical usage pattern, here being used with threads.
  
  [source,groovy]
  ----
  include::../test/ClassTest.groovy[tags=inner_class2,indent=0]
  ----
  
  Note that the class `Inner2` is defined only to provide an implementation of the method `run` to class `Outer2`.
  Anonymous inner classes help to eliminate verbosity in this case.
  That topic is covered shortly.
  
  Groovy 3+ also supports Java syntax for non-static inner class instantiation, for example:
  
  [source,groovy]
  --------------------------------------
  