Error identifier expected java

Posted by Marta on November 21, 2021 Viewed 90994 times

In this article you will learn how to fix the java error: identifier expected to get a better understanding of this error and being able to avoid in the future.

This error is a very common compilation error that beginners frequently face when learning Java. I will explain what is the meaning of this error and how to fix it.

What’s the meaning of Identifier Expected error?

The identifier expected error is a compilation error, which means the code doesn’t comply with the syntax rules of the Java language. For instance, one of the rules is that there should be a semicolon at the end of every statement. Missing the semicolon will cause a compilation error.

The identifier expected error is also a compilation error that indicates that you wrote a block of code somewhere where java doesn’t expect it.

Here is an example of piece of code that presents this error:

public class Example {
	System.out.println("Hello");
}

If you try to compile this class, using the javac command in the terminal, you will see the following error:

Output:

Example.java:5: error: <identifier> expected
    System.out.println("Hello");
                      ^
Example.java:5: error: illegal start of type
    System.out.println("Hello");
                       ^

This error is slightly confusing because it seems to suggest there is something wrong with line 2. However what it really means is that this code is not in the correct place.

How to Fix it

We have seen what the error actually means, however how could I fix it? The error appears because I added some code in the wrong place, so what’s the correct place to right code? Java expects the code always inside a method. Therefore, all necessary to fix this problem is adding a class method and place the code inside. See this in action below:

public class Example {

    public void print() {
        System.out.println("Hello");
    }
}

The code above will compile without any issue.

Another example

Here is another example that will return the identifier expected error:

public class Example {

    public void print() {
        System.out.println("Hello");
    }

    Example e = new Example();
    e.print(); // Here is the error
}

Output:

Example.java:10: error: <identifier> expected
    e.print();
           ^

As before, this compilation error means that there is a piece of code: e.print() that is not inside a class method. You might be wondering, why line 7 ( Example e = new Example(); ) is not considered a compilation error? Variable declarations are allowed outside a method, because they will be considered class fields and their scope will be the whole class.

Here is a possible way to fix the code above:

public class Example {

    public void print() {
        System.out.println("Hello");
    }

    Example e = new Example();

    public void method2(){
        e.print();
    }
}

The fix is simply placing the code inside a method.

Conclusion

To summarise, this article covers how to fix the identifier expected java error. This compilation error will occur when you write code outside a class method. In java, this is not allow, all code should be placed inside a class method.

In case you want to explore java further, I will recommend the official documentation

Hope you enjoy the tutorial and you learn what to do when you find the identifier expected error. Thanks for reading and supporting this blog.

Happy coding!

More Interesting Articles

How to shuffle a string in java

How to open a web browser in python

Runnable vs Callable – Find out the differences

What is a mutator method in Java?

1. Understanding <identifier> expected Error in Java
2. Example 1: When Parameters in a Method Are Missing Data Type or Name
3. Example 2: When the Expression Statements Are Misplaced
4. Example 3: When Declaration Statements Are Misplaced
5. Conclusion

In this article, we will learn about Java’s <identifier> expected error.

Understanding <identifier> expected Error in Java

The <identifier> expected is the most common Java compile-time error faced by novice programmers. This error occurs when a method parameter does not have a data type or name declared or when an expression statement is written outside a method, a constructor, or an initialization block.

In Java, an identifier is a sequence of one or more characters where the 1st character must be a letter or $ or _, and the subsequent characters can be letters, digits, $ or _.

These identifiers are used to name a variable, a method, a class, a package, an interface, etc.

When the Java code is compiled initial phase involves lexical analysis of the program. Here the program is categorized into tokens, and all the tokens, including identifiers, are verified against a set of grammar rules.

And whenever as per grammar rules, an identifier is expected, but it’s not present, and something else is found in its place compiler raises the <identifier> expected error. Angle brackets here signify a reference to the token objects.

Let’s look at some examples to understand it better now.

Example 1: When Parameters in a Method Are Missing Data Type or Name

Parameters inside a method must have data followed by the variable name, which is an identifier; missing either of those will inevitably raise the <identifier> expected error.

1. Data of the parameter is missing

   public class Demo
   {
       public static int square(x)
       {
           return x*x;
       }
   
       public static void main(String[] args)
       {
   
           System.out.println(square(10));
   
       }
   }
   

   Output:

   square.java:9: error: <identifier> expected
   public static int square(x) {
           	        	  ^
   1 error
   

   If we observe the error above, we see that variable x is missing the data type. If we give the data type for it, it will work properly.

   public class Demo
   {
   
           public static int square( int x)
           {
               return x*x;
           }
   
           public static void main(String[] args)
           {
   
               System.out.println(square(10));
   
           }
   }
   

   Output:

2. The parameter’s data type is the identifier; the variable name is missing here.

   public class Demo
   {
   
       public static int square(int)
       {
           return x*x;
       }
   
       public static void main(String[] args)
       {
   
           System.out.println(square(10));
   
       }
   }
   

   Output:

   square.java:9: error: <identifier> expected
   public static int square(int) {
           	        	   ^
   1 error
   

   If we observe the error above, we can clearly see that we specified the data type but didn’t attach any variable name.

   public class Demo
   {
   
           public static int square( int x)
           {
           	return x*x;
           }
   
           public static void main(String[] args)
           {
   
           	System.out.println(square(10));
   
           }
   }
   

   Output:

Example 2: When the Expression Statements Are Misplaced

The compiler raises an error when an expression statement is written outside a method, a constructor or an initialization block <identifier> expected.

Example code:

public class Demo
{
    private String name;
    name = "Naruto";
    System.out.println(name);
}

Output:

Demo.java:9: error: <identifier> expected
  name = "Naruto";
      ^
Demo.java:10: error: <identifier> expected
  System.out.println(name);
                    ^
Demo.java:10: error: <identifier> expected
  System.out.println(name);
                        ^
3 errors

If we observe the error above, the error occurs because the statements are not enclosed within a function or a constructor. Let’s write these statements inside a method named print.

public class Demo {

    private String name;

    public void print()
    {
        name = "Naruto";
        System.out.println(name);
    }

    public static void main(String[] args) {

        Demo obj = new Demo();
        obj.print();

    }
}

Output:

Example 3: When Declaration Statements Are Misplaced

This is rare but not unheard of when working with try-with-resources statements. All these statements require that any closable resource be declared immediately after the try keyword.

If the resource variable is declared outside the try-with-resources statement, then the <identifier> expected error might be raised by the compiler (as compiler to compiler, this may vary).

Example code: Here, the closable resource is BufferedReader.

import  java.io.*;


public class Demo
{

        public static void main(String[] args) {
        StringBuilder obj = new StringBuilder();
        BufferedReader br = null;

        try (br = new BufferedReader(new InputStreamReader(System.in))){
            String lines = "";
            while (!(lines = br.readLine()).isBlank()) {
                obj.append(lines);
            }
        } catch(Exception e){
            e.printStackTrace();
        }


    }

}

Output:

Demo.java:13: error: <identifier> expected
        try (br = new BufferedReader(new InputStreamReader(System.in))) {
              ^
1 error

The error will be resolved if we declare the BufferedReader obj inside the try block.

import  java.io.*;


public class Demo
{

    public static void main(String[] args) {
        StringBuilder obj = new StringBuilder();

        try (BufferedReader br = new BufferedReader(new InputStreamReader(System.in))){

            String lines = "";
            while (!(lines = br.readLine()).isBlank()) {
                obj.append(lines);
            }
        } catch(Exception e){
            e.printStackTrace();
        }


    }

}

Conclusion

In this article, we learned about why the <identifier> expected error had been raised by the compiler and how it’s the most common compile-time error faced by newbies. We also looked at different examples analyzing the cases when this error was raised.

In this article, we’ll give you some pointers on how to fix the Identifier Expected Warning in Java.

1. Why does it appear?

Identifier Expected is one of many different syntax error messages a Java compiler may produce. It occurs when the compiler reaches a point in your program where, based on the grammar of the Java language, an identifier must appear, but something else is there instead.

2. What does the Identifier Expected Warning in Java mean?

Technically, an “Identifier Expected” error means exactly what it says: at some point in your program, the Java compiler expected to find an identifier, but instead found something else. However, Java compilers and Java developers each view code (especially buggy code) through very different sets of eyes. What a Java compiler might diagnose as “Error A at location x” can look more like “Error B at location y” to a human observer. So, in practice, it’s best not to take “<identifier> expected” errors too literally: treat them as if they mean “an error”, rather than “the error”.

3. How to fix the Identifier Expected Warning in Java

The key to addressing “<identifier> expected” errors successfully is not to read too much into them. Don’t assume the problem is literally a missing identifier at the indicated location, and don’t assume the solution is to insert an identifier at the indicated location. Always look at the bigger picture, and come to your own conclusion about what the “real” problem and its proper solution are. Here are a couple of examples to inspire you.

3.1 Example #1

These two nearly identical pieces of code each have an error at line #5:

Demo1WithErrors.java

package com.jcg.identexpected;

public class Demo1WithErrors
{
    public static double squareOf(double)
    {
        return x * x;
    }
}

codedemossrcmainjavacomjcgidentexpectedDemo1WithErrors.java:5: error:  expected
     public static double squareOf(double)
                                         ^
 1 error

Demo2WithErros.java

package com.jcg.identexpected;

public class Demo2WithErrors
{
    public static double squareOf(x){
        return x * x;
    }    
}

codedemossrcmainjavacomjcgidentexpectedDemo2WithErrors.java:5: error:  expected
     public static double squareOf(x){
                                    ^
 1 error

The Java compiler diagnosed identical errors in both cases: an <identifier> was expected at the location of the right-paren. You, however, probably see two somewhat different problems:

• In Demo1WithErrors, the parameter was supposed to be double x; the type double was specified, but the name x was omitted;
• In Demo2WithErrors, the parameter was supposed to be double x; the name x is present, but the type double was omitted.

But had you been thinking like a Java compiler, you would have seen things this way:

• In Demo1WithErrors, the parameter should consist of a <type>, followed by an <identifier>; the <type> is double, but no <identifier> follows, only a right-paren. Thus “<identifier> expected” error at the position of the right-paren!
• In Demo2WithErrors, the parameter should consist of a <type> followed by an <identifier>; the type is x, but no <identifier> follows, only a right-paren. Thus, “<identifier> expected” error at the position of the right-paren.

Both sets of assessments are technically correct, just from different points of view.

The fix, in both cases, is to make the parameter declaration read double x. In the case of Demo1WithErrors, it’s a simple matter of taking the error message more or less at its word and inserting the missing identifier x after the existing type double (in other words, at the position right-paren):Demo1.java

package com.jcg.identexpected;

public class Demo1
{
    public static double squareOf(double x)
    {
        return x * x;
    }
}

As for Demo2WithErrors, the “intuitive” fix is simply to insert the missing type double before the existing parameter name x, more or less ignoring the specifics of the “<identifier> expected” error. But another way to think about it is that you are first inserting the missing identifier, x, at the location of the right-paren, and then correcting the already-present, but incorrect, type x to double. Either way, the end result is:Demo2.java

package com.jcg.identexpected;

public class Demo2
{
    public static double squareOf(double x){
        return x * x;
    }    
}

3.2 Example #2

An “<identifier> expected” error can sometimes be just a minor symptom of a much larger problem. Consider this common newbie mistake:Demo3WithErrors.java

package com.jcg.identexpected;

import java.util.Arrays;

public class Demo3WithErrors
{
    int[] nums = {9,1,3,10,7,4,6,2,8,5};
    int max;
    max = nums[0];
    for (int i = 1; i < nums.length; ++i){
        if (nums[i] > max){
            max = nums[i];
        }    
    }
    System.out.println("List: " + Arrays.toString(nums));
    System.out.println("Largest = " + max);
}

This code produces a rather impressive slew of error messages (29 in all!) that starts off with these:

codedemossrcmainjavacomjcgidentexpectedDemo3WithErrors.java:9: error:  expected
     max = nums[0];
        ^
 codedemossrcmainjavacomjcgidentexpectedDemo3WithErrors.java:10: error: illegal start of type
     for (int i = 1; i < nums.length; ++i){
     ^
 codedemossrcmainjavacomjcgidentexpectedDemo3WithErrors.java:10: error: ')' expected
     for (int i = 1; i < nums.length; ++i){
               ^
 codedemossrcmainjavacomjcgidentexpectedDemo3WithErrors.java:10: error: illegal start of type
     for (int i = 1; i < nums.length; ++i){
                  ^
 codedemossrcmainjavacomjcgidentexpectedDemo3WithErrors.java:10: error:  expected
     for (int i = 1; i < nums.length; ++i){
                   ^
 codedemossrcmainjavacomjcgidentexpectedDemo3WithErrors.java:10: error: ';' expected
     for (int i = 1; i < nums.length; ++i){
                    ^
 codedemossrcmainjavacomjcgidentexpectedDemo3WithErrors.java:10: error: > expected
     for (int i = 1; i < nums.length; ++i){
                             ^
 codedemossrcmainjavacomjcgidentexpectedDemo3WithErrors.java:10: error: '(' expected
     for (int i = 1; i < nums.length; ++i){

Clearly there’s something more going on here than a simple missing identifier. The Java compiler seems unable to recognize perfectly normal Java statements!

The problem here is that these statements have been dropped right into the top level of the Demo3WithErrors class body, where only class member declarations belong. The compiler doesn’t recognize statements at this point in the code, simply because it isn’t expecting any statements. Instead, it tries to parse the statements as class member declarations, with varying degrees of success.

The solution, of course, is to put those statements where they belong, in an appropriate context. Here it makes sense to move them into a new main method:Demo3.java

package com.jcg.identexpected;

import java.util.Arrays;

public class Demo3
{
    public static void main(String[] args)
    {
        int[] nums = {9, 1, 3, 10, 7, 4, 6, 2, 8, 5};
        int max;
        max = nums[0];
        for (int i = 1; i < nums.length; ++i) {
            if (nums[i] > max) {
                max = nums[i];
            }
        }
        System.out.println("List: " + Arrays.toString(nums));
        System.out.println("Largest = " + max);
    }
}

4. Summary

That was an article on how to fix the Identifier Expected warning in Java.

• The «Identifier Expected» message is caused by a syntax error in your code;
• The «real» error might, or might not, actually be the result of a missing identifier, and inserting the supposed missing identifier might, or might not, fix it;
• Look at the bigger picture and use your own best judgment.

5. Download the Source Code

Use the link below to download a Maven project containing all the example code from this article.

An identifier expected error is a very common error faced by beginners. In this section, we will discuss what is identifier expected error, the reasons to occur errors, and how to fix the identifier expected error in Java. Before moving to the error first we will understand what are identifiers in Java.

Identifiers in Java are symbolic names used for identification. They can be a class name, variable name, method name, package name, constant name, etc. However, In Java, there are some reserved words that cannot be used as an identifier such as int, const, new, double, enum, etc.

What is an identifier expected error?

It is a very common compilation error that occurs at compile time.

Let’s consider the following Java program.

IdentifierError.java

When we try to compile the above program, we get the following error.

The code looks fine but not so. Because the print statement is not a proper place. It should be inside a method/ block. Let’s wrap the code inside a method and then compile and run.

IdentifierError.java

Output:

Reasons to Occur Error

There may be the following reasons to occur the error:

• It occurs when the code does not comply with the Java syntax rules.
• A block of code directly written in the class body instead of inside a method or block.
• There may be extra curly braces.
• The code is not at the proper place.
• Every statement must have a semicolon at the end.

How to fix/ resolve errors?

• Do not forget to put a semicolon at the end of the statement.
• Do not put code directly inside the class body.
• Calling of methods must be inside a method, constructor, or static initializer.
• Write a block of code at the proper place.
• Remove extra curly braces.

IdentifierErrorExample1.java

Let’s compile the above code. We get the <identifier> expected error.

Observe the above code, we get there is an extra curly brace that is the reason to generate an error. The error can be fixed by removing an extra brace at line 6.

The error also occurs when we put semicolon instead of comma while defining values in enum. For example, consider the following code.

IdentifierErrorExample2.java

Let’s run the above code. we get the identifier expected error.

To fix the error, remove semicolons from the enum values.

Sometimes the error may be much larger. Consider the following code.

IdentifierErrorExample3.java

Let’s compile the above code.

We get too many errors because some statements directly write inside the class body. To resolve the error, write entire the block of code inside a method and then compile and run.

IdentifierErrorExample4.java

Output:

In this post, I will be sharing how to fix the error «identifier expected in Java«. This compilation error is mostly faced by Java beginners. This error generally occurs when you place the code inside the class instead of the method. Before moving on to the solution, we will produce the error first.

Read Also: Error: Could not find Java SE Runtime Environment

[Fixed] Error : Identifier expected

Example 1: Producing the error by using an extra curly brace

Consider the following code:

public class HelloWorld {
   public static void main(String args[]) {
      System.out.println("Alive is Awesome");}
      System.out.println("Love Yourself");
   }  
}

If you compile the above code using the javac command:

javac HelloWorld.java

then you will find the following compilation error:

Output:

/HelloWorld.java:4: error: <identifier> expected
System.out.println(«Love Yourself»);
                              ^
/HelloWorld.java:4: error: illegal start of type
System.out.println(«Love Yourself»);
                               ^
/HelloWorld.java:6: error: class, interface, or enum expected
}
^
3 errors

Explanation

If you observe the code, then you will find there is an extra curly brace, since the code is not properly indented, it is difficult to view. The above error can be fixed by removing the extra curly brace.

Solution

public class HelloWorld {
   public static void main(String args[]) {
            
     System.out.println("Alive is Awesome");
     System.out.println("Love Yourself");
   }  
}

Output:
Alive is Awesome
Love Yourself

Example 2: Producing the error by placing code inside the class

public class HelloWorld {
      System.out.println("Alive is Awesome");
}

If you compile the above code using the javac command:

javac HelloWorld.java

You will get the following error:

Explanation

We are getting <identifier> expected error because we have placed the code inside the class not inside the method. Let’s solve this issue by placing the code inside the main method.

Solution

public class HelloWorld {
   public static void main(String args[]) {
      System.out.println("Alive is Awesome");
   }  
}

Output:
Alive is Awesome

Example 3: Producing the error by missing comma in enum

Consider the following code:

public class MissingComma {
    public enum Company {
        APPLE;
        GOOGLE;
    }

    public static void main(String args[]){
        for(Company c : Company.values())
            System.out.println(c);
    }
}

If you compile the above code using the javac command i.e javac MissingComma.java then you will face the following compilation error:

Output:

/MissingComma.java:4: error: <identifier> expected
GOOGLE;
                ^
1 error

Explanation

We are getting <identifier> expected error because we have missed comma in the enum types. Let’s solve this issue by placing the comma inside the enum Company.

Solution

public class MissingComma {
    public enum Company {
        APPLE,
        GOOGLE;
    }

    public static void main(String args[]){
        for(Company c : Company.values())
            System.out.println(c);
    }
}

Output:
APPLE
GOOGLE

That’s all for today, please mention in the comments in case you are still facing the error: identifier expected in java.