Importieren von zwei Klassen mit demselben Namen. Wie verwendet man?

Angenommen, ich habe einen Code wie:

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 ?

  }
}

Sollte ich voll qualifizierte Klassennamen sein? Kann ich die Importanweisungen entfernen? Ist ein solches Szenario in der realen Programmierung üblich?

Sie können die Importanweisungen weglassen und über den gesamten Pfad auf sie verweisen. Z.B:

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

Aber ich würde sagen, dass die Verwendung von zwei Klassen mit demselben Namen und einer ähnlichen Funktion normalerweise nicht die beste Idee ist, es sei denn, Sie können wirklich klarstellen, welche welche ist.

Verwenden Sie den vollständig qualifizierten Namen, anstatt die Klasse zu importieren.

z.B

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

Ja, wenn Sie Klassen mit denselben einfachen Namen importieren, müssen Sie sie mit ihren vollständig qualifizierten Klassennamen referenzieren. Ich würde die import-Anweisungen belassen, da sie anderen Entwicklern einen Eindruck davon vermitteln, was in der Datei enthalten ist, wenn sie damit arbeiten.

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

Eine andere Möglichkeit ist die Unterklasse:

package my.own;

public class FQNDate extends Date {

}

Importieren Sie dann my.own.FQNDate in Pakete mit java.util.Date.

Wenn Sie eine eigene Datumsklasse haben, sollten Sie diese von der integrierten Datumsklasse unterscheiden. dh warum hast du deine eigenen erstellt? So etwas wie ImmutableDate oder BetterDate oder NanoDate würde sogar MyDate angeben, warum Sie Ihre eigene Datumsklasse haben. In diesem Fall haben sie einen eindeutigen Namen.

Sie können eine davon mit import importieren. Für alle anderen ähnlichen Klassen müssen Sie vollständig qualifizierte Klassennamen angeben. Andernfalls wird ein Kompilierungsfehler angezeigt.

Z.B:

import java.util.Date;

class Test{

  public static void main(String [] args){

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

    // util.Date
    Date utilDate;
  }
}

Dieses Szenario ist in der realen Programmierung nicht so häufig, aber auch nicht so seltsam. Es kommt manchmal vor, dass zwei Klassen in verschiedenen Paketen denselben Namen haben und wir beide benötigen.

Es ist nicht zwingend erforderlich, dass wenn zwei Klassen denselben Namen haben, beide dieselben Funktionen enthalten und wir nur eine davon auswählen sollten.

Wenn wir beides brauchen, schadet es nicht, das zu benutzen. Und es ist auch keine schlechte Programmieridee.

Wir sollten jedoch vollständig qualifizierte Namen der Klassen (die denselben Namen haben) verwenden, um zu verdeutlichen, auf welche Klasse wir uns ebenfalls beziehen.

:) :)

Ich bin auf dieses Problem gestoßen, wenn ich beispielsweise eine Klasse einer anderen zugeordnet habe (z. B. wenn ich zu einer neuen Gruppe von Klassen gewechselt bin, um Personendaten darzustellen). Zu diesem Zeitpunkt benötigen Sie beide Klassen, da dies der springende Punkt des Codes ist - um eine der anderen zuzuordnen. Und Sie können die Klassen an beiden Orten nicht umbenennen (wieder besteht die Aufgabe darin, zuzuordnen, nicht zu ändern, was jemand anderes getan hat).

Voll qualifiziert ist eine Möglichkeit. Es scheint, dass Sie nicht beide Importanweisungen einschließen können, da Java sich beispielsweise Sorgen darüber macht, welche "Person" gemeint ist.

Wenn Sie wirklich denselben Klassennamen aus zwei verschiedenen Paketen verwenden möchten oder müssen, haben Sie zwei Möglichkeiten:

1 Wählen Sie eine aus, die beim Import verwendet werden soll, und verwenden Sie den vollständig qualifizierten Klassennamen der anderen:

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-Verwenden Sie immer den vollständig qualifizierten Klassennamen:

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

  }
}

Ich hatte nur das gleiche Problem, was ich getan habe, ich habe die Bibliotheksreihenfolge nacheinander angeordnet, zum Beispiel gab es java.lang.NullPointerException und javacard.lang.NullPointerException. Ich habe die erste als Standardbibliothek erstellt. Wenn Sie die andere verwenden müssen, können Sie den vollständigen qualifizierten Klassennamen explizit angeben.

Wenn Sie Klassen mit demselben Namen aufrufen, müssen Sie das Paket, von dem aus die Klasse aufgerufen wird, explizit angeben.

Sie können dies wie folgt tun:

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

Ausgabe:

Foo{first class}
Foo{second class}