Importowanie dwóch klas o tej samej nazwie. Jak radzić sobie?

Powiedz, że mam kod taki jak:

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 ?

  }
}

Czy powinienem mieć pełne kwalifikowane nazwy klas? Czy mogę pozbyć się instrukcji importu? Czy taki scenariusz jest powszechny w programowaniu w świecie rzeczywistym?

Możesz pominąć instrukcje importu i odwołać się do nich, używając całej ścieżki. Na przykład:

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

Powiedziałbym jednak, że używanie dwóch klas o tej samej nazwie i podobnej funkcji zwykle nie jest najlepszym pomysłem, chyba że można jasno określić, która jest która.

użyj w pełni kwalifikowanej nazwy zamiast importować klasę.

na przykład

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

Tak, kiedy importujesz klasy o tych samych prostych nazwach, musisz odwoływać się do nich, używając ich w pełni kwalifikowanych nazw. Pozostawiłbym instrukcje importu w, ponieważ daje to innym programistom poczucie tego, co jest w pliku, gdy z nim pracują.

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

Innym sposobem na to jest podklasa:

package my.own;

public class FQNDate extends Date {

}

A następnie zaimportuj my.own.FQNDate w pakietach, które mają java.util.Date.

Jeśli masz własną klasę Date, powinieneś ją odróżnić od wbudowanej klasy Date. tj. dlaczego stworzyłeś swój własny. Coś w rodzaju ImmutableDate lub BetterDate lub NanoDate, nawet MyDate wskazywałoby, dlaczego masz własną klasę randkową. W takim przypadku będą miały unikalną nazwę.

Możesz zaimportować jeden z nich za pomocą importu. W przypadku wszystkich innych podobnych klas należy określić w pełni kwalifikowane nazwy klas. W przeciwnym razie pojawi się błąd kompilacji.

Na przykład:

import java.util.Date;

class Test{

  public static void main(String [] args){

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

    // util.Date
    Date utilDate;
  }
}

Ten scenariusz nie jest tak powszechny w programowaniu w świecie rzeczywistym, ale też nie jest tak dziwny. Czasami zdarza się, że dwie klasy w różnych pakietach mają tę samą nazwę i potrzebujemy obu.

Nie jest obowiązkowe, że jeśli dwie klasy mają taką samą nazwę, to obie będą zawierały te same funkcjonalności i powinniśmy wybrać tylko jedną z nich.

Jeśli potrzebujemy obu, nie ma nic złego w używaniu tego. Nie jest to też zły pomysł na programowanie.

Powinniśmy jednak używać w pełni kwalifikowanych nazw klas (o tej samej nazwie), aby było jasne, do której klasy również się odnosimy.

:)

Trafiłem na ten problem, gdy na przykład mapuję jedną klasę na inną (na przykład przy przełączaniu na nowy zestaw klas reprezentujących dane osoby). W tym momencie potrzebujesz obu klas, ponieważ to jest cały punkt kodu - aby zmapować jedną na drugą. I nie możesz zmienić nazw klas w żadnym miejscu (ponownie, zadaniem jest mapowanie, a nie zmienianie tego, co zrobił ktoś inny).

Pełne kwalifikacje to jedna droga. Wygląda na to, że nie można w rzeczywistości uwzględnić obu instrukcji importu, ponieważ Java martwi się, na przykład, o którą „osobę” chodzi.

Jeśli naprawdę chcesz lub potrzebujesz użyć tej samej nazwy klasy z dwóch różnych pakietów, masz dwie opcje:

1-wybierz jeden do importu i użyj w pełni kwalifikowanej nazwy klasy drugiej:

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 - zawsze używaj w pełni kwalifikowanej nazwy klasy:

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

  }
}

Po prostu miałem ten sam problem, co zrobiłem, uporządkowałem kolejność bibliotek w kolejności, na przykład były java.lang.NullPointerException i javacard.lang.NullPointerException. Pierwszą z nich ustawiłem jako bibliotekę domyślną, a jeśli chcesz użyć drugiej, możesz jawnie określić pełną kwalifikowaną nazwę klasy.

W przypadku wywoływania klas o takich samych nazwach należy jawnie określić pakiet, z którego ta klasa jest wywoływana.

Możesz zrobić tak:

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

Wynik:

Foo{first class}
Foo{second class}