title: Java method keyword "final" and its use
body: <p>When I create complex type hierarchies (several levels, several types per level), I like to use the <code>final</code> keyword on methods implementing some interface declaration. An example:</p>
  
  <pre><code>interface Garble {
    int zork();
  }
  
  interface Gnarf extends Garble {
    /**
     * This is the same as calling {@link #zblah(0)}
     */
    int zblah();
    int zblah(int defaultZblah);
  }
  </code></pre>
  
  <p>And then</p>
  
  <pre><code>abstract class AbstractGarble implements Garble {
    @Override
    public final int zork() { ... }
  }
  
  abstract class AbstractGnarf extends AbstractGarble implements Gnarf {
    // Here I absolutely want to fix the default behaviour of zblah
    // No Gnarf shouldn't be allowed to set 1 as the default, for instance
    @Override
    public final int zblah() { 
      return zblah(0);
    }
  
    // This method is not implemented here, but in a subclass
    @Override
    public abstract int zblah(int defaultZblah);
  }
  </code></pre>
  
  <p>I do this for several reasons:</p>
  
  <ol>
  <li>It helps me develop the type hierarchy. When I add a class to the hierarchy, it is very clear, what methods I have to implement, and what methods I may not override (in case I forgot the details about the hierarchy)</li>
  <li>I think overriding <strong>concrete</strong> stuff is bad according to design principles and patterns, such as the <code>template method</code> pattern. I don't want other developers or my users do it.</li>
  </ol>
  
  <p>So the <code>final</code> keyword works perfectly for me. My question is:</p>
  
  <p>Why is it used so rarely in the wild? Can you show me some examples / reasons where <code>final</code> (in a similar case to mine) would be very bad?</p>