Pourquoi le point-virgule n'est-il pas requis mais autorisé à la fin d'une définition de classe?

Je suis en train de passer de C++ à Java.

Ce que je me demande est, en C++, après une définition de classe, un point-virgule (;) est nécessaire, mais en Java, il n'est pas.

Qui est, en C++:

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

Mais en Java:

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

C'est bien, je le comprends.

Cependant, mon problème est:

Java fonctionne aussi quand j'ai ajouter un point-virgule à la fin de la définition de la classe, comme:

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

J'ai compilé et exécuté le programme d'extraits montré pour Java, et ils travaillent tous les deux. Quelqu'un peut-il expliquer pourquoi il en est ainsi? Quel est le point-virgule à la fin de la définition d'une classe en Java?

Je suis désolé si cette question est de faible qualité, mais j'ai vraiment besoin d'éclaircissements pour cela. J'espère que les experts en Java va m'aider.

Bien, j'ai déjà vu Les points-virgules dans une définition de classe et d'autres questions connexes.

Merci à l'avance.

source d'informationauteur Vedant Terkar | 2014-07-07

  1. 18

    J'ai compilé et exécuté le programme d'extraits montré pour Java, et ils travaillent tous les deux. Quelqu'un peut-il expliquer pourquoi il en est ainsi?

    Il est permis parce que le Java Grammaire dit que c'est autorisé; Voir JLS 7.6.

    Quel est le point-virgule à la fin de la définition d'une classe en Java?

    Rien. Il est facultatif "syntaxique de bruit".

    JL explique comme suit:

    Extra ";" jetons apparaissant au niveau des déclarations de type dans une unité de compilation n'ont aucun effet sur le sens de l'unité de compilation. Errants des points-virgules sont autorisés dans le langage de programmation Java uniquement comme une concession pour les programmeurs en C++ qui sont utilisés pour l'installation de ";" après une déclaration de classe. Ils ne devraient pas être utilisée dans du code Java.

    (Note que ce n'est PAS une "instruction vide". Une instruction vide (JLS 14.6) apparaît dans un contexte syntaxique où une déclaration est autorisé. La présence d'une instruction vide peut changer le sens de votre code; par exemple, if (a == b) ; c(); contre if (a == b) c();)

  2. 9

    Dans les premiers jours, ce qui lui permet a été l'une des façons de Java a été rendue plus familière aux programmeurs C/C++. Cette familiarité était important à l'adoption de Java.

    Voici comment cela fonctionne syntaxiquement.

    Après un haut-niveau de la classe, cela fonctionne, car une unité de compilation contient cette séquence, selon JLS 7.3:

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

    Et une déclaration de type est l'une des actions suivantes, selon JLS 7.6:

    TypeDeclaration:
   ClassDeclaration
   InterfaceDeclaration
   ;

    Après qu'un membre de la classe, imbriqué dans un autre classe, il travaille parce qu'un point-virgule peut être un membre de la classe de déclaration selon JLS 8.1.6:

    ClassMemberDeclaration:
    FieldDeclaration
    MethodDeclaration
    ClassDeclaration    
    InterfaceDeclaration
    ;

    Après une classe locale, à l'intérieur d'une méthode, il travaille parce qu'un point-virgule peut être une instruction vide, selon JLS 14.6:

    EmptyStatement:
    ;
  3. 7

    Java ajouté ce juste pour les personnes qui, comme vous, le passage de C++!

    En Java, un seul point-virgule est une déclaration qui peut être écrit à peu près partout. Son seul but est de faciliter la transition de ces langues.

    Par exemple, la suivante est correcte en Java:

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

    Un point-virgule est simplement traité comme un vide déclaration qui ne fait rien.

    Voici une citation de la spec, paragraphe 7.6:

    Extra ";"
    jetons apparaissant au niveau des déclarations de type dans une compilation
    l'unité n'ont pas d'effet sur le sens de l'unité de compilation. Errants
    les points-virgules sont autorisés dans le langage de programmation Java uniquement comme un
    de la concession pour les programmeurs en C++ qui sont utilisés pour l'installation de ";" après un
    déclaration de classe. Ils ne devraient pas être utilisée dans du code Java.

    Donc, comme vous voyez, c'est vraiment juste pour les gars comme vous :).

    Vous pouvez même utiliser une ligne de points-virgules comme une belle séparation visuelle. Cependant, je déconseille fortement ce. Mais il pourrait être bon pour de la vantardise fins. E. g.:

    class X {
   //Member variables
   private int i;

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

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

}
  4. 0

    Je pense que c'est un suivi de style qui inherites à partir de C:

    struct A
{ 
    unsigned a;
    unsigned b;
};

    Ou vous pouvez utiliser:

    struct A
{ 
    unsigned a;
    unsigned b;
}A1,A2;
  5. -2

    Je ne suis pas familier avec Java, mais la raison pour laquelle il ya un supplément de point-virgule est nécessaire car vous pouvez définir une classe anonyme, à l'intérieur des fonctions. Par exemple:

    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
}

    Vous aurez généralement voir de plus près avec les structures de classes, à la capture de certaines variables importantes d'une grande 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...
}