Question

说我的代码如下：

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 ?

  }
}

我应该是完全合格的班级名字吗？我能摆脱进口声明吗？这种场景在现实世界的编程中是否常见？

Answer 1

您可以省略import语句并使用整个路径引用它们。例如：

java.util.Date javaDate = new java.util.Date()
my.own.Date myDate = new my.own.Date();

但是我会说使用两个具有相同名称和类似功能的类通常不是最好的主意，除非你能清楚地知道它是哪个。

Answer 2

使用完全限定名称而不是导入类。

e.g。

//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();
   }
}

Answer 3

是的，当您导入具有相同简单名称的类时，必须通过其完全限定的类名称来引用它们。我会留下import语句，因为它可以让其他开发人员了解文件在使用时的含义。

java.util.Data date1 = new java.util.Date();
my.own.Date date2 = new my.own.Date();

Answer 4

另一种方法是将它子类化：

package my.own;

public class FQNDate extends Date {

}

然后在包含java.util.Date的包中导入my.own.FQNDate。

Answer 5

如果您有自己的日期类，则应将其与内置的Date类区分开来。也就是你为什么创造自己的。像ImmutableDate或BetterDate或NanoDate之类的东西，甚至MyDate都会说明为什么你有自己的日期类。在这种情况下，它们将具有唯一的名称。

Answer 6

您可以使用导入导入其中一个。对于所有其他类似的类，您需要指定完全限定的类名。否则您将收到编译错误。

例如：

import java.util.Date;

class Test{

  public static void main(String [] args){

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

    // util.Date
    Date utilDate;
  }
}

Answer 7

这种情况在现实世界的编程中并不常见，但也不是那么奇怪。有时，不同包中的两个类具有相同的名称，我们需要它们。

如果两个类具有相同的名称，那么两个类都将包含相同的功能并且我们应该只选择其中一个，这不是强制性的。

如果我们两者都需要，那么使用它是没有害处的。而且这也不是一个糟糕的编程想法。

但是我们应该使用类的完全限定名（具有相同的名称），以便明确我们所引用的类。

：）

Answer 8

我遇到了这个问题，例如，将一个类映射到另一个类（例如切换到一组新的类来表示人员数据时）。此时，您需要这两个类，因为这是代码的全部要点 - 将一个映射到另一个。并且你不能在任何一个地方重命名这些类（再次，工作是映射，而不是改变其他人所做的）。

完全合格是一种方式。看起来你实际上不能同时包含两个import语句，因为例如，Java会担心“Person”的含义。

Answer 9

如果您真的想要或需要使用两个不同包装中的相同类名，您有两种选择：

1 - 选择一个用于导入并使用其他完全限定的类名：

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();

     }
}

2 - 始终使用完全限定的类名：

//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();

  }
}

Answer 10

我遇到了同样的问题，我做了什么，我按顺序排列了库顺序，例如java.lang.NullPointerException和javacard.lang.NullPointerException。我将第一个作为默认库，如果你需要使用另一个，你可以明确指定完整的限定类名。

Answer 11

调用具有相同名称的类时，必须显式指定从中调用该类的包。

您可以这样做：

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}";
    }
}

输出：

Foo{first class}
Foo{second class}

导入两个具有相同名称的类。如何处理？

11 个答案: