blocks|key|1737210|text|它使您的命名空间变得混乱，要求您完全指定任何不明确的类名。最常见的情况是：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1737211|import+java.util.*;
import+java.awt.*;

...
List+blah;+//+Ambiguous,+needs+to+be+qualified.|code-block|syntax|javascript|1737212|它还有助于使您的依赖关系具体化，因为您的所有依赖关系都列在文件顶部。|1737213|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

It clutters your namespace, requiring you to fully specify any classnames that are ambiguous. The most common occurence of this is with:

<pre><code>import java.util.*;
import java.awt.*;

...
List blah; // Ambiguous, needs to be qualified.
</code></pre>

It also helps make your dependencies concrete, as all of your dependencies are listed at the top of the file.

blocks|key|1737161|text|我更喜欢特定的导入，因为它允许我查看文件中使用的所有外部引用，而无需查看整个文件。(是的，我知道它不一定会显示完全限定的引用。但只要有可能，我就会避免使用它们。)|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1737162|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

I prefer specific imports, because it allows me to see all the external references used in the file without looking at the whole file. (Yes, I know it won't necessarily show fully qualified references. But I avoid them whenever possible.)

blocks|key|1522240|text|在以前的一个项目中，我发现将*-imports改为特定的导入可以将编译时间减少一半(从大约10分钟减少到大约5分钟)。*-import让编译器在列出的每个包中搜索与您使用的类匹配的类。虽然这个时间可能很小，但对于大型项目来说，这是很重要的。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1522241|*-import的一个副作用是，开发人员会复制和粘贴常见的导入行，而不是考虑他们需要什么。|1522242|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|F|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|G|8|@]|9|@]|A|$]]|$1|D|3|-4|5|6|7|H|8|@]|9|@]|A|$]]]|E|$]]

In a previous project I found that changing from *-imports to specific imports reduced compilation time by half (from about 10 minutes to about 5 minutes). The *-import makes the compiler search each of the packages listed for a class matching the one you used. While this time can be small, it adds up for large projects.

A side affect of the *-import was that developers would copy and paste common import lines rather than think about what they needed.

blocks|key|1737378|text|最重要的一点是，导入java.awt.*可能会使您的程序与未来的Java版本不兼容：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1737379|假设您有一个名为"ABC“的类，您正在使用JDK8并导入java.util.*。现在，假设Java9出现了，它在java.util包中有一个新的类，碰巧也被称为"ABC“。您的程序现在不能在Java9上编译，因为编译器不知道名为"ABC“的您是指自己的类还是java.awt中的新类。|1737380|当您只显式地从您实际使用的java.awt导入那些类时，就不会出现这个问题。|1737381|资源：|1737382|Java+Imports|1737383|entityMap|0|LINK|mutability|MUTABLE|url|https://coderanch.com/t/488764/java/java/import-java-util-List-faster^0|A|A|0|S|B|1K|9|3L|8|0|D|8|0|0|0|C|0|0^^$0|@$1|2|3|4|5|6|7|V|8|@$9|W|A|X|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|Y|8|@$9|Z|A|10|B|C]|$9|11|A|12|B|C]|$9|13|A|14|B|C]]|D|@]|E|$]]|$1|H|3|I|5|6|7|15|8|@$9|16|A|17|B|C]]|D|@]|E|$]]|$1|J|3|K|5|6|7|18|8|@]|D|@]|E|$]]|$1|L|3|M|5|6|7|19|8|@]|D|@$9|1A|A|1B|1|1C]]|E|$]]|$1|N|3|-4|5|6|7|1D|8|@]|D|@]|E|$]]]|O|$P|$5|Q|R|S|E|$T|U]]]]

The most important one is that importing <code>java.awt.*</code> can make your program incompatible with a future Java version: 

Suppose that you have a class named "ABC", you're using JDK 8 and you import <code>java.util.*</code>. Now, suppose that Java 9 comes out, and it has a new class in package <code>java.util</code> that by coincidence also happens to be called "ABC". Your program now will not compile on Java 9, because the compiler doesn't know if with the name "ABC" you mean your own class or the new class in <code>java.awt</code>. 

You won't have that problem when you import only those classes explicitly from <code>java.awt</code> that you actually use. 

Resources:

<a href="https://coderanch.com/t/488764/java/java/import-java-util-List-faster" rel="nofollow">Java Imports</a>

blocks|key|1737428|text|对于记录:当您添加导入时，您也在指示您的依赖项。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1737429|您可以快速查看文件的依赖关系(不包括具有相同名称空间的类)。|1737430|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|F|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|G|8|@]|9|@]|A|$]]|$1|D|3|-4|5|6|7|H|8|@]|9|@]|A|$]]]|E|$]]

For the record:
When you add an import, you are also indicating your dependencies.

You could see quickly what are the dependencies of files (excluding classes of the same namespace).

blocks|key|1737548|text|忘记杂乱的名称空间吧……想想那些必须在GitHub、vi、Notepad%2B%2B或其他非集成开发环境的文本编辑器中阅读和理解您的代码的可怜的人。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1737549|这个人必须费力地在每个通配符作用域中查找来自一个通配符的每个令牌和所有类和引用……只是想弄清楚到底是怎么回事。|1737550|如果你只为编译器编写代码--你知道你在做什么--我相信通配符是没有问题的。|1737551|但是，如果其他人--包括未来的你--想要在一次阅读中快速理解某个特定的代码文件，那么显式引用会有很大帮助。|1737552|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|J|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|K|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|L|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|M|8|@]|9|@]|A|$]]|$1|H|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|I|$]]

Forget about cluttered namespaces... And consider the poor soul who has to read and understand your code on GitHub, in vi, Notepad++, or some other non-IDE text editor.
That person has to painstakingly look up every token that comes from one of the wildcards against all the classes and references in each wildcarded scope... just to figure out what in the heck is going on.
If you're writing code for the compiler only - and you know what you're doing - I'm sure there's no problem with wildcards.
But if other people - including future you - want to quickly make sense of a particular code file on one reading, then explicit references help a lot.

blocks|key|1522479|text|导入包中的所有类被认为是一种盲目的方法。这样做的一个主要原因是它使类命名空间变得混乱，并可能导致具有相同名称的不同包中的类之间的冲突。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1522480|具体地说，填充必要的类可以避免这个问题，并清楚地显示需要哪些版本。这对代码的可维护性很好。|1522481|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|F|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|G|8|@]|9|@]|A|$]]|$1|D|3|-4|5|6|7|H|8|@]|9|@]|A|$]]]|E|$]]

Importing all the classes in a package is considered a blind approach. A major reason for this is that it clutters the class namespace and could lead to conflicts between classes in different packages with the same name.
Specifically populating the necessary classes avoids that problem and clearly shows which versions were wanted. This is good for code maintainability.

blocks|key|1737628|text|使用通配符导入并不是坏事，因为Oracle的Java教程使用通配符导入。我不认为Oracle的Java人员会做错事。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1737629|请看这里：https://docs.oracle.com/javase/tutorial/uiswing/examples/components/CustomComboBoxDemoProject/src/components/CustomComboBoxDemo.java|offset|length|1737630|上面的程序使用通配符导入：|1737631|import+java.awt.*;
import+java.awt.event.*;
import+javax.swing.*;|code-block|syntax|javascript|1737632|你可以在这里看到更多的程序：https://docs.oracle.com/javase/tutorial/uiswing/examples/components/。|1737633|entityMap|0|LINK|mutability|MUTABLE|url|https://docs.oracle.com/javase/tutorial/uiswing/examples/components/CustomComboBoxDemoProject/src/components/CustomComboBoxDemo.java|1|https://docs.oracle.com/javase/tutorial/uiswing/examples/components/^0|0|5|3O|0|0|0|0|E|1W|1|0^^$0|@$1|2|3|4|5|6|7|Y|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|Z|8|@]|9|@$D|10|E|11|1|12]]|A|$]]|$1|F|3|G|5|6|7|13|8|@]|9|@]|A|$]]|$1|H|3|I|5|J|7|14|8|@]|9|@]|A|$K|L]]|$1|M|3|N|5|6|7|15|8|@]|9|@$D|16|E|17|1|18]]|A|$]]|$1|O|3|-4|5|6|7|19|8|@]|9|@]|A|$]]]|P|$Q|$5|R|S|T|A|$U|V]]|W|$5|R|S|T|A|$U|X]]]]

Using wild card imports is not bad because Java tutorials by Oracle use wild card imports. I don't think that Java folks at Oracle would do wrong thing.
Please look here: <a href="https://docs.oracle.com/javase/tutorial/uiswing/examples/components/CustomComboBoxDemoProject/src/components/CustomComboBoxDemo.java" rel="nofollow noreferrer">https://docs.oracle.com/javase/tutorial/uiswing/examples/components/CustomComboBoxDemoProject/src/components/CustomComboBoxDemo.java</a>
The above program uses wild card imports:
<pre><code>import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
</code></pre>
You can look at more programs here:
<a href="https://docs.oracle.com/javase/tutorial/uiswing/examples/components/" rel="nofollow noreferrer">https://docs.oracle.com/javase/tutorial/uiswing/examples/components/</a>.

It is much more convenient and cleaner to use a single statement like

<pre><code>import java.awt.*;
</code></pre>

than to import a bunch of individual classes

<pre><code>import java.awt.Panel;
import java.awt.Graphics;
import java.awt.Canvas;
...
</code></pre>

What is wrong with using a wildcard in the <code>import</code> statement?

Why is using a wild card with a Java import statement bad?

集成开发环境

编译器

GitHub

Java

使用像这样的单个语句会更方便、更简洁import java.awt.*;而不是导入一堆单独的类import java.awt.Panel;import java.awt.Graphics;import java.awt.Canvas;...在import语句中使用通配符有什么问题？

问为什么在Java import语句中使用通配符是不好的？
EN

回答 8

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问为什么在Java import语句中使用通配符是不好的？EN

回答 8

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问为什么在Java import语句中使用通配符是不好的？
EN