Cuando creo jerarquías de tipos complejas (varios niveles, varios tipos por nivel), me gusta usar elfinal palabra clave sobre métodos que implementan alguna declaración de interfaz. Un ejemplo:

interface Garble {
  int zork();
}

interface Gnarf extends Garble {
  /**
   * This is the same as calling {@link #zblah(0)}
   */
  int zblah();
  int zblah(int defaultZblah);
}

Y entonces

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);
}

Hago esto por varias razones:

Me ayuda a desarrollar la jerarquía de tipos. Cuando agrego una clase a la jerarquía, está muy claro, qué métodos tengo que implementar y qué métodos no puedo anular (en caso de que olvide los detalles sobre la jerarquía)Pienso primordialhormigón las cosas son malas según los principios y patrones de diseño, como eltemplate method modelo. No quiero que otros desarrolladores o mis usuarios lo hagan.

Entonces elfinal La palabra clave funciona perfectamente para mí. Mi pregunta es:

¿Por qué se usa tan raramente en la naturaleza? ¿Me puede mostrar algunos ejemplos / razones dondefinal (en un caso similar al mío) sería muy malo?