¿Por qué es malo usar un comodín con una declaración de importación de Java?

Es mucho más conveniente y limpio usar una sola declaración como

import java.awt.*;

que importar un montón de clases individuales

import java.awt.Panel;
import java.awt.Graphics;
import java.awt.Canvas;
...

¿Qué tiene de malo usar un comodín en la importdeclaración?

El único problema es que satura tu espacio de nombres local. Por ejemplo, supongamos que está escribiendo una aplicación Swing, y por lo tanto necesita java.awt.Event, y también está interactuando con el sistema de calendario de la compañía, que tiene com.mycompany.calendar.Event. Si importa ambos utilizando el método comodín, ocurre una de estas tres cosas:

1. Tiene un conflicto de nombres absoluto entre java.awt.Eventy com.mycompany.calendar.Event, por lo que ni siquiera puede compilar.
2. En realidad, solo logra importar uno (solo uno de sus dos importaciones lo hace .*), pero es el incorrecto y le cuesta descubrir por qué su código afirma que el tipo es incorrecto.
3. Cuando compila su código, no hay ninguno com.mycompany.calendar.Event, pero cuando luego agregan uno, su código previamente válido deja de compilarse.

La ventaja de enumerar explícitamente todas las importaciones es que puedo decir de un vistazo qué clase quería usar, lo que simplemente hace que la lectura del código sea mucho más fácil. Si solo está haciendo algo rápido, no hay nada explícitamente incorrecto , pero los futuros mantenedores le agradecerán su claridad de lo contrario.

Aquí hay un voto para las importaciones estrella. Una declaración de importación está destinada a importar un paquete , no una clase. Es mucho más limpio importar paquetes completos; Los problemas identificados aquí (p. ej., java.sql.Datevs java.util.Date) se solucionan fácilmente por otros medios, no realmente abordados por importaciones específicas y ciertamente no justifican importaciones increíblemente pedantes en todas las clases. No hay nada más desconcertante que abrir un archivo fuente y tener que pasar por 100 declaraciones de importación.

Hacer importaciones específicas hace que la refactorización sea más difícil; Si elimina / cambia el nombre de una clase, debe eliminar todas sus importaciones específicas. Si cambia una implementación a una clase diferente en el mismo paquete, debe arreglar las importaciones. Si bien estos pasos adicionales se pueden automatizar, son realmente éxitos de productividad sin ganancia real.

Incluso si Eclipse no hiciera importaciones de clase por defecto, todos seguirían haciendo importaciones estrella. Lo siento, pero realmente no hay justificación racional para realizar importaciones específicas.

Aquí se explica cómo lidiar con los conflictos de clase:

import java.sql.*;
import java.util.*;
import java.sql.Date;

por favor vea mi artículo Importar bajo demanda es malo

En resumen, el mayor problema es que su código puede romperse cuando se agrega una clase a un paquete que importa. Por ejemplo:

import java.awt.*;
import java.util.*;

// ...

List list;

En Java 1.1, esto estaba bien; La lista se encontró en java.awt y no hubo conflicto.

Ahora suponga que registra su código que funciona perfectamente, y un año después alguien más lo saca para editarlo y está utilizando Java 1.2.

Java 1.2 agregó una interfaz llamada Lista a java.util. ¡AUGE! Conflicto. El código que funciona perfectamente ya no funciona.

Esta es una característica del lenguaje MAL . Hay NO razón de que el código debe dejar de compilar sólo porque un tipo se añadió a un paquete de ...

Además, hace que sea difícil para un lector determinar qué "Foo" está utilizando.

Es no mal usar un comodín con una declaración de importación de Java.

En Clean Code , Robert C. Martin realmente recomienda usarlos para evitar largas listas de importación.

Aquí está la recomendación:

J1: Evite largas listas de importación utilizando comodines

Si usa dos o más clases de un paquete, importe el paquete completo con

paquete de importación. *;

Las largas listas de importaciones son desalentadoras para el lector. No queremos saturar la parte superior de nuestros módulos con 80 líneas de importación. Más bien queremos que las importaciones sean una declaración concisa sobre con qué paquetes colaboramos.

Las importaciones específicas son dependencias difíciles, mientras que las importaciones con comodines no lo son. Si importa específicamente una clase, entonces esa clase debe existir. Pero si importa un paquete con un comodín, no es necesario que existan clases particulares. La declaración de importación simplemente agrega el paquete a la ruta de búsqueda cuando busca nombres. Por lo tanto, tales importaciones no crean una dependencia verdadera y, por lo tanto, sirven para mantener nuestros módulos menos acoplados.

Hay momentos en que la larga lista de importaciones específicas puede ser útil. Por ejemplo, si está lidiando con código heredado y desea averiguar para qué clases necesita construir simulacros y trozos, puede recorrer la lista de importaciones específicas para descubrir los verdaderos nombres calificados de todas esas clases y luego colocar los trozos apropiados en su lugar. Sin embargo, este uso para importaciones específicas es muy raro. Además, la mayoría de los IDE modernos le permitirán convertir las importaciones con comodines en una lista de importaciones específicas con un solo comando. Entonces, incluso en el caso heredado, es mejor importar comodines.

Las importaciones de comodines a veces pueden causar conflictos de nombres y ambigüedades. Dos clases con el mismo nombre, pero en diferentes paquetes, deberán importarse específicamente, o al menos calificarse específicamente cuando se usen. Esto puede ser una molestia, pero es lo suficientemente raro como para que el uso de importaciones con comodines sea generalmente mejor que las importaciones específicas.

Rendimiento : sin impacto en el rendimiento, ya que el código de bytes es el mismo. aunque conducirá a algunos gastos generales de compilación.

Compilación : en mi máquina personal, compilar una clase en blanco sin importar nada toma 100 ms, pero la misma clase cuando import java. * Toma 170 ms.

Abarrota su espacio de nombres, lo que requiere que especifique completamente cualquier nombre de clase que sea ambiguo. La ocurrencia más común de esto es con:

import java.util.*;
import java.awt.*;

...
List blah; // Ambiguous, needs to be qualified.

También ayuda a concretar sus dependencias, ya que todas sus dependencias se enumeran en la parte superior del archivo.

1. Ayuda a identificar conflictos de nombre de clase: dos clases en diferentes paquetes que tienen el mismo nombre. Esto se puede enmascarar con * import.
2. Hace explícitas las dependencias, de modo que cualquiera que tenga que leer su código más tarde sepa lo que quiso importar y lo que no quiso importar.
3. Puede hacer una compilación más rápida porque el compilador no tiene que buscar en todo el paquete para identificar las depencias, aunque esto generalmente no es un gran problema con los compiladores modernos.
4. Los aspectos inconvenientes de las importaciones explícitas se minimizan con los IDE modernos. La mayoría de los IDE le permiten contraer la sección de importación para que no se interponga, llenar automáticamente las importaciones cuando sea necesario e identificar automáticamente las importaciones no utilizadas para ayudar a limpiarlas.

La mayoría de los lugares en los que he trabajado que usan una cantidad significativa de Java hacen que las importaciones explícitas sean parte del estándar de codificación. A veces sigo usando * para la creación rápida de prototipos y luego amplío las listas de importación (algunos IDE también lo harán por usted) al crear el código.

Prefiero importaciones específicas, porque me permite ver todas las referencias externas utilizadas en el archivo sin mirar el archivo completo. (Sí, sé que no necesariamente mostrará referencias totalmente calificadas. Pero las evito siempre que sea posible).

En un proyecto anterior descubrí que el cambio de importaciones * a importaciones específicas reducía el tiempo de compilación a la mitad (de aproximadamente 10 minutos a aproximadamente 5 minutos). La importación * hace que el compilador busque en cada uno de los paquetes listados una clase que coincida con la que usó. Si bien este tiempo puede ser pequeño, se suma para grandes proyectos.

Un efecto secundario de la importación * fue que los desarrolladores copiarían y pegarían líneas de importación comunes en lugar de pensar en lo que necesitaban.

En el libro DDD

En cualquier tecnología de desarrollo en la que se basará la implementación, busque formas de minimizar el trabajo de refactorización de MÓDULOS. En Java, no se puede escapar de la importación a clases individuales, pero al menos puede importar paquetes completos a la vez, lo que refleja la intención de que los paquetes sean unidades altamente cohesivas y al mismo tiempo reduzca el esfuerzo de cambiar los nombres de los paquetes.

Y si abarrota el espacio de nombres local, no es su culpa, culpe al tamaño del paquete.

• No hay impacto en el tiempo de ejecución, ya que el compilador reemplaza automáticamente el * con nombres de clase concretos. Si descompila el archivo .class, nunca lo vería import ...*.

• C # siempre usa * (implícitamente) ya que solo puede usingempaquetar el nombre. Nunca puede especificar el nombre de la clase en absoluto. Java presenta la función después de c #. (Java es muy complicado en muchos aspectos, pero está más allá de este tema).

• En Intellij Idea, cuando "organiza las importaciones", reemplaza automáticamente las importaciones múltiples del mismo paquete con *. Esta es una característica obligatoria, ya que no puede desactivarla (aunque puede aumentar el umbral).

• El caso que figura en la respuesta aceptada no es válido. Sin * todavía tienes el mismo problema. Debe especificar el nombre del paquete en su código sin importar si usa * o no.

Para el registro: cuando agrega una importación, también está indicando sus dependencias.

Podrías ver rápidamente cuáles son las dependencias de los archivos (excluyendo las clases del mismo espacio de nombres).

La más importante es que la importación java.awt.*puede hacer que su programa sea incompatible con una futura versión de Java:

Suponga que tiene una clase llamada "ABC", está utilizando JDK 8 e importa java.util.*. Ahora, supongamos que sale Java 9 y tiene una nueva clase en el paquete java.utilque por casualidad también se llama "ABC". Su programa ahora no se compilará en Java 9, porque el compilador no sabe si con el nombre "ABC" quiere decir su propia clase o la nueva clase en java.awt.

No tendrá ese problema cuando importe solo aquellas clases explícitamente de las java.awtque realmente usa.

Recursos:

Importaciones Java

Entre todos los puntos válidos hechos en ambos lados, no he encontrado mi razón principal para evitar el comodín: me gusta poder leer el código y saber directamente qué es cada clase, o si su definición no está en el idioma o el archivo, donde encontrarlo. Si se importa más de un paquete con *, tengo que buscar en cada uno de ellos para encontrar una clase que no reconozca. La legibilidad es suprema, y ​​estoy de acuerdo en que el código no debería requerir un IDE para leerlo.