Java: non Pas une déclaration

Je suppose que c'est plus une question à propos de la théorie des langages qu'autre chose. Pourquoi est la première instruction juridique principal, alors que la deuxième ne l'est pas? N'ont-ils pas d'évaluer à la même chose?

public class Main {
        public static void main(String[] args) {
                foo();
                0;
        }
        public static int foo(){
                return 0;
        }
}

Parce que c'est une brute primitive, n'est pas un énoncé.
Lire ceci: docs.oracle.com/javase/specs/jls/se7/jls7.pdf en Particulier le chapitre sur les états.

OriginalL'auteur Skyler | 2013-05-16

java semantics

15

Java limite les types d'expressions qui sont admis dans ce qu'on appelle "l'expression des états". N'a de sens que les expressions qui ont des effets secondaires potentiels sont autorisés. Il n'autorise pas sémantiquement vide de sens des énoncés comme 0; ou a + b;. Ils sont tout simplement exclus de la langue grammaire.

Un appel de fonction comme foo() peut, et en général, ont des effets secondaires, il n'est donc pas dénué de sens de la déclaration. Le compilateur n'a pas profondément inspecter le corps de foo() pour vérifier si il ne fait rien. L'appel d'une fonction peut ont des effets secondaires, de sorte qu'il est syntaxiquement valide.

Cela reflète une différence philosophique entre C/C++ et Java. Java interdit les constructions diverses qui entraîner la mort ou de sens du code.
```
return;
foo();    //unreachable statement
```
Le C et le C++ sont relativement laissez-faire à propos de tout cela. Écrivez ce que vous voulez; ils n'ont pas le temps de faire du babysitting.

Citant le Java Langage De Spécification, §14.8 Expression Des Déclarations:
Certains types d'expressions peuvent être utilisées comme des déclarations suivantes
avec des points-virgules.
```
ExpressionStatement:
    StatementExpression ;

StatementExpression:
    Assignment
    PreIncrementExpression
    PreDecrementExpression
    PostIncrementExpression
    PostDecrementExpression
    MethodInvocation
    ClassInstanceCreationExpression
```
Une expression instruction est exécutée par l'évaluation de l'expression; si
l'expression a une valeur, la valeur est ignorée.

L'exécution de l'expression instruction se termine normalement si et seulement
si l'évaluation de l'expression se termine normalement.

Contrairement au C et C++, le langage de programmation Java ne permet que certaines
les formes d'expressions pour être utilisé comme expression consolidés. Notez que
le langage de programmation Java ne permet pas un "cast à nul" nul
n'est pas un type de sorte que la traditionnelle C truc de l'écriture d'une expression
énoncé tel que:
```
(void)... ;  //incorrect!
```
ne fonctionne pas. D'autre part, le langage de programmation Java permet
toutes les plus utiles les formes d'expression dans les expressions des déclarations,
et il ne nécessite pas une invocation de méthode utilisé comme une expression
déclaration d'invoquer une méthode void, donc, un tel truc n'est presque jamais
nécessaire. Si un truc est nécessaire, soit une instruction d'affectation (§15.26)
ou une déclaration de variable locale déclaration (§14.4) peut être utilisé à la place.
OriginalL'auteur John Kugelman

In the first statement you are actually calling a function and second statement doesn't give any value. Incase you want to process the return value, you need to call a variable for return type

Eg: 
public class Main {
        public static void main(String[] args) {
               int n = foo();

               //do whatever you want with return 

        }
        public static int foo(){
                return 0;
        }
}

Cette réponse ne traite pas de la question. Cette question est sur la façon de corriger le code en aucune façon. La question est à propos d'expliquer pourquoi une chose est autorisé par la langue, mais une autre des choses similaires génère une erreur de compilation.
J'ai modifié ma réponse bits.

OriginalL'auteur Saravana Kumar

Vous devez vous connecter pour publier un commentaire.