Importações estáticas

De volta ao Capítulo 1, você viu que poderíamos importar uma classe específica ou todas as classes em um pacote:

import java.util.ArrayList;

import java.util.*;

Poderíamos usar esta técnica para importar:

import java.util.List;

import java.util.Arrays;

public class Imports {

 public static void main(String[] args) {

 List<String> list = Arrays.asList("one", "two");

As importações são convenientes porque você não precisa especificar de onde vem cada classe a cada vez que você o usa. Há outro tipo de importação chamado importação estática. Regular as importações são para importar classes. As importações estáticas destinam-se à importação de membros estáticos de classes. Assim como as importações regulares, você pode usar um curinga ou importar um membro específico. A idéia é que você não precise especificar de onde vem cada método ou variável estática cada vez que você o usa. Um exemplo de quando as interfaces estáticas brilham é quando você está se referindo para muitas constantes em outra classe.

Em um programa grande, as importações estáticas podem ser usadas em excesso. Ao importar em muitos lugares, pode ser difícil lembrar onde cada membro estático vem.

O método anterior possui uma chamada de método estático: Arrays.asList . Reescrevendo o código para usar uma importação estática gera o seguinte:

import java.util.List;

import static java.util.Arrays.asList; // static import

public class StaticImports {

 public static void main(String[] args) {

 List<String> list = asList("one", "two"); // no Arrays.

} }

Neste exemplo, estamos importando especificamente o método asList . Isso significa que quando nos referimos a asList na classe, ele chamará Arrays.asList () . Um caso interessante é o que aconteceria se criassemos um método asList em nossa Classe StaticImports. Java daria preferência ao importado e ao método nós codificamos seria usado.

O exame tentará enganá-lo com o uso indevido de importações estáticas. Este exemplo mostra quase tudo o que você pode fazer de errado. Você consegue descobrir o que há de errado com cada um?

1: import static java.util.Arrays; // DOES NOT COMPILE

2: import static java.util.Arrays.asList;

3: static import java.util.Arrays.*; // DOES NOT COMPILE

4: public class BadStaticImports {

5: public static void main(String[] args) {

6: Arrays.asList("one"); // DOES NOT COMPILE

7: } }

A linha 1 tenta usar uma importação estática para importar uma classe. Lembre-se de que importações estáticas são somente para importar membros estáticos. As importações regulares são para importar uma classe. Linha 3 tenta para ver se você está prestando atenção à ordem das palavras-chave. A sintaxe é import static e não vice-versa. A linha 6 é sorrateira. Importamos o método asList na linha 2. No entanto, não importamos a classe Arrays em nenhum lugar. Isso faz com que seja bom escrever como List ("one"); mas não Arrays.asList ("one"); . Há apenas mais um cenário com importações estáticas. No capítulo 1, você aprendeu que importar duas classes com o mesmo nome gera um erro do compilador. Isso é verdade para importações estáticas também. O compilador reclamará se você tentar fazer explicitamente uma importação estática de dois métodos com o mesmo nome ou duas variáveis estáticas com o mesmo nome. Por exemplo:

import static statics.A.TYPE;

import static statics.B.TYPE; // DOES NOT COMPILE

Felizmente, quando isso acontece, podemos apenas nos referir aos membros estáticos através do nome da classe em o código em vez de tentar usar uma importação estática.

Voltar para Passando dados

Voltar para Capitulo 04

Google Sites

Report abuse