Perché il punto e virgola non è obbligatorio ma è consentito alla fine di una definizione di classe?

Question

Sto provando a passare da C++ a Java.

Quello che mi chiedo è, in C++, dopo una definizione di classe, è necessario un punto e virgola (;), ma in Java non lo è.

Cioè, in C++:

class Person { 
    public: 
    string name; 
    int number; 
}; // Note this semicolon 

Ma in Java:

class Person { 
    public String name; 
    public int number; 
} // Semicolon is not required 

va bene, lo capisco.

Tuttavia, il mio problema è :

Java funziona anche quando aggiungo punto e virgola alla fine della definizione di classe, come:

class Person { 
    public String name; 
    public int number; 
}; // Now this semicolon is confusing me! 

ho compilato ed eseguito entrambi i frammenti di programma indicati per Java, ed entrambi funzionano. Qualcuno può spiegare perché è così? Che cosa significa il punto e virgola alla fine di una definizione di classe in Java?

Mi dispiace se questa domanda è di bassa qualità, ma ho davvero bisogno di chiarimenti per questo. Spero che gli esperti di Java mi aiutino.

Bene, ho già visto Semicolons in a class definition e altre domande correlate.

Grazie in anticipo.

Answer 1

I abbiamo compilato ed eseguito entrambi i frammenti di programma mostrati per Java, ed entrambi funzionano. Qualcuno può spiegare perché è così?

È consentito perché la grammatica Java dice che è consentito; Vedi JLS 7.6.

Cosa significa il punto e virgola alla fine di una definizione di classe in Java?

Niente.È opzionale "rumore sintattico".

Il JLS spiega come segue:

Extra ";" i token che appaiono al livello delle dichiarazioni di tipo in un'unità di compilazione non hanno alcun effetto sul significato dell'unità di compilazione. Il punto e virgola è consentito nel linguaggio di programmazione Java solo come concessione ai programmatori C++ che sono abituati a piazzare ";" dopo una dichiarazione di classe. Non dovrebbero essere usati nel nuovo codice Java.

---

^{(Si noti che questa non è una "dichiarazione di vuoto". Una dichiarazione vuota (JLS 14.6) appare in un contesto sintattico in cui è consentita una dichiarazione. La presenza di una dichiarazione vuota può cambiare il significato di il codice, ad esempio if (a == b) ; c(); contro if (a == b) c();)}

Answer 2

Java ha aggiunto questo solo per persone come te che passano da C++!

In Java, un singolo punto e virgola è una dichiarazione che può essere scritta quasi ovunque. Il suo unico scopo è facilitare il passaggio da tali lingue.

Ad esempio, anche la seguente è corretto in Java:

;;;;;;;;;; 
class X{ 
    ;;;;;;;;;;;;;; 
} ;;;;;;;;;;;;;;; 

Una virgola è semplicemente trattato come una dichiarazione di vuoto che non fa nulla.

Ecco una citazione dal spec, paragrafo 7.6:

Extra ";" I token visualizzati a livello di dichiarazioni di tipo in una compilation non hanno alcun effetto sul significato dell'unità di compilazione. I punti e virgola sono consentiti nel linguaggio di programmazione Java esclusivamente come una concessione ai programmatori C++ che vengono utilizzati per posizionare ";" dopo una dichiarazione di classe . Non dovrebbero essere usati nel nuovo codice Java.

Così come vedi, questo è davvero solo per ragazzi come te :).

È anche possibile utilizzare una riga di punto e virgola come una bella separazione visiva. Tuttavia, sconsiglio vivamente questo. Ma potrebbe essere utile per vantarsi. Es .:

class X { 
    // Member variables 
    private int i; 

    ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; 
    // Constructors 
    X(){} 

    ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; 
    // Methods 
    void foo(){}  

} 

Answer 3

Il punto e virgola dopo la } diventa una dichiarazione vuota. Dichiarazione vuota significa letteralmente un'affermazione che non contiene nulla.

In Java, ogni riga è separata da } o da ;. In altre parole, si potrebbe avere un codice monofoderato source come

public class Test { public static void main (String[] args) { System.out.println ("Hello"); } } 

In altre parole,

class Person{ 
public String name; 
public int number; 
}; 

è equivalente a

class Person{ 
public String name; 
public int number; 
} 
; // Empty statement 

Answer 4

Non ho dimestichezza con Java , ma il motivo per cui è necessario un punto e virgola in più è perché è possibile definire una classe anonima, all'interno delle funzioni. Per esempio:

void routine(const int x, const int y) 
{ 
    class { public: int x; int y; } my_instance; 
    my_instance.x = x; 
    my_instance.y = y; 
    // ... etc 
} 

Potrai solito si vede questo di più con le strutture che con le classi, per catturare alcune variabili importanti di una gran classe.

void f(const BigClass& big_class) 
{ 
    struct { std::string str; int i; } props; 
    props.str = big_class.GetFilename(); 
    props.i = big_class.GetID(); 
    // etc... 
} 

Answer 5

Nei primi giorni, che permette questo è stato uno dei modi in cui Java è stato reso più familiare ai programmatori C/C++. Questa familiarità era importante per l'adozione di Java.

Ecco come funziona sintatticamente.

Dopo una classe di primo livello, funziona perché un'unità di compilazione contiene questa sequenza, secondo JLS 7.3:

CompilationUnit: 
PackageDeclaration(opt) ImportDeclarations(opt) TypeDeclarations(opt) 

E una dichiarazione di tipo è uno qualsiasi dei seguenti, secondo JLS 7.6:

TypeDeclaration: 
    ClassDeclaration 
    InterfaceDeclaration 
    ; 

Dopo una classe membro, annidato in qualche altra classe, che funziona perché un punto e virgola può essere una classe m dichiarazione brace, secondo JLS 8.1.6:

ClassMemberDeclaration: 
    FieldDeclaration 
    MethodDeclaration 
    ClassDeclaration  
    InterfaceDeclaration 
    ; 

Dopo una classe locale, all'interno di un metodo, funziona perché una virgola può essere un'istruzione vuota, secondo JLS 14.6:

EmptyStatement: 
    ; 

Answer 6

credo che questo sia uno stile che seguita inherites da C:

struct A 
{ 
    unsigned a; 
    unsigned b; 
}; 

Oppure si può utilizzare:

struct A 
{ 
    unsigned a; 
    unsigned b; 
}A1,A2;