τTau SolutionsAspectos de calidad

Guía del aspecto: Herencia y polimorfismo

Actualizado el 15 de noviembre de 2026

El aspecto responde a una pregunta: ¿cómo usa el código la herencia, y qué hace con lo que hereda? La herencia deja que una clase reciba campos y métodos de otra y que los cambie. Bien usada, comparte código y permite tratar objetos distintos de la misma forma (polimorfismo). Mal usada, crea jerarquías profundas en las que, para entender una clase, hay que leer todas las que tiene encima, y en las que un cambio arriba rompe algo abajo.

Las métricas del aspecto miran tres cosas distintas:

  • la forma de las jerarquías: lo profunda que está una clase, cuántas clases cuelgan de ella, cuántas jerarquías empiezan y terminan en el código;
  • lo que pasa por la herencia en cada clase: cuántos campos y métodos recibe, cuántos añade y cuántos reescribe;
  • el uso global en el proyecto: qué proporción de lo disponible viene heredado y cuántas de las sobrescrituras posibles se hacen de verdad (los factores MOOD).

Para quien empieza. Casi ninguna de estas métricas tiene un valor «bueno». Una clase con diez hijos puede ser una base bien pensada o una clase de utilidad a la que todo el mundo se engancha por comodidad. Se leen para entender la estructura y para encontrar lo raro, no para aprobar o suspender.

Por dónde empezar

  1. «Profundidad del árbol de herencia» (DIT): cuántos escalones separan una clase de Object. Es la única del aspecto que el catálogo de Stau Metro marca como esencial y la única a la que ese catálogo da umbrales de referencia (aviso por encima de 5, error por encima de 8).
  2. «Número de hijos» (NOC) y «número de subclases» (SUB): la anchura de la jerarquía bajo una clase, directa o a cualquier profundidad. Dicen a cuántas clases afecta un cambio en la base.
  3. «Número de operaciones sobrescritas» (NOOC), leída junto a las «añadidas» (NOAC): si una subclase extiende a su padre o lo corrige método a método.

Todas las métricas del aspecto

Todas son informativas (ni alto ni bajo es mejor) salvo DIT y SIX, en las que más alto es peor.

Forma de las jerarquías

Métrica Sigla Nivel Qué cuenta Stau Metro
«Profundidad del árbol de herencia» DIT clase superclases hasta Object inclusive sí
«Número de hijos» NOC clase clases que la extienden directamente sí
«Número de subclases» SUB clase clases que descienden de ella a cualquier profundidad sí
«Número de subinterfaces» SUB interfaz interfaces que la extienden a cualquier profundidad sí
«Número de implementaciones» IMP método, interfaz clases que cumplen la interfaz; métodos que dan cuerpo a un método abstracto sí
«Número de interfaces implementadas» NII clase interfaces distintas que cumple, propias y heredadas sí
«Número de clases raíz» ROOT paquete, módulo, proyecto clases en lo alto de su cadena de herencia sí
«Número de clases hoja» LEAF paquete, módulo, proyecto clases que ninguna otra extiende sí

Lo que pasa por la herencia, clase a clase

Métrica Sigla Nivel Qué cuenta Stau Metro
«Número de atributos heredados» NAIC clase campos no estáticos declarados en sus superclases sí
«Número de atributos añadidos» NAAC clase campos que declara ella misma sí
«Número de operaciones heredadas» NOIC clase métodos concretos que recibe y no redefine sí
«Número de operaciones añadidas» NOAC clase métodos propios que no redefinen uno concreto heredado sí
«Número de operaciones sobrescritas» NOOC clase métodos propios que redefinen uno concreto heredado sí
«Número de métodos que sobrescriben» OVER método métodos de las subclases que lo sobrescriben sí
«Índice de especialización» SIX clase sobrescrituras por profundidad, entre el número de métodos no

Proyecto (factores MOOD)

Métrica Sigla Nivel Qué cuenta Stau Metro
«Factor de herencia de métodos» MIF proyecto parte de los métodos disponibles que llega por herencia sí
«Factor de herencia de atributos» AIF proyecto parte de los campos disponibles que llega por herencia sí
«Factor de polimorfismo» PF proyecto sobrescrituras reales frente a las posibles sí

SIX es la única que Stau Metro no calcula, pero calcula sus piezas (NOOC, NOAC y DIT), y la página de la métrica explica cómo aproximarla con ellas. DIT y NOC pertenecen a las «métricas de Chidamber y Kemerer»; MIF, AIF y PF, a las «métricas MOOD»; NOAC, NOOC y SIX, a las «de Lorenz y Kidd».

Un ejemplo con varias a la vez

Una jerarquía pequeña basta para ver qué mira cada métrica:

abstract class Shape {
    abstract double area();
    String name() { return "shape"; }
    String describe() { return name() + ": " + area(); }
}

class Circle extends Shape {
    final double r;
    Circle(double r) { this.r = r; }
    @Override double area() { return Math.PI * r * r; }
}

class Rectangle extends Shape {
    final double w, h;
    Rectangle(double w, double h) { this.w = w; this.h = h; }
    @Override double area() { return w * h; }
    @Override String name() { return "rectangle"; }
}

class Square extends Rectangle {
    Square(double side) { super(side, side); }
    @Override String name() { return "square"; }
}

class Util { }

Con las reglas de Stau Metro, que cuentan Object en la profundidad y no cuentan los constructores ni los métodos de Object como operaciones:

Clase DIT NOC SUB NAAC NAIC NOAC NOOC NOIC
Shape 1 2 3 0 0 2 0 0
Circle 2 0 0 1 0 1 0 2
Rectangle 2 1 1 2 0 1 1 1
Square 3 0 0 0 2 0 1 2
Util 1 0 0 0 0 0 0 0
  • Shape añade name y describe (NOAC 2); area es abstracto y no entra en NOAC.
  • Circle.area implementa un método abstracto: cuenta como añadido, no como sobrescrito. Hereda tal cual name y describe (NOIC 2).
  • Rectangle.name sí reescribe un método concreto (NOOC 1). Solo hereda sin tocar describe.
  • Square no añade nada: reescribe name y hereda area de Rectangle y describe de Shape. Sus dos campos son heredados (NAIC 2).
  • En el paquete hay dos clases raíz (Shape y Util) y tres hojas (Circle, Square y Util): Util es a la vez raíz y hoja, una clase que no participa en ninguna jerarquía.
  • Por método, IMP de Shape.area vale 2 (Circle.area y Rectangle.area; Square usa la de Rectangle, que cuenta una vez).

Cómo se combinan

Profundidad y anchura. DIT mira hacia arriba; NOC y SUB, hacia abajo. Una jerarquía estrecha y profunda (muchas clases con NOC 1 y DIT creciente) suele ser una cadena de capas de paso que se pueden fusionar. Una ancha y plana (una base con NOC alto y DIT 2 en los hijos) es el caso típico de una abstracción con muchas variantes. ROOT y LEAF, contadas por paquete, dan el resumen: muchas raíces que son también hojas significan poca herencia.

Reutilizar, extender o corregir. Las tres operaciones de clase reparten los métodos de una subclase:

  • NOIC alto con NOOC bajo: la clase reutiliza; es una variante ligera de sus antepasados.
  • NOAC alto: la clase extiende; aporta comportamiento nuevo.
  • NOOC alto frente a NOAC: la clase corrige lo que hereda. Es lo que quiere detectar SIX, y a menudo señala una subclase que no es un subtipo natural de su padre.

Para los campos, NAAC y NAIC hacen lo mismo; en Stau Metro su suma es el «tamaño de la clase en atributos» (CSA).

Desde la clase o desde el método. NOOC cuenta, en la subclase, cuántos métodos reescribe; OVER cuenta, en el método de la base, cuántas subclases lo reescriben. IMP hace lo mismo que OVER para los métodos abstractos. Un OVER alto en un método que no estaba pensado como punto de extensión es el dato más directo para decidir si debería ser final o convertirse en un hook explícito.

Del proyecto a la clase. MIF, AIF y PF dan un número para todo el proyecto y sirven para comparar proyectos o versiones, no para encontrar una clase. Están ligados entre sí y con la encapsulación:

Ojo. En Stau Metro las métricas de clase y las de proyecto no tratan igual las bibliotecas. NAIC y NOIC cuentan lo heredado de clases del JDK o de bibliotecas (una clase que extiende ArrayList hereda decenas de métodos), mientras que AIF y MIF solo cuentan lo heredado de antepasados con código fuente en el proyecto. DIT también cuenta las superclases de biblioteca. Y, de las métricas MOOD, PF es la única que cuenta las clases anónimas como subclases. No sumes ni compares valores de unas y otras como si salieran de la misma población.

Con otros aspectos. Extender una clase es depender de ella, así que los hijos aparecen entre los «dependientes» (Dpt) de la base y las interfaces implementadas entre las «dependencias» (Dcy) de la clase. Una NOC alta en una clase con una «complejidad ponderada» (WMC) alta concentra complejidad arriba de la jerarquía, donde más clases la reciben.

Qué no miden

  • Si la herencia es correcta. Las métricas cuentan estructura. No ven si una subclase respeta el contrato de su padre (el principio de sustitución de Liskov, que Liskov y Wing precisaron en 1994 como subtipado de comportamiento). Un NOOC alto es una pista, no una prueba.
  • La composición. Una clase que reutiliza a otra por delegación, guardándola en un campo, no gana profundidad ni hijos por ello: esa reutilización no aparece en ninguna métrica del aspecto. Un proyecto que sigue el consejo de preferir la composición a la herencia (ver «Para profundizar») tendrá valores bajos en todo el aspecto, y eso no dice nada malo de él.
  • La fragilidad de la base. Que un cambio en una superclase rompa subclases que no se han tocado (el problema de la clase base frágil, estudiado por Mikhajlov y Sekerinski en 1998) depende de cómo se llaman entre sí los métodos, no de cuántos hay. NOC y SUB dicen cuántas clases podrían romperse, no si se romperán.
  • El uso real. NOIC cuenta lo que una clase puede usar, no lo que usa: un método heredado al que nadie llama cuenta igual.
  • Lo que queda fuera del análisis. NOC, SUB, LEAF, IMP y OVER solo cuentan las clases del ámbito analizado, así que una clase puede ser hoja en un módulo y no en el proyecto. En Stau Metro tampoco entran las clases Kotlin: el aspecto solo cubre Java.

Para profundizar

Evidencia sobre la profundidad. Los resultados no apuntan todos en la misma dirección:

  • Basili, Briand y Melo (1996) estudiaron ocho sistemas de gestión de tamaño medio escritos en C++ a partir de los mismos requisitos. Cuanto mayor era DIT, mayor era la probabilidad de encontrar un defecto en la clase. Con NOC salió lo contrario de lo esperado: las clases con más hijos tenían menos probabilidad de defecto, y los autores lo explican porque las clases reutilizadas tal cual solían tener más hijos.
  • Daly y colegas (1996) encontraron en experimentos de laboratorio con sujetos que un programa con tres niveles de herencia se mantenía significativamente más deprisa que su equivalente sin herencia, y que con cinco niveles se tardaba de media algo más, sin significación estadística.
  • Prechelt, Unger, Philippsen y Tichy (2003) repitieron la comparación con 0, 3 y 5 niveles en un programa más largo y con otro tipo de tareas. En las tareas centradas en entender el código, los programas con menos herencia se mantuvieron más deprisa. Concluyeron que la profundidad no hace útil o dañino un diseño en sí misma: el esfuerzo de mantenimiento se explicaba mucho mejor por el número de métodos relevantes para la tarea.

Sobre los umbrales de DIT no hay acuerdo: la página de la métrica recoge los que usan Visual Studio y Project Analyzer y por qué no tienen respaldo empírico. Los umbrales de los factores MOOD salen de cinco bibliotecas de C++ de 1995 y conviene no aplicarlos a una aplicación Java sin más; están en cada página y en «Métricas MOOD».

Variantes que cambian los números. Cada herramienta decide si DIT cuenta las clases de biblioteca y si la raíz vale 0 o 1; si implementar un método abstracto o de interfaz es sobrescribir (en el NOOC de Stau Metro no lo es; implementar un método de una interfaz del ámbito sí cuenta en su PF); si los constructores o los métodos estáticos se heredan en MIF. Compara valores solo entre mediciones hechas con la misma herramienta.

Consejos de diseño que explican las lecturas. Gamma, Helm, Johnson y Vlissides (1994) resumieron su experiencia en «favorece la composición de objetos frente a la herencia de clases»: llaman a la herencia reutilización de caja blanca, porque la subclase ve las interioridades de su padre, y a la composición, de caja negra. Bloch dedica a lo mismo dos consejos de Effective Java (3.ª edición, 2018): «Favor composition over inheritance» y «Design and document for inheritance or else prohibit it». Leídas con esa idea, una NOC alta en una clase que no se diseñó como base y un OVER alto en métodos que no se pensaron para sobrescribirse son las señales más útiles del aspecto.

Referencias

  • Basili, V. R., Briand, L. C. y Melo, W. L. (1996). «A Validation of Object-Oriented Design Metrics as Quality Indicators». IEEE Transactions on Software Engineering, 22(10), 751-761. https://doi.org/10.1109/32.544352 Informe técnico previo: https://www.cs.umd.edu/~basili/publications/technical/T102.pdf
  • Daly, J., Brooks, A., Miller, J., Roper, M. y Wood, M. (1996). «Evaluating Inheritance Depth on the Maintainability of Object-Oriented Software». Empirical Software Engineering, 1(2), 109-132. https://doi.org/10.1007/BF00368701
  • Prechelt, L., Unger, B., Philippsen, M. y Tichy, W. F. (2003). «A Controlled Experiment on Inheritance Depth as a Cost Factor for Code Maintenance». Journal of Systems and Software, 65(2), 115-126. https://doi.org/10.1016/S0164-1212(02)00053-5
  • Liskov, B. y Wing, J. M. (1994). «A Behavioral Notion of Subtyping». ACM Transactions on Programming Languages and Systems, 16(6), 1811-1841. https://doi.org/10.1145/197320.197383
  • Mikhajlov, L. y Sekerinski, E. (1998). «A Study of the Fragile Base Class Problem». En ECOOP'98 — Object-Oriented Programming, LNCS 1445, 355-382. https://doi.org/10.1007/BFb0054099
  • Gamma, E., Helm, R., Johnson, R. y Vlissides, J. (1994). Design Patterns: Elements of Reusable Object-Oriented Software. Addison-Wesley.
  • Bloch, J. (2018). Effective Java, 3.ª edición. Addison-Wesley. Items 18 y 19.