blocks|key|3040858|text|java.awt.*与java.awt.event.*不同，第一个类将导入java.awt包中的所有类，而第二个类将导入java.awt.event中的所有类，导入函数将只导入类，而不是包。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|3040859|entityMap^0|0|A|B|G|11|8|1O|E|0^^$0|@$1|2|3|4|5|6|7|H|8|@$9|I|A|J|B|C]|$9|K|A|L|B|C]|$9|M|A|N|B|C]|$9|O|A|P|B|C]]|D|@]|E|$]]|$1|F|3|-4|5|6|7|Q|8|@]|D|@]|E|$]]]|G|$]]

<code>java.awt.*</code> is different with <code>java.awt.event.*</code>, the first one will import all the classes within <code>java.awt</code> package, while the second one will import all the classes within <code>java.awt.event</code>, the import function will only import classes, not packages.

blocks|key|3040890|text|Java中的“通配符”导入只在实现类的直接级别上工作。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3040891|也就是说，如果您有类A、B和C，并且具有完全限定的名称：|offset|length|style|CODE|3040892|com.foo.bar.A；|unordered-list-item|3040893|com.foo.bar.B；|3040894|com.foo.C；|3040895|然后，导入com.foo.bar.*将允许对A和B的访问，而无需进一步的限制；但是C将不可用。|3040896|同样，进口com.foo.*很容易获得C，但A和B则不然。|3040897|现在：|3040898|我认为，如果您包含了一个类，就像上两个示例中的那样，您可以有效地导入该类并继承它的所有子类。|blockquote|3040899|事实并非如此。即使B“继承”了A，如果您选择使用完全限定的导入com.foo.bar.A，它也不会自动导入com.foo.bar.B。您必须分别导入B。这是有意义的:没有任何东西强迫接口或抽象类的实现与它们的基本接口/基类在同一个包中；在同一个项目中，您可能在不同的包中有两个名为B的类:编译器应该做什么？|3040900|现在，根据编码风格的约定(您可以自己弥补，或者在工作环境中必须遵守这些约定)，这种通配符导入可能是纯粹的和简单的禁止的，您必须分别导入A和B。至于静态进口，他们还有其他问题.|3040901|最后，请注意，默认情况下，您可以使用所有的java.lang.*，而不必声明导入。|3040902|entityMap^0|0|A|1|C|1|E|1|0|0|D|0|0|D|0|0|9|0|5|D|M|1|O|1|15|1|0|5|9|J|1|M|1|O|1|0|0|0|9|1|F|1|V|D|1H|D|22|1|3W|1|0|1V|1|1X|1|0|L|B|0^^$0|@$1|2|3|4|5|6|7|15|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|16|8|@$D|17|E|18|F|G]|$D|19|E|1A|F|G]|$D|1B|E|1C|F|G]]|9|@]|A|$]]|$1|H|3|I|5|J|7|1D|8|@$D|1E|E|1F|F|G]]|9|@]|A|$]]|$1|K|3|L|5|J|7|1G|8|@$D|1H|E|1I|F|G]]|9|@]|A|$]]|$1|M|3|N|5|J|7|1J|8|@$D|1K|E|1L|F|G]]|9|@]|A|$]]|$1|O|3|P|5|6|7|1M|8|@$D|1N|E|1O|F|G]|$D|1P|E|1Q|F|G]|$D|1R|E|1S|F|G]|$D|1T|E|1U|F|G]]|9|@]|A|$]]|$1|Q|3|R|5|6|7|1V|8|@$D|1W|E|1X|F|G]|$D|1Y|E|1Z|F|G]|$D|20|E|21|F|G]|$D|22|E|23|F|G]]|9|@]|A|$]]|$1|S|3|T|5|6|7|24|8|@]|9|@]|A|$]]|$1|U|3|V|5|W|7|25|8|@]|9|@]|A|$]]|$1|X|3|Y|5|6|7|26|8|@$D|27|E|28|F|G]|$D|29|E|2A|F|G]|$D|2B|E|2C|F|G]|$D|2D|E|2E|F|G]|$D|2F|E|2G|F|G]|$D|2H|E|2I|F|G]]|9|@]|A|$]]|$1|Z|3|10|5|6|7|2J|8|@$D|2K|E|2L|F|G]|$D|2M|E|2N|F|G]]|9|@]|A|$]]|$1|11|3|12|5|6|7|2O|8|@$D|2P|E|2Q|F|G]]|9|@]|A|$]]|$1|13|3|-4|5|6|7|2R|8|@]|9|@]|A|$]]]|14|$]]

The "wildcard" imports in Java only work to the immediate level at which classes are implemented.

That is, if you have classes <code>A</code>, <code>B</code> and <code>C</code>, with fully qualified names:

<ul>
<li><code>com.foo.bar.A</code>;</li>
<li><code>com.foo.bar.B</code>;</li>
<li><code>com.foo.C</code>;</li>
</ul>

then importing <code>com.foo.bar.*</code> will allow access to <code>A</code> and <code>B</code> without further ado; but <code>C</code> will NOT be available.

In the same vein, importing <code>com.foo.*</code> will readily have <code>C</code> available, but not <code>A</code> and <code>B</code>.

Now:

<blockquote>
 I thought that if you included a class, like in the last two example, that you effectively imported that class and inherited all of its subclasses.
</blockquote>

It does not. Even if <code>B</code> "inherits" <code>A</code>, if you choose to use the fully qualified import <code>com.foo.bar.A</code>, it WILL NOT automatically import <code>com.foo.bar.B</code>. You'll have to import <code>B</code> separately. Which makes sense: nothing forces implementations of an interface or abstract class to be in the same package as their base interface/base class, for one; and in the same project, you may have two classes named <code>B</code>, in different packages: what should the compiler do?

Now, according to coding style conventions, which you either make up for yourself or have to obey in your work environment, such wildcard imports may be purely and simply forbidden, and you'll have to import <code>A</code> and <code>B</code> separately. As to static imports, they have other problems...

Finally, note that by default, you can use all of <code>java.lang.*</code> without having to declare an import.

blocks|key|2252775|text|来自Java教程：包的表观层次结构|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|2252776|起初，包似乎是分层的，但它们不是。例如，java.awt包括一个java.awt包、一个java.awt.color包、一个java.awt.font包以及许多以java.awt开头的包。但是，java.awt.color包、java.awt.font包和其他java.awt.xxxx包不包括在java.awt包中。前缀java.awt+(Java抽象窗口工具包)用于许多相关包，以使关系变得明显，但不显示包含。
导入java.awt.*导入java.awt包中的所有类型，但它不导入java.awt.color、java.awt.font或任何其他java.awt.xxxx包。如果计划使用java.awt.color中的类和其他类型以及java.awt中的类和其他类型，则必须导入两个包及其所有文件：
import+java.awt.*;
import+java.awt.color.*;|blockquote|style|CODE|2252777|entityMap|0|LINK|mutability|MUTABLE|url|http://docs.oracle.com/javase/tutorial/java/package/usepkgs.html^0|9|8|0|0|W|8|18|E|1Q|D|2P|E|35|D|3M|D|44|8|4H|8|5U|A|66|8|6R|E|76|D|7O|D|89|E|9U|I|AD|O|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@$A|R|B|S|1|T]]|C|$]]|$1|D|3|E|5|F|7|U|8|@$A|V|B|W|G|H]|$A|X|B|Y|G|H]|$A|Z|B|10|G|H]|$A|11|B|12|G|H]|$A|13|B|14|G|H]|$A|15|B|16|G|H]|$A|17|B|18|G|H]|$A|19|B|1A|G|H]|$A|1B|B|1C|G|H]|$A|1D|B|1E|G|H]|$A|1F|B|1G|G|H]|$A|1H|B|1I|G|H]|$A|1J|B|1K|G|H]|$A|1L|B|1M|G|H]|$A|1N|B|1O|G|H]|$A|1P|B|1Q|G|H]]|9|@]|C|$]]|$1|I|3|-4|5|6|7|1R|8|@]|9|@]|C|$]]]|J|$K|$5|L|M|N|C|$O|P]]]]

From the Java Tutorials: <a href="http://docs.oracle.com/javase/tutorial/java/package/usepkgs.html" rel="nofollow noreferrer">Apparent Hierarchies of Packages</a>
<blockquote>
At first, packages appear to be hierarchical, but they are not. For example, the Java API includes a <code>java.awt</code> package, a <code>java.awt.color</code> package, a <code>java.awt.font</code> package, and many others that begin with java.awt. However, the <code>java.awt.color</code> package, the <code>java.awt.font</code> package, and other <code>java.awt.xxxx</code> packages are not included in the <code>java.awt</code> package. The prefix <code>java.awt</code> (the Java Abstract Window Toolkit) is used for a number of related packages to make the relationship evident, but not to show inclusion.
Importing <code>java.awt.*</code> imports all of the types in the <code>java.awt</code> package, but it does not import <code>java.awt.color</code>, <code>java.awt.font</code>, or any other <code>java.awt.xxxx</code> packages. If you plan to use the classes and other types in <code>java.awt.color</code> as well as those in java.awt, you must import both packages with all their files:
<code>import java.awt.*;</code>
<code>import java.awt.color.*;</code>
</blockquote>

blocks|key|931291|text|请记住，import语句只是为了方便。在这里，您可以使用类的短名称，而不是完全限定的名称。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|931292|Java中的包名结构对应于目录结构。因此，您可以将其视为一个名为java的目录，在该目录中还有其他几个目录，如awt和io等。|931293|当你说|931294|import+java.awt.*;|code-block|syntax|javascript|931295|基本上，您想要对名为java的目录中名为awt的目录中的所有类使用短名称。因此，如果在代码中使用类名，如下所示：|931296|+++List+mylist;|931297|然后编译器将尝试在当前包中找到一个名为List的类或一个名为java.awt.List的类。|931298|因此，如果在awt目录中有一个名为event的目录，并且在该目录中有一个名为ActionEvent的类，那么完全限定的名称是：|931299|++java.awt.event.ActionEvent|931300|上面的导入声明没有帮助。因此，需要另一条导入语句的原因|931301|++import+java.awt.event.*;|931302|现在，如果使用类ActionEvent，编译器将在当前目录中查找名为ActionEvent的类，或者查找java.awt.ActionEvent或java.awt.event.ActionEvent，直到找到类为止。|931303|entityMap^0|0|0|0|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|12|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|13|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|14|8|@]|9|@]|A|$]]|$1|F|3|G|5|H|7|15|8|@]|9|@]|A|$I|J]]|$1|K|3|L|5|6|7|16|8|@]|9|@]|A|$]]|$1|M|3|N|5|H|7|17|8|@]|9|@]|A|$I|J]]|$1|O|3|P|5|6|7|18|8|@]|9|@]|A|$]]|$1|Q|3|R|5|6|7|19|8|@]|9|@]|A|$]]|$1|S|3|T|5|H|7|1A|8|@]|9|@]|A|$I|J]]|$1|U|3|V|5|6|7|1B|8|@]|9|@]|A|$]]|$1|W|3|X|5|H|7|1C|8|@]|9|@]|A|$I|J]]|$1|Y|3|Z|5|6|7|1D|8|@]|9|@]|A|$]]|$1|10|3|-4|5|6|7|1E|8|@]|9|@]|A|$]]]|11|$]]

Remember that the import statement is just for convenience. It is there to make it possible for you to use the short name of a class rather than the fully qualified name.

The package name structure in Java corresponds to a directory structure. So you can think of it as a directory named java and in that directory there are several other directories such as awt and io etc.

When you say

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

you are basically saying that you want to use the short name for all the classes in the directory named awt inside the directory named java. So if you use a class name in your code like this:

<pre><code> List mylist;
</code></pre>

Then the compiler will attempt to find either a class named List in the current package or a class named java.awt.List. 

So if you have a directory inside the awt directory called event and you have a class named ActionEvent in that directory, the fully qualified name is:

<pre><code> java.awt.event.ActionEvent
</code></pre>

and the import statement above does not help. Hence the reason for needing another import statement

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

Now, if you use the class ActionEvent the compiler looks for a class named ActionEvent in the current directory, or java.awt.ActionEvent or java.awt.event.ActionEvent until it finds one.

blocks|key|2252861|text|来自Sun关于使用包成员的文档|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|2252862|起初，包似乎是分层的，但它们不是。例如，Java包括一个java.awt包、一个java.awt.color包、一个java.awt.font包以及许多以java.awt开头的包。但是，java.awt.color包、java.awt.font包和其他java.awt.xxxx包不包括在java.awt包中。前缀java.awt+(Java抽象窗口工具包)用于许多相关包，以使关系变得明显，但不显示包含。
导入java.awt.*导入java.awt包中的所有类型，但它不导入java.awt.color、java.awt.font或任何其他java.awt.xxxx包。如果计划使用java.awt.color中的类和其他类型以及java.awt中的类和其他类型，则必须导入两个包及其所有文件：|blockquote|2252863|import+java.awt.*;+
import+java.awt.color.*;|code-block|syntax|javascript|2252864|如果您有时间，您可能会很好地从sun阅读整个包裹都跟着，它深入地讨论了基础知识和更复杂的概念。从问题中的语言来看，您将第二个导入语句称为包含特定类的导入语句，听起来您似乎不明白您实际上是在引用包。|2252865|entityMap|0|LINK|mutability|MUTABLE|url|http://docs.oracle.com/javase/tutorial/java/package/usepkgs.html|1|http://docs.oracle.com/javase/tutorial/java/package/index.html^0|7|5|0|0|0|0|K|7|1|0^^$0|@$1|2|3|4|5|6|7|X|8|@]|9|@$A|Y|B|Z|1|10]]|C|$]]|$1|D|3|E|5|F|7|11|8|@]|9|@]|C|$]]|$1|G|3|H|5|I|7|12|8|@]|9|@]|C|$J|K]]|$1|L|3|M|5|6|7|13|8|@]|9|@$A|14|B|15|1|16]]|C|$]]|$1|N|3|-4|5|6|7|17|8|@]|9|@]|C|$]]]|O|$P|$5|Q|R|S|C|$T|U]]|V|$5|Q|R|S|C|$T|W]]]]

From Sun's documentation on <a href="http://docs.oracle.com/javase/tutorial/java/package/usepkgs.html" rel="nofollow">Using Package Members</a>:

<blockquote>
 At first, packages appear to be hierarchical, but they are not. For example, the Java 
 API includes a java.awt package, a java.awt.color package, a
 java.awt.font package, and many others that begin with java.awt.
 However, the java.awt.color package, the java.awt.font package, and
 other java.awt.xxxx packages are not included in the java.awt package.
 The prefix java.awt (the Java Abstract Window Toolkit) is used for a
 number of related packages to make the relationship evident, but not
 to show inclusion.
 
 Importing java.awt.* imports all of the types in the java.awt package,
 but it does not import java.awt.color, java.awt.font, or any other
 java.awt.xxxx packages. If you plan to use the classes and other types
 in java.awt.color as well as those in java.awt, you must import both
 packages with all their files:
</blockquote>

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

If you have time, you will probably do well to read through <a href="http://docs.oracle.com/javase/tutorial/java/package/index.html" rel="nofollow">the entire Packages trail</a> from sun which goes over the basics and more complicated concepts thoroughly. From the language in your question, where you refer to the second import statements as including particular classes, it sounds like you're not understanding that you're actually referring to packages.

If I say:

<pre><code>import java.awt.event.ActionListener;
</code></pre>

I get the ActionListener Class.
If I say:

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

I get the event class including ActionListener?
Or better yet:

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

I thought that if you included a class, like in the last two example, that you effectively imported that class and inherited all of its subclasses. But, when I use only the last line, for example, Eclipse often shows errors saying it cannot resolve certain items and suggests I include both the java.awt and java.awt.event.

importing classes using wildcards

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

如果我说：import java.awt.event.ActionListener;我得到了ActionListener课程。如果我说：import java.awt.event.*;我得到了包括ActionListener在内的事件类？或者更好的是：import java.awt.*;我认为，如果您包含了一个类，就像...

问使用通配符导入类
EN

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问使用通配符导入类EN

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问使用通配符导入类
EN