Cómo importar una clase desde un paquete predeterminado

Las clases en el paquete predeterminado no se pueden importar por clases en paquetes. Esta es la razón por la que no debe usar el paquete predeterminado.

Hay una solución para su problema. Puedes usar la reflexión para lograrlo.

Primero, crea una interfaz para tu clase de destino Calculatons:

package mypackage;

public interface CalculationsInterface {  
    int Calculate(int contextId);  
    double GetProgress(int contextId);  

}

A continuación, haga que su clase de destino implemente esa interfaz:

public class Calculations implements mypackage.CalculationsInterface {
    @Override
    native public int Calculate(int contextId);
    @Override
    native public double GetProgress(int contextId);
    static  {
        System.loadLibrary("Calc");
    }
}

Finalmente, use reflexión para crear una instancia de la clase Calculations y asignarla a una variable de tipo CalculationsInterface:

Class<?> calcClass = Class.forName("Calculations");
CalculationsInterface api = (CalculationsInterface)calcClass.newInstance();
// Use it 
double res = api.GetProgress(10);

Puedo darte esta sugerencia, Por lo que sé de mi experiencia en programación en C y C++ , Una vez, cuando tuve el mismo tipo de problema, lo resolví cambiando la estructura escrita dll en ".C " cambiando el nombre de la función que implementó la funcionalidad nativa de JNI. por ejemplo, si desea agregar su programa en el paquete " com.mypackage", Se cambia el prototipo de la implementación del JNI ".C " Función/método del archivo a este:

JNIEXPORT jint JNICALL
Java_com_mypackage_Calculations_Calculate(JNIEnv *env, jobject obj, jint contextId)
{
   //code goes here
}

JNIEXPORT jdouble JNICALL
Java_com_mypackage_Calculations_GetProgress(JNIEnv *env, jobject obj, jint contextId)
{
  //code goes here
}

Ya que soy nuevo a delphi, no puedo garantizarle pero diré esto finalmente, (aprendí pocas cosas después de googlear sobre Delphi y JNI): Pídele a aquellas personas (Si no eres tú) que proporcionaron la implementación de Delphi del código nativo que cambien los nombres de las funciones a algo como esto:

function Java_com_mypackage_Calculations_Calculate(PEnv: PJNIEnv; Obj: JObject; contextId: JInt):JInt; {$IFDEF WIN32} stdcall; {$ENDIF} {$IFDEF LINUX} cdecl; {$ENDIF}
var
//Any variables you might be interested in
begin
  //Some code goes here
end;



function Java_com_mypackage_Calculations_GetProgress(PEnv: PJNIEnv; Obj: JObject; contextId: JInt):JDouble; {$IFDEF WIN32} stdcall; {$ENDIF} {$IFDEF LINUX} cdecl; {$ENDIF}
var
//Any variables you might be interested in
begin
//Some code goes here
end;

Pero, un consejo final: Aunque tú (si eres el programador de delphi) o ellos cambiarán los prototipos de estas funciones y recompilarán el archivo dll, una vez compilado el archivo dll, no podrás cambie el nombre del paquete de su archivo "Java" una y otra vez. Porque, esto requerirá de nuevo que usted o ellos cambien los prototipos de las funciones en delphi con prefijos cambiados (por ejemplo, JAVA_yourpackage_with_underscores_for_inner_packages_JavaFileName_MethodName)

Creo que esto resuelve el problema. Gracias y saludos, Harshal Malshe

De algunos donde encontré a continuación: -

De hecho, puedes.

Usando la API de reflections puede acceder a cualquier clase hasta ahora. Al menos yo era capaz de:)

Class fooClass = Class.forName("FooBar");
Method fooMethod =
    fooClass.getMethod("fooMethod", new Class[] { String.class });

String fooReturned =
    (String) fooMethod.invoke(fooClass.newInstance(), "I did it");

Desafortunadamente, no se puede importar una clase sin que esté en un paquete. Esta es una de las razones por las que está altamente desaconsejado. Lo que yo intentaría es una especie de proxy put pon tu código en un paquete que cualquier cosa pueda usar, pero si realmente necesitas algo en el paquete predeterminado, haz que sea una clase muy simple que reenvíe las llamadas a la clase con el código real. O, aún más simple, que se extienda.

Para dar un ejemplo:

import my.packaged.DefaultClass;

public class MyDefaultClass extends DefaultClass {}

package my.packaged.DefaultClass;

public class DefaultClass {

   // Code here

}

Crear un nuevo paquete Y luego mover las clases del paquete predeterminado en nuevo paquete y usar esas clases

1. Crea un nuevo paquete.
2. Mueva sus archivos del paquete predeterminado al nuevo.

1. Cree un paquete (carpeta) "raíz" en su proyecto, por ejemplo.

   Fuente del paquete; (.../ path_to_project / source/)

2. Mueve a tu clase.class en una carpeta de origen. (.../ path_to_project / source / YourClass.class)

3. Importar así

   Importar fuente.YourClass;