Importando dos clases con el mismo nombre. ¿Cómo manejar?

Digamos que tengo un código como:

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 ?

  }
}

¿Debería ser nombres completos de clases calificados? ¿Puedo deshacerme de las declaraciones de importación? ¿Es este escenario común en la programación del mundo real?

Puede omitir las declaraciones de importación y consultarlas utilizando la ruta completa. P.ej:

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

Pero yo diría que usar dos clases con el mismo nombre y una función similar no suele ser la mejor idea a menos que puedas dejar muy claro cuál es cuál.

utilice el nombre completo en lugar de importar la clase.

p.ej

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

Sí, cuando importa clases con los mismos nombres simples, debe referirse a ellas por sus nombres de clase completamente calificados. Dejaría las declaraciones de importación, ya que les da a otros desarrolladores una idea de lo que hay en el archivo cuando están trabajando con él.

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

Otra forma de hacerlo es subclasificarlo:

package my.own;

public class FQNDate extends Date {

}

Y luego importe my.own.FQNDate en paquetes que tengan java.util.Date.

Si tiene su propia clase de fecha, debe distinguirla de la clase de fecha incorporada. es decir, ¿por qué creaste el tuyo? Algo como ImmutableDate o BetterDate o NanoDate, incluso MyDate indicaría por qué tiene su propia clase de fecha. En este caso, tendrán un nombre único.

Puede importar uno de ellos mediante la importación. Para todas las demás clases similares, debe especificar nombres de clase totalmente calificados. De lo contrario, obtendrá un error de compilación.

P.ej:

import java.util.Date;

class Test{

  public static void main(String [] args){

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

    // util.Date
    Date utilDate;
  }
}

Este escenario no es tan común en la programación del mundo real, pero tampoco tan extraño. A veces sucede que dos clases en paquetes diferentes tienen el mismo nombre y las necesitamos a las dos.

No es obligatorio que si dos clases tienen el mismo nombre, ambas contendrán las mismas funcionalidades y debamos elegir solo una de ellas.

Si necesitamos ambos, entonces no hay nada de malo en usarlos. Y tampoco es una mala idea de programación.

Pero deberíamos usar nombres completos de las clases (que tienen el mismo nombre) para dejar claro a qué clase nos referimos también.

:)

Me encuentro con este problema cuando, por ejemplo, mapeo una clase a otra (como cuando cambio a un nuevo conjunto de clases para representar datos personales). En ese punto, necesita ambas clases porque ese es el objetivo del código: asignar una a la otra. Y no puede cambiar el nombre de las clases en ningún lugar (nuevamente, el trabajo es mapear, no cambiar lo que hizo otra persona).

Completamente calificado es una forma. Parece que en realidad no puede incluir ambas declaraciones de importación, porque Java se preocupa por a qué "Persona" se refiere, por ejemplo.

Si realmente desea o necesita usar el mismo nombre de clase de dos paquetes diferentes, tiene dos opciones:

1-elija uno para usar en la importación y use el nombre de clase completo del otro:

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-utilice siempre el nombre de clase completo:

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

  }
}

Simplemente tuve el mismo problema, lo que hice, organicé el orden de la biblioteca en secuencia, por ejemplo, había java.lang.NullPointerException y javacard.lang.NullPointerException. Hice la primera como biblioteca predeterminada y si necesita usar la otra, puede especificar explícitamente el nombre completo de la clase calificada.

Cuando llama a clases con los mismos nombres, debe especificar explícitamente el paquete desde el que se llama a la clase.

Puedes hacer esto:

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

Salida:

Foo{first class}
Foo{second class}