Quando a importação de java importa um pacote, em que devemos prestar atenção?

Olá, estou observando as montanhas.

O motivo deste artigo é uma discordância com meus colegas sobre a instrução de importação durante a revisão do código.

Quem já utilizou o IDEA sabe que por padrão, ao importar classes via importação, quando o número atingir o número definido (5 classes, 3 variáveis ​​estáticas), será alterado para o método de importação sob demanda, ou seja, utilize o * assinar para dobrar a importação.

Os colegas sugerem não usar a importação sob demanda, mas usar a importação de tipo único. E eu acho que, como o IDEA é um IDE em nível de universo, não haverá erros neste tipo de lugar, então quero continuar a seguir a configuração padrão do IDEA.

Portanto, resuma as diferenças entre esses dois métodos. Se você não está familiarizado com a importação de java, dê uma olhada aqui .

Duas declarações de importação de importação

Em java, existem duas maneiras de importar classes por meio de importação:

• Importação de tipo único (importação de tipo único), por exemplo import java.io.File: Este método é mais fácil de entender e, na maioria das vezes, usamos esse método. Importe-os especificando claramente a classe e o caminho da interface.
• Importação de tipo sob demanda (tipo-importação sob demanda), por exemplo import java.io.*: *defina o método de importação por meio de curingas , mas nem todas as classes neste pacote são importadas diretamente, mas todas as classes podem ser importadas. Em outras palavras, se você precisar importá-lo, não importe se você não precisar dele.

Possui os seguintes atributos:

1. Java importa publicas classes e interfaces de qualquer um dos pacotes dessas duas maneiras (apenas classes e interfaces públicas podem ser importadas)
2. Conforme mencionado acima, as declarações de importação importam apenas classes no diretório de declaração e não subpacotes, por isso são chamadas de declarações de importação de tipo.
3. O nome simples da classe ou interface importada tem o escopo da unidade de compilação. Isso significa que o nome abreviado do tipo pode ser usado em qualquer lugar na unidade de compilação onde a instrução import está localizada. Isso não significa que você pode usar os nomes curtos de todos os membros do tipo, mas apenas os nomes curtos do próprio tipo. Por exemplo: as classes públicas no pacote java.lang são importadas automaticamente, incluindo as classes Mathe System. No entanto, você não pode usar a PI()soma dos nomes curtos de seus membros gc(), mas deve usar a Math.PI()soma System.gc(). Não é necessário digitar a java.lang.Math.PI()soma java.lang.System.gc().
4. Os programadores às vezes importam o pacote ou pacote atual java.lang, o que é desnecessário, porque os próprios membros do pacote atual estão no escopo e o java.langpacote é importado automaticamente. O compilador java ignora essas declarações de importação redundantes.

Mecanismo de importação sob demanda

A importação sob demanda é mais conveniente na maioria dos casos.Um curinga pode importar todas as classes do pacote, então você não precisa escrever muitas importações.

No entanto, de acordo com a conservação de energia, a energia economizada ao digitar os códigos será inevitavelmente consumida em outro lugar.

Por exemplo, uma Dateclasse pode ser escrita se for completamente importada usando o tipo sob demanda import java.util.*. Quando esta classe for necessária, uma importação PrepareStatementprecisa ser adicionada import java.sql.*. Neste momento, o compilador não sabe se a Dateclasse deve ser usada no java.utilpacote ou java.sqldentro dele, ele relatará uma Reference to 'Date' is ambiguous, both 'java.util.Date' and 'java.sql.Date' matchexceção, que é a chamada nomenclatura conflito .

A solução é especificar Dateo caminho completo para a classe, isto é, usando um único tipo de importação: import java.util.Date.

Além dos conflitos de nomenclatura, existem algumas desvantagens menos óbvias:

1. Velocidade de compilação: devido às características do mecanismo de importação sob demanda, você precisa encontrar todas as classes que correspondem ao nome do pacote em CLASSPATH, o que consumirá desempenho durante a compilação. Em pequenos projetos, essa velocidade pode ser ignorada. Se for um grande projeto, haverá diferenças detalhadas.
2. Legibilidade: no processo de desenvolvimento usando IDE, raramente olhamos para importo caminho da classe. Mas se precisarmos editar arquivos em outros ambientes, como o vim, importé muito conveniente visualizar o caminho da classe.

O que acontece ao importar classes desnecessárias

De um ponto de vista racional, o compilador java definitivamente otimizará aqui e não adicionará declarações de importação desnecessárias ao arquivo de classe, mas não vi nenhuma instrução antes, então vamos fazer alguns experimentos:

Primeiro defina a classe java:

package cn.howardliu;

// 需要用到的单类型导入
import java.util.Date;
// 需要用到的按需类型导入
import java.math.*;
// 不需要用到的单类型导入
import java.sql.PreparedStatement;
// 不需要用到的按需类型导入
import java.awt.*;

public class Main {
    
    
    private Date date1;
    private BigDecimal num1;

    public void test(){
    
    
        Date date2 = new Date();
        BigDecimal num2 = new BigDecimal(0);
    }
}

javac Main.javaCompile por comando e javap -verbose Main.classveja os resultados da compilação:

Classfile /path/to/Main.class
  Last modified 2021-1-31; size 439 bytes
  MD5 checksum 81e13559f738197b4875c2c2afd6fc41
  Compiled from "Main.java"
public class cn.howardliu.Main
  minor version: 0
  major version: 52
  flags: ACC_PUBLIC, ACC_SUPER
Constant pool:
   #1 = Methodref          #7.#19         // java/lang/Object."<init>":()V
   #2 = Class              #20            // java/util/Date
   #3 = Methodref          #2.#19         // java/util/Date."<init>":()V
   #4 = Class              #21            // java/math/BigDecimal
   #5 = Methodref          #4.#22         // java/math/BigDecimal."<init>":(I)V
   #6 = Class              #23            // cn/howardliu/Main
   #7 = Class              #24            // java/lang/Object
   #8 = Utf8               date1
   #9 = Utf8               Ljava/util/Date;
  #10 = Utf8               num1
  #11 = Utf8               Ljava/math/BigDecimal;
  #12 = Utf8               <init>
  #13 = Utf8               ()V
  #14 = Utf8               Code
  #15 = Utf8               LineNumberTable
  #16 = Utf8               test
  #17 = Utf8               SourceFile
  #18 = Utf8               Main.java
  #19 = NameAndType        #12:#13        // "<init>":()V
  #20 = Utf8               java/util/Date
  #21 = Utf8               java/math/BigDecimal
  #22 = NameAndType        #12:#25        // "<init>":(I)V
  #23 = Utf8               cn/howardliu/Main
  #24 = Utf8               java/lang/Object
  #25 = Utf8               (I)V
{
  public cn.howardliu.Main();
    descriptor: ()V
    flags: ACC_PUBLIC
    Code:
      stack=1, locals=1, args_size=1
         0: aload_0
         1: invokespecial #1                  // Method java/lang/Object."<init>":()V
         4: return
      LineNumberTable:
        line 12: 0

  public void test();
    descriptor: ()V
    flags: ACC_PUBLIC
    Code:
      stack=3, locals=3, args_size=1
         0: new           #2                  // class java/util/Date
         3: dup
         4: invokespecial #3                  // Method java/util/Date."<init>":()V
         7: astore_1
         8: new           #4                  // class java/math/BigDecimal
        11: dup
        12: iconst_0
        13: invokespecial #5                  // Method java/math/BigDecimal."<init>":(I)V
        16: astore_2
        17: return
      LineNumberTable:
        line 17: 0
        line 18: 8
        line 19: 17
}
SourceFile: "Main.java"

Ele pode ser visto no conteúdo do arquivo da classe:

1. A apresentação do método de importação de tipo sob demanda no arquivo de classe é a mesma que a importação por tipo.A importação de classe necessária será encontrada e todas as classes do pacote não serão importadas.
2. As declarações de importação de classe desnecessárias serão eventualmente otimizadas e não aparecerão no arquivo de classe.
3. importAo contrário da linguagem C, Java includenão grava as classes declaradas importadas no arquivo de classe e cada uma é um arquivo de classe independente.

JDK recomenda qual caminho

O JDK é definitivamente o benchmark para a programação java. Muitos de nós podem aprender com o JDK:

import java.io.IOException;
import java.io.PrintStream;
import java.io.PrintWriter;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.Reader;
import java.io.Writer;
import java.io.OutputStreamWriter;
import java.io.BufferedWriter;
import java.security.AccessController;
import java.security.PrivilegedAction;

import sun.util.spi.XmlPropertiesProvider;

Esta é java.util.Propertiesa instrução de importação em. Pode-se ver que uma instrução de importação de tipo único é usada, portanto, se não houver outro requisito, tentamos usar a importação de tipo único tanto quanto possível.

Pensamento de fim de frase

1. Java importé uma declaração de importação de classe e não gravará o arquivo no arquivo de classe compilado
2. importExistem dois métodos de importação para java : importação de tipo único e importação de tipo sob demanda
3. A importação de tipo sob demanda só terá perda de desempenho durante o processo de compilação e não há diferença entre a importação de tipo único em tempo de execução
4. A maior parte do código-fonte JDK usa importações de tipo único.

---

Olá, sou Kanshan, conta pública: Kanshan’s Lodge, back-end de 10 anos, contribuidor de código aberto para Apache Storm, WxJava, Cynomys. Trabalho principal: programador, trabalho a tempo parcial: arquitecto. Nade no mundo do código, aproveite a vida no drama.

Página pessoal: https://www.howardliu.cn
Postagem pessoal no blog: java import import package
CSDN homepage: http://blog.csdn.net/liuxinghao
CSDN blog post: java import import package