Static Import en Java con Ejemplos

Palabra Clave

Java admite un uso ampliado de la palabra clave import. Siguiendo a import la palabra clave static, se puede usar una declaración de import para importar los miembros estáticos de una clase o interfaz. Esto se llama Static Import. Al usar Static Import, es posible hacer referencia a miembros estáticos directamente por sus nombres, sin tener que calificarlos con el nombre de su clase. Esto simplifica y acorta la sintaxis requerida para usar un miembro estático.

1. Introducción a Static Import

En Java, el concepto de importación estática (Static Import) se introduce en la versión 1.5. Con la ayuda de la importación estática, podemos acceder a los miembros estáticos de una clase directamente sin nombre de clase o cualquier objeto. Por ejemplo: siempre usamos el método sqrt() de la clase Math, es decir Math.sqrt(), pero al usar la importación estática podemos acceder al método sqrt() directamente.

Según SUN microSystem, mejorará la legibilidad del código y mejorará la codificación. Pero según los expertos en programación, generará confusión y no será bueno para la programación. Si no hay ningún requisito específico, entonces no deberíamos usar static import.

2. Uso de Static Import

Para comprender la utilidad de la importación estática (Static Import), comencemos con un ejemplo que no la use. El siguiente programa calcula las soluciones a una ecuación cuadrática, que tiene esta forma:

ax² + bx + c = 0

El programa usa dos métodos estáticos de la clase Math incorporada de Java, Math, que es parte de java.lang. El primero es Math.pow(), que devuelve un valor elevado a una potencia especificada. El segundo es Math.sqrt(), que devuelve la raíz cuadrada de su argumento.

//Encuentra las soluciones a una ecuación cuadrática.
class EcuCuadratica {
    public static void main(String[] args) {
       //a,b,c representan los coeficientes en
       //la ecuación cuadrática ax² + bx + c = 0
        double a,b,c,x;
       // Resuelve 4x² + x - 3 = 0  para x.
        a=4;
        b=1;
        c=-3;

        //Encuentra la primera solución
        x=(-b+Math.sqrt(Math.pow(b,2)-4*a*c))/(2*a);
        System.out.println("Primera solución: "+x);

        //Encuentra la segunda solución
        x=(-b-Math.sqrt(Math.pow(b,2)-4*a*c))/(2*a);
        System.out.println("Segunda solución: "+x);
    }
}

Salida:

Primera solución: 0.75
Segunda solución: -1.0

Debido a que pow() y sqrt() son métodos estáticos, deben invocarse mediante el uso del nombre de su clase, Math. Esto da como resultado una expresión algo difícil de manejar:

x = (-b + Math.sqrt(Math.pow(b, 2) - 4 * a * c)) / (2 * a)

Además, tener que especificar el nombre de la clase cada vez que se usan pow() o sqrt() (o cualquiera de los otros métodos matemáticos de Java, como sin(), cos() y tan()) puede volverse tedioso.

Puede eliminar lo trabajoso de especificar el nombre de clase mediante el uso de import static, como se muestra en la siguiente versión del programa anterior:

3. Ejemplo de ‘import static’

//Uso de static import para sqrt() y pow()
import static java.lang.Math.pow;
import static java.lang.Math.sqrt;

class EcuCuadratica {
    public static void main(String[] args) {
       //a,b,c representan los coeficientes en
       //la ecuación cuadrática ax² + bx + c = 0
        double a,b,c,x;
       // Resuelve 4x² + x - 3 = 0  para x.
        a=4;
        b=1;
        c=-3;

        //Encuentra la primera solución
        x=(-b+sqrt(pow(b,2)-4*a*c))/(2*a);
        System.out.println("Primera solución: "+x);

        //Encuentra la segunda solución
        x=(-b-sqrt(pow(b,2)-4*a*c))/(2*a);
        System.out.println("Segunda solución: "+x);
    }
}

En esta versión, los nombres sqrt y pow se utilizan mediante estas declaraciones static import (estáticas de importación):

import static java.lang.Math.sqrt;
import static java.lang.Math.pow;

Después de estas declaraciones, ya no es necesario calificar sqrt() o pow() con su nombre de clase. Por lo tanto, la expresión se puede especificar más cómodamente, como se muestra aquí:

x = (-b + sqrt(pow(b, 2) - 4 * a * c)) / (2 * a);

Como puede ver, esta forma es considerablemente más corta y más fácil de leer.

  • Hay dos formas generales de la declaración import static. El primero, que se usa en el ejemplo anterior, muestra un solo nombre. Su forma general se muestra aquí:
import static pkg.nombre-tipo.nombre-miembro-static;

Aquí, nombre-tipo es el nombre de una clase o interfaz que contiene el miembro estático deseado. Su nombre completo del paquete está especificado por pkg. El nombre del miembro se especifica mediante nombre-miembro-static.

  • La segunda forma de static import importa todos los miembros estáticos. Su forma general se muestra aquí:
import static pkg.nombre-tipo.*

Si va a utilizar muchos métodos estáticos o campos definidos por una clase, este forma le permite visualizarlos sin tener que especificarlos individualmente. Por lo tanto, el programa anterior podría haber utilizado esta única declaración de importación para poner a disposición tanto pow() como sqrt() (y todos los otros miembros estáticos de Math):

import static java.lang.Math.*;

4. Puntos Finales

Por supuesto, la importación estática (static import) no está limitada solo a la clase de Math o solo a métodos. Por ejemplo, lo siguiente trae el campo estático System.out a la vista:

import static java.lang.System.out;

Después de esta declaración, puede enviar a la consola sin tener que calificar con System, como se muestra aquí:

out.println("Después de importar System.out, se puede utilizar directamente.");

Si importar System.out como se acaba de mostrar es una buena idea, está sujeto a debate. A pesar de que acorta la declaración, ya no está claro instantáneamente para cualquiera que lea el programa que la salida a la que se refiere es a System.out.

Por muy conveniente que sea static import, es importante no abusar de ella. Recuerde, una de las razones por las que Java organiza sus bibliotecas en paquetes es para evitar las colisiones de espacios de nombres. Cuando importa miembros estáticos, está trayendo a esos miembros al espacio de nombres global. Por lo tanto, está aumentando el potencial de conflictos de espacio de nombres y la ocultación involuntaria de otros nombres.

Si está usando un miembro estático una o dos veces en el programa, es mejor no importarlo. Además, algunos nombres estáticos, como System.out, son tan reconocibles que es posible que no desee importarlos. La importación estática está diseñada para aquellas situaciones en las que se utiliza un miembro estático repetidamente, como cuando se realizan una serie de cálculos matemáticos. En esencia, usted debe usar, pero no abusar, de esta característica.

Palabras Claves Java
  • Static Import

Sobre el Autor:

Hey hola! Yo soy Alex Walton y tengo el placer de compartir conocimientos hacía ti sobre el tema de Programación en Java, desde cero, Online y Gratis.

Deja una Respuesta

*

Este sitio usa Akismet para reducir el spam. Aprende cómo se procesan los datos de tus comentarios.