Respuestas:
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:
java.awt.Eventy com.mycompany.calendar.Event, por lo que ni siquiera puede compilar..*), pero es el incorrecto y le cuesta descubrir por qué su código afirma que el tipo es incorrecto.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;Foo, y si leo su código sin usar un IDE (ya que su argumento es que no debería tener que usar uno), ¿cómo sabré de qué paquete Fooproviene? ? Claro, usando un IDE, el IDE me lo dirá, pero su argumento completo es que debería poder leer el código sin uno. Hacer importaciones explícitas ayuda a documentar el código (una buena razón para evitar los comodines) , y es mucho más probable que esté leyendo el código sin usar un IDE, que escribir el código sin usar un IDE.
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.
java.util.Listvs java.awt.Listno es tan malo de entender, pero pruébelo cuando el nombre de la clase lo sea Configurationy múltiples bibliotecas de dependencias lo hayan agregado en su última versión de repositorio maven.
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.
import java.*No importa nada. ¿Por qué haría una diferencia?
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.
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.
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:
Streamcomo ejemplo una nueva clase agregada en Java en java.util en Java 8 ...
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.