blocks|key|1357168|text|您可以省略import语句，并使用整个路径引用它们。例如：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1357169|java.util.Date+javaDate+=+new+java.util.Date()
my.own.Date+myDate+=+new+my.own.Date();|code-block|syntax|javascript|1357170|但我要说的是，使用两个具有相同名称和相似函数的类通常不是最好的主意，除非你能真正弄清楚哪一个是哪个。|1357171|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|$]]

You can omit the import statements and refer to them using the entire path. Eg:

<pre><code>java.util.Date javaDate = new java.util.Date()
my.own.Date myDate = new my.own.Date();
</code></pre>

But I would say that using two classes with the same name and a similiar function is usually not the best idea unless you can make it really clear which is which.

blocks|key|1142174|text|使用完全限定名称，而不是导入类。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1142175|例如：|1142176|//import+java.util.Date;+//delete+this
//import+my.own.Date;

class+Test{

+++public+static+void+main(String+[]+args){

++++++//+I+want+to+choose+my.own.Date+here.+How?
++++++my.own.Date+myDate+=+new+my.own.Date();

++++++//+I+want+to+choose+util.Date+here.+How+?
++++++java.util.Date+javaDate+=+new+java.util.Date();
+++}
}|code-block|syntax|javascript|1142177|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|L|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|M|8|@]|9|@]|A|$G|H]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

use the fully qualified name instead of importing the class. 

e.g.

<pre><code>//import java.util.Date; //delete this
//import my.own.Date;

class Test{

 public static void main(String [] args){

 // I want to choose my.own.Date here. How?
 my.own.Date myDate = new my.own.Date();

 // I want to choose util.Date here. How ?
 java.util.Date javaDate = new java.util.Date();
 }
}
</code></pre>

blocks|key|1357245|text|是的，当您导入具有相同简单名称的类时，您必须通过它们的完全限定类名来引用它们。我会保留import语句，因为当其他开发人员使用文件时，它可以让他们对文件中的内容有一种感觉。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1357246|java.util.Data+date1+=+new+java.util.Date();
my.own.Date+date2+=+new+my.own.Date();|code-block|syntax|javascript|1357247|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Yes, when you import classes with the same simple names, you must refer to them by their fully qualified class names. I would leave the import statements in, as it gives other developers a sense of what is in the file when they are working with it.

<pre><code>java.util.Data date1 = new java.util.Date();
my.own.Date date2 = new my.own.Date();
</code></pre>

blocks|key|1142398|text|另一种方法是将其子类化：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1142399|package+my.own;

public+class+FQNDate+extends+Date+{

}|code-block|syntax|javascript|1142400|然后在包含java.util.Date的包中导入my.own.FQNDate。|1142401|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|$]]

Another way to do it is subclass it:

<pre><code>package my.own;

public class FQNDate extends Date {

}
</code></pre>

And then import my.own.FQNDate in packages that have java.util.Date.

blocks|key|1142366|text|如果你有自己的date类，你应该把它和内置的Date类区分开来。也就是说，你为什么要创建你自己的。像ImmutableDate或BetterDate或NanoDate，甚至MyDate这样的东西都会指出为什么你有自己的date类。在这种情况下，它们将有一个唯一的名称。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1142367|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|$]]

If you have your own date class you should distinguish it form the built in Date class. i.e. why did you create your own. Something like ImmutableDate or BetterDate or NanoDate, even MyDate would indicate why you have your own date class. In this case, they will have a unique name.

blocks|key|1357488|text|您可以使用import导入其中一个。对于所有其他类似的类，您需要指定完全限定的类名。否则你会得到编译错误。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1357489|例如：|1357490|import+java.util.Date;

class+Test{

++public+static+void+main(String+[]+args){

++++//+your+own+date
++++my.own.Date+myOwndate+;

++++//+util.Date
++++Date+utilDate;
++}
}|code-block|syntax|javascript|1357491|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|L|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|M|8|@]|9|@]|A|$G|H]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

You can import one of them using import. For all other similar class , you need to specify Fully qualified class names. Otherwise you will get compilation error.

Eg:

<pre><code>import java.util.Date;

class Test{

 public static void main(String [] args){

 // your own date
 my.own.Date myOwndate ;

 // util.Date
 Date utilDate;
 }
}
</code></pre>

blocks|key|1357301|text|这种情况在现实世界的编程中并不常见，但也不是那么奇怪。有时，不同包中的两个类具有相同的名称，而我们需要这两个类。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1357302|如果两个类具有相同的名称，那么这两个类都将包含相同的功能，这并不是强制性的，我们应该只选择其中一个。|1357303|如果我们两者都需要，那么使用它并没有什么坏处。而且这也是一个不错的编程想法。|1357304|但我们应该使用类的完全限定名(具有相同的名称)，以便明确我们引用的是哪个类。|1357305|:)|1357306|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|L|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|M|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|N|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|O|8|@]|9|@]|A|$]]|$1|H|3|I|5|6|7|P|8|@]|9|@]|A|$]]|$1|J|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|K|$]]

This scenario is not so common in real-world programming, but not so strange too. It happens sometimes that two classes in different packages have same name and we need both of them.

It is not mandatory that if two classes have same name, then both will contain same functionalities and we should pick only one of them.

If we need both, then there is no harm in using that. And it's not a bad programming idea too.

But we should use fully qualified names of the classes (that have same name) in order to make it clear which class we are referring too.

:)

blocks|key|1357610|text|如果您确实希望或需要使用来自两个不同包的相同类名，您有两个选择：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1357611|1-选择一个在导入中使用，并使用另一个的完全限定类名：|1357612|import+my.own.Date;

class+Test{

+++++public+static+void+main(String[]+args){

++++++++//+I+want+to+choose+my.own.Date+here.+How?
++++++++//Answer:
++++++++Date+ownDate+=+new+Date();

++++++++//+I+want+to+choose+util.Date+here.+How+?
++++++++//Answer:
++++++++java.util.Date+utilDate+=+new+java.util.Date();

+++++}
}|code-block|syntax|javascript|1357613|2-始终使用完全限定的类名：|1357614|//no+Date+import
class+Test{

++public+static+void+main(String[]+args){

++++//+I+want+to+choose+my.own.Date+here.+How?
++++//Answer:
+++++my.own.Date+ownDate+=+new+my.own.Date();
++++//+I+want+to+choose+util.Date+here.+How+?
++++//Answer:
+++++java.util.Date+utilDate+=+new+java.util.Date();

++}
}|1357615|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|P|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|Q|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|R|8|@]|9|@]|A|$]]|$1|K|3|L|5|F|7|S|8|@]|9|@]|A|$G|H]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

If you really want or need to use the same class name from two different packages, you have two options: 
1-pick one to use in the import and use the other's fully qualified class name:

<pre><code>import my.own.Date;

class Test{

 public static void main(String[] args){

 // I want to choose my.own.Date here. How?
 //Answer:
 Date ownDate = new Date();

 // I want to choose util.Date here. How ?
 //Answer:
 java.util.Date utilDate = new java.util.Date();

 }
}
</code></pre>

 

2-always use the fully qualified class name:

<pre><code>//no Date import
class Test{

 public static void main(String[] args){

 // I want to choose my.own.Date here. How?
 //Answer:
 my.own.Date ownDate = new my.own.Date();
 // I want to choose util.Date here. How ?
 //Answer:
 java.util.Date utilDate = new java.util.Date();

 }
}
</code></pre>

blocks|key|1357446|text|例如，我在将一个类映射到另一个类时遇到了这个问题(例如，当切换到一组新的类来表示person数据时)。此时，您需要这两个类，因为这是代码的全部要点--将一个类映射到另一个类。并且您不能在这两个地方重命名类(同样，工作是映射，而不是去更改其他人所做的)。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1357447|完全合格是一种方法。看起来您实际上不能同时包含两个import语句，例如，Java会担心哪个"Person“是指哪个”Person“。|1357448|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|$]]

I hit this issue when, for example, mapping one class to another (such as when switching to a new set of classes to represent person data). At that point, you need both classes because that is the whole point of the code--to map one to the other. And you can't rename the classes in either place (again, the job is to map, not to go change what someone else did).

Fully qualified is one way. It appears you can't actually include both import statements, because Java gets worried about which "Person" is meant, for example.

blocks|key|1357567|text|我只是遇到了同样的问题，我所做的是，我按顺序安排了库的顺序，例如，有java.lang.NullPointerException和javacard.lang.NullPointerException。我将第一个库设置为默认库，如果需要使用另一个库，则可以显式指定完全限定的类名。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1357568|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 just had the same problem, what I did, I arranged the library order in sequence, for example there were java.lang.NullPointerException and javacard.lang.NullPointerException. I made the first one as default library and if you needed to use the other you can explicitly specify the full qualified class name.

blocks|key|1142639|text|当调用具有相同名称的类时，必须显式指定从中调用类的包。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1142640|你可以这样做：|1142641|import+first.Foo;

public+class+Main+{
++++public+static+void+main(String[]+args)+{
++++++++System.out.println(new+Foo());
++++++++System.out.println(new+second.Foo());
++++}
}



package+first;

public+class+Foo+{
++++public+Foo()+{
++++}

++++@Override
++++public+String+toString()+{
++++++++return+"Foo{first+class}";
++++}
}



package+second;

public+class+Foo+{
++++public+Foo()+{
++++}

++++@Override
++++public+String+toString()+{
++++++++return+"Foo{second+class}";
++++}
}|code-block|syntax|javascript|1142642|输出：|1142643|Foo{first+class}
Foo{second+class}|1142644|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|P|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|Q|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|R|8|@]|9|@]|A|$]]|$1|K|3|L|5|F|7|S|8|@]|9|@]|A|$G|H]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

When you call classes with the same names, you must explicitly specify the package from which the class is called.

You can to do like this:

<pre><code>import first.Foo;

public class Main {
 public static void main(String[] args) {
 System.out.println(new Foo());
 System.out.println(new second.Foo());
 }
}



package first;

public class Foo {
 public Foo() {
 }

 @Override
 public String toString() {
 return "Foo{first class}";
 }
}



package second;

public class Foo {
 public Foo() {
 }

 @Override
 public String toString() {
 return "Foo{second class}";
 }
}
</code></pre>

Output:

<pre><code>Foo{first class}
Foo{second class}
</code></pre>

Say I've a code like:

<pre><code>import java.util.Date;
import my.own.Date;

class Test{

 public static void main(String [] args){

 // I want to choose my.own.Date here. How?
 ..
 // I want to choose util.Date here. How ?

 }
}
</code></pre>

Should I be full qualified class names? Can I get rid of the import statements? Is such a scenario common in real world programming?

Importing two classes with same name. How to handle?

Java

假设我有这样一段代码：import java.util.Date;import my.own.Date;class Test{  public static void main(String [] args){    // I want to choose my.own.Date here. How?    ..    // I want to choose util.Date here. How

问导入两个同名的类。怎么处理？
EN

回答 11

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问导入两个同名的类。怎么处理？EN

回答 11

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问导入两个同名的类。怎么处理？
EN