Guía del aspecto: Herencia y polimorfismo
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
- «Profundidad del árbol de herencia» (
DIT): cuántos escalones separan una clase deObject. 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). - «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. - «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 |
Shapeañadenameydescribe(NOAC2);areaes abstracto y no entra enNOAC.Circle.areaimplementa un método abstracto: cuenta como añadido, no como sobrescrito. Hereda tal cualnameydescribe(NOIC2).Rectangle.namesí reescribe un método concreto (NOOC1). Solo hereda sin tocardescribe.Squareno añade nada: reescribenamey heredaareadeRectangleydescribedeShape. Sus dos campos son heredados (NAIC2).- En el paquete hay dos clases raíz (
ShapeyUtil) y tres hojas (Circle,SquareyUtil):Utiles a la vez raíz y hoja, una clase que no participa en ninguna jerarquía. - Por método,
IMPdeShape.areavale 2 (Circle.areayRectangle.area;Squareusa la deRectangle, 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:
NOICalto conNOOCbajo: la clase reutiliza; es una variante ligera de sus antepasados.NOACalto: la clase extiende; aporta comportamiento nuevo.NOOCalto frente aNOAC: la clase corrige lo que hereda. Es lo que quiere detectarSIX, 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:
- sobrescribir un método lo saca de los heredados de
MIFy lo suma a las sobrescrituras reales dePF; - los campos y métodos privados no se heredan, así que un
«factor de ocultación de atributos» alto limita
AIF, y uno de «métodos» alto,MIF(ver «Encapsulación»).
Ojo. En Stau Metro las métricas de clase y las de proyecto no tratan igual las bibliotecas.
NAICyNOICcuentan lo heredado de clases del JDK o de bibliotecas (una clase que extiendeArrayListhereda decenas de métodos), mientras queAIFyMIFsolo cuentan lo heredado de antepasados con código fuente en el proyecto.DITtambién cuenta las superclases de biblioteca. Y, de las métricas MOOD,PFes 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
NOOCalto 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.
NOCySUBdicen cuántas clases podrían romperse, no si se romperán. - El uso real.
NOICcuenta 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,IMPyOVERsolo 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. ConNOCsalió 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.