Import JAVA

[vanosco]

Salve a tutti,
ho questo problema, se non lo risolvo non posso dare l'esame.

Se voglio importare nella classe java un file java che sta nella sotto cartella scrivo:
import sottocartella.nomeFile;

oppure

import sottocartella.*;

ma se il file che mi interessa sta nella cartella di livello superiore come faccio?
GRAZIE!!

[PGI-Bis]

E' una domanda legittima e sarei curioso di sentire che risposta ti darebbe quel lanzichenecco che vi ha spiegato i package.

Spiegato nel senso sartoriale di "privato di pieghe" perchè certo l'attività di cui sei stato vittima non rientra nell'alveo dell'insegnamento.

La risposta alla domanda è la più banale: il problema non si pone perchè per il linguaggio di programmazione Java manca del concetto di file. Mancando i file, mancano pure le cartelle. Insomma, al dubbio togliamo proprio il pane di bocca.

Tolto questo dubbio, mi aspetto che ne sorga un altro.

Se quando importo non sto importando dei file, che cavolo sto importando?

La risposta è: dei nomi. E neppure nomi qualsiasi, ci direbbe il linguaggio, ma solo alcune specie di ciò che in Java è qualificato nome.

Che nomi, vale a dire, in:

import x;

cosa può essere "x"?

1. il nome pienamente qualificato di un tipo top level (classe, interfaccia, enumerativo, annotazione)

"pienamente qualificato" significa "nomedelpackage.nomedelladichiarazioneditipo".

In:

package pippo.pappo;

public class Bingo {}

pippo.pappo è il nome del package, Bingo è il nome della dichiarazione di tipo (classe), pippo.pappo.Bingo è il nome pienamente qualificato del tipo (classe) Bingo.

2. il nome pienamente qualificato di un tipo membro (cioè una classe, interfaccia, enumerativo o annotazione la cui dichiarazione interviene nel corpo di un altro tipo, che può essere a sua volta un membro o un tipo top level);

3. il nome di un package, seguito da un punto e un asterisco.

4. nel caso di uno static import, il nome di un membro statico di un tipo top level o membro annidato non interno o il nome di un tipo top level o membro annidato non interno seguito da un punto ed un asterisco. Ma non usatissima come forma, sebbene si presti ad alcune divertenti capriole.

Il punto è che in tutta questa manfrina non c'è una sola volta la parola "file".

Al che mi dirai: calma e gesso Goffredino, lì non ci sarà la parola file, ma quando io programmo in Java di file ne scrivo eccome.

Certamente, risponderei. Ma. E che ma.

La ragione per cui scrivi delle cose su file è perchè così vuole il programma "javac". Proprio il programma "javac", perchè quello specifico programma usa per la compilazione una libreria Java per la quale i file sono irrilevanti.

E a javac interessano le cartelle?

Sopresa: no.

Tu potresti tranquillamente prendere tutti i file sorgente di un programma java, mettere ciascuno in una cartella diversa, con un nome a caso, in una posizione a caso, e compilare il programma con javac: basta che tu "dica" a javac dove si trovano i file sorgente che vuoi compilare.

Insomma, 'ste cartelle non c'entrano proprio nulla? In verità c'è un momento in cui entrano in gioco.

SE il compilatore non ha a disposizione l'unita di compilazione che contiene la dichiarazione di un certo nome, usato in un'altra unità di compilazione ALLORA il compilatore cerca la definizione di quel nome nel "classpath".

Tra le cose che possono esserci in questo classpath ci sono dei percorsi di cartelle. Quando si trova di fronte ad una di queste cartelle, il compilatore javac va a guardare se in quella cartella c'è un file in posizione:

nomepackage/nometipo

Ricapitolando.

1. non c'è alcuna relazione tra package e cartelle
2. il linguaggio Java ignora totalmente la questione file
3. l'unico a cui interessano i file è il compilatore javac del JDK
4. al compilatore javac interessa la corrispondenza tra nome di package e cartella solo quando non sia altrimenti in grado di risolvere un nome richiesto per la compilazione

E chiudiamo con il caso del "file che sta nella cartella superiore".

Supponiamo che io abbia un tipo così definito:

package pippo;

public class Pippo {

    public void diQualcosa() {
        System.out.println("Pippo World");
    }
}

E che questo si trovi nel file:

/home/pgi/DATA001/test/Pippo.java

Supponiamo inoltre che in una cartella:

/home/pgi/DATA001/test/toast/

io abbia il tipo:

package gianni;

public class Gianni {

}

Se in Gianni voglio usare Pippo, cosa devo dire? Mi interessa la posizione di Pippo sul filesystem? No. Mi interessa il nome di Pippo? Sì. Pippo è un tipo classe top-level. Se il nome di Gianni non è qualificato dallo stesso nome di package di Pippo, devo importare il nome Pippo.

package gianni;

import pippo.Pippo;

public class Gianni {

}

E solo allora potrò usarlo nell'unità di compilazione di Gianni:

package gianni;

import pippo.Pippo;

public class Gianni {

    private Pippo pippo = new Pippo();
}

Nota l'assenza di qualsiasi questione relativa alla posizione del file sorgente Pippo.java o del file sorgente Gianni.java. Ci interessano solo i nomi, nel senso che questo termine ha nel linguaggio Java, non i file o le cartelle.

Come compilo?

Apro una linea di comando e dico a javac dove deve andare a prendere i file da compilare. Sia Gianni che Pippo.

javac -d . /home/pgi/DATA001/test/Pippo.java /home/pgi/DATA001/test/toast/Gianni.java

Et voilà.

Un caso in cui il percorso conta. Caso direi rarissimo perchè non si ha mai a che fare con classi sfuse ma se capita, capita.

Supponiamo che io abbia il codice sorgente di Gianni, così come scritto, nel cartella:

/home/pgi/DATA001/test/toast/Gianni.java

Ma che io NON abbia il codice sorgente di Pippo, bensì il "file compilato".

Abbiamo visto che il compilatore se non trova il sorgente è in grado di acchiappare un file compilato, un file .class. Basta includerlo nel classpath del programma javac. E come lo includiamo?

Nel 99.9% dei casi, il file .class è impacchettato in un archivio jar, e includi quell'archivio. Nello 0.099% dei casi, hai per le mani il file .class e lo impacchetti in un jar tu a mano. Nel restante 0.001% dei casi devi assicurarti che il file "Pippo.class" si trovi in un ramo del filesystem il cui percorso corrisponda al nome del package che qualifica il tipo Pippo. Pippo è qualificato da pippo (pippo.Pippo è il nome pienamente qualificato di pippo) quindi il file Pippo.class deve trovarsi in una cartella che si chiama "pippo":

/pippo/Pippo.class

A "javac" dai come classpath il nome della directory in cui si trova la cartella "pippo".

Supponiamo che sia:

/home/pgi/DATA001/test

cioè che il percorso completo sia:

/home/pgi/DATA001/test/pippo/Pippo.class.

A javac dirò:

javac -d . -classpath .:/home/pgi/DATA001 /home/pgi/DATA001/test/toast/Gianni.java

Solo qui, in questo 0.01% di casi, entrano in gioco le cartelle e la corrispondenza package-cartella.

E non per una questione di package o di import, è semplicemente un "incidente di percorso" del compilatore e anche per lui riguarda solo i file class "sciolti".

[vanosco]

Grazie per la risposta esauriente.. ho capito qualcosa di più.. ma soprattutto sono riuscito a concludere il progetto d'esame..grazie

[franksisca]

altra tacca sul tuo fucile ...