Java: dichiarazioni di più classi in un file

In Java, è possibile definire più classi di livello superiore in un singolo file, purché al massimo una di queste sia pubblica (vedere JLS §7.6 ). Vedi sotto per esempio.

1. C'è un nome in ordine per questa tecnica (analogo a inner, nested, anonymous)?

2. JLS afferma che il sistema potrebbe imporre la restrizione che queste classi secondarie non possono essere referred to by code in other compilation units of the package, ad esempio, non possono essere trattate come pacchetto-private. È davvero qualcosa che cambia tra le implementazioni Java?

ad es. PublicClass.java:

package com.example.multiple;

public class PublicClass {
    PrivateImpl impl = new PrivateImpl();
}

class PrivateImpl {
    int implementationData;
}

Il mio nome suggerito per questa tecnica (comprese più classi di livello superiore in un singolo file sorgente) sarebbe "pasticcio". Scherzi a parte, non credo sia una buona idea, in questa situazione utilizzerei un tipo nidificato. Quindi è ancora facile prevedere in quale file sorgente si trova. Non credo che ci sia un termine ufficiale per questo approccio.

Per quanto riguarda se questo cambia effettivamente tra le implementazioni - ne dubito fortemente, ma se eviti di farlo in primo luogo, non dovrai mai preoccuparti :)

javac non lo proibisce attivamente, ma ha una limitazione che praticamente significa che non vorresti mai fare riferimento a una classe di livello superiore da un altro file a meno che non abbia lo stesso nome del file in cui si trova.

Supponiamo di avere due file, Foo.java e Bar.java.

Foo.java contiene:

• classe pubblica Foo

Bar.java contiene:

• Bar di classe pubblica
• classe Baz

Diciamo anche che tutte le classi si trovano nello stesso pacchetto (e che i file si trovano nella stessa directory).

Cosa succede se Foo.java si riferisce a Baz ma non a Bar e proviamo a compilare Foo.java? La compilazione non riesce con un errore come questo:

Foo.java:2: cannot find symbol
symbol  : class Baz
location: class Foo
  private Baz baz;
          ^
1 error

Questo ha senso se ci pensi. Se Foo.java fa riferimento a Baz, ma non esiste Baz.java (o Baz.class), come può javac sapere in quale file sorgente cercare?

Se invece dici a javac di compilare Foo.java e Bar.java allo stesso tempo, o anche se avevi precedentemente compilato Bar.java (lasciando la classe Baz. dove javac può trovarlo), questo errore scompare. Questo rende il tuo processo di compilazione molto inaffidabile e traballante, tuttavia.

Perché la limitazione effettiva, che è più simile a "non si riferisce a una classe di livello superiore da un altro file a meno che non abbia lo stesso nome del file in cui si trova o si riferisca anche a una classe che si trova nello stesso file che è denominato la stessa cosa del file "è un po 'difficile da seguire, le persone di solito vanno con la convenzione molto più semplice (anche se più rigorosa) di mettere solo una classe di livello superiore in ciascun file. Questo è anche meglio se cambi idea sul fatto che una classe debba essere pubblica o meno.

A volte c'è davvero una buona ragione per cui tutti fanno qualcosa in un modo particolare.

Credo che tu chiami semplicemente PrivateImplquello che è: a non-public top-level class. Puoi anche dichiarare non-public top-level interfacesanche.

ad es. altrove su SO: classe di livello superiore non pubblica vs classe nidificata statica

Per quanto riguarda i cambiamenti nel comportamento tra le versioni, c'è stata questa discussione su qualcosa che "ha funzionato perfettamente" in 1.2.2. ma ha smesso di funzionare in 1.4 nel forum di Sun: Java Compiler - impossibile dichiarare classi di livello superiore non pubbliche in un file .

Puoi avere tutte le lezioni che desideri in questo modo

public class Fun {
    Fun() {
        System.out.println("Fun constructor");
    }
    void fun() {
        System.out.println("Fun mathod");
    }
    public static void main(String[] args) {
        Fun fu = new Fun();
        fu.fun();
        Fen fe = new Fen();
        fe.fen();
        Fin fi = new Fin();
        fi.fin();
        Fon fo = new Fon();
        fo.fon();
        Fan fa = new Fan();
        fa.fan();
        fa.run();
    }
}

class Fen {
    Fen() {
        System.out.println("fen construuctor");

    }
    void fen() {
        System.out.println("Fen method");
    }
}

class Fin {
    void fin() {
        System.out.println("Fin method");
    }
}

class Fon {
    void fon() {
        System.out.println("Fon method");
    } 
}

class Fan {
    void fan() {
        System.out.println("Fan method");
    }
    public void run() {
        System.out.println("run");
    }
}

1. Esiste un nome ordinato per questa tecnica (analogo a interno, nidificato, anonimo)?

Demo multi-classe a file singolo.

2. Il JLS afferma che il sistema potrebbe imporre la restrizione che queste classi secondarie non possono essere indicate dal codice in altre unità di compilazione del pacchetto, ad esempio, non possono essere trattate come pacchetto-privato. È davvero qualcosa che cambia tra le implementazioni Java?

Non sono a conoscenza di nessuno che non abbia questa limitazione - tutti i compilatori basati su file non ti permetteranno di fare riferimento a classi di codice sorgente in file che non hanno lo stesso nome del nome della classe. (se si compila un file multi-classe e si inseriscono le classi nel percorso della classe, qualsiasi compilatore le troverà)

Secondo Effective Java 2nd edition (Item 13):

"Se una classe di livello superiore (o interfaccia) privata del pacchetto viene utilizzata da una sola classe, considerare di rendere la classe di livello superiore una classe nidificata privata della sola classe che la utilizza (elemento 22). Ciò riduce la sua accessibilità da tutti le classi nel suo pacchetto a quella che lo utilizza. Ma è molto più importante ridurre l'accessibilità di una classe pubblica gratuitamente rispetto a una classe di livello superiore pacchetto privato: ... "

La classe nidificata può essere statica o non statica in base al fatto che la classe membro debba accedere all'istanza che la racchiude (elemento 22).

Sì, puoi, con membri statici pubblici su una classe pubblica esterna, in questo modo:

public class Foo {

    public static class FooChild extends Z {
        String foo;
    }

    public static class ZeeChild extends Z {

    }

}

e un altro file che fa riferimento a quanto sopra:

public class Bar {

    public static void main(String[] args){

        Foo.FooChild f = new Foo.FooChild();
        System.out.println(f);

    }
}

metterli nella stessa cartella. Compilare con:

javac folder/*.java

e corri con:

 java -cp folder Bar

Cordiali saluti, se si utilizza Java 11+, esiste un'eccezione a questa regola: se si esegue direttamente il file java ( senza compilazione ). In questa modalità, non vi sono restrizioni su una singola classe pubblica per file. Tuttavia, la classe con il mainmetodo deve essere la prima nel file.

No. Non puoi. Ma è molto possibile in Scala:

class Foo {val bar = "a"}
class Bar {val foo = "b"}