Identifier Expected Error in Java

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.

In Java, an "identifier expected" error usually happens when the compiler comes across a token that doesn't follow the language's identifier conventions. In Java, an identifier must begin with a letter, dollar sign ($), underscore (_), or digit, and then another letter, digit, underscore, or dollar sign. They are not allowed to have any spaces or special characters (dollar signs and underscores excluded).

Let's consider the following Java program.

IdentifierError.java

public class IdentifierError
{
System.out.println("javatpoint");
}

Output:

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

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

Output:

javatpoint

Reasons to Occur Error

There may be the following reasons to occur the error:

Non-compliance with Java syntax rules: If the code does nots adhere to the syntax defined by Java, such as using reserved words inappropriately or violating rules for naming identifiers.
Code directly in the class body: Java requires code to be placed inside methods or blocks, not directly within the class body.
Extra curly braces: Additional curly braces can disrupt the structure of the code, leading to compilation errors.
Improper placement of code: Certain Java constructs have specific places where they should be used. Placing code incorrectly within the class or method structure can result in compilation errors.
Missing semicolons: Each statement in Java must end with a semicolon. Forgetting to add semicolons can lead to syntax errors, including "identifier expected" errors.

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

public class IdentifierErrorExample1
{
public static void main(String args[]) 
{
System.out.println("Python");
}
System.out.println("MySql");
System.out.println("Java");
}  
}

Output:

We get the <identifier> expected error.

Explanation

The Java code provided defines a class entitled IdentifierErrorExample2, which has an enumeration called Vegetables. Enumerations are utilised to define a fixed collection of constants, in this example representing several vegetable varieties (broccoli, tomato, and aubergine). There are commas between each constant and a semicolon at the end. Using the values() function, a for-each loop in the class's main method iterates over each value in the vegetable enumeration, printing each vegetable's name to the console.

Observing 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 use a semicolon instead of a comma when defining values in an enum. Consider the following code.

IdentifierErrorExample2.java

public class IdentifierErrorExample2
{
public enum Vegetables
{
eggplant,
tomato,
broccoli;
}
public static void main(String args[])
{
for(Vegetables veg : Vegetables.values())
System.out.println(veg);
}
}

Output:

we get the identifier expected error.

Explanation

An enumeration named Vegetables is included in a class entitled IdentifierErrorExample2, which is defined in the Java code given. In this example, enumerations are used to establish a fixed collection of constants that represent various vegetable varieties, such as broccoli, tomato, and aubergine. Every constant has a semicolon at the end and is separated by commas. A for-each loop in the class's main function uses the values () method to go over each value in the vegetable enumeration, printing each vegetable's name to the console.

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

public enum Vegetables
{
eggplant,
tomato,
broccoli;
}

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

IdentifierErrorExample3.java

import java.util.Arrays;
public class IdentifierErrorExample3
{
int[] primes = {17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73};
int max_val;
max_val = nums[0];
for (int i = 1; i < primes.length; ++i)
{
if (primes[i] > max_val)
{
max_val = primes[i];
}    
}
System.out.println("Primes Numbers are: " + Arrays.toString(primes));
System.out.println("Largest Prime is: " + max_val);
}

Output:

Explanation

The provided code fails to compile due to multiple syntax mistakes, preventing it from attempting to obtain the greatest prime number from an array of integers. First, the integer variable max_val and an array called primes are declared by the IdentifierErrorExample3 class. But rather than referencing primes, the assignment expression max_val = nums[0]; refers to an undefined array nums. Java syntax standards are also broken by the code that loops through the array to determine the maximum value without being included in a function or a block. This can be fixed by placing the code within a method, usually the main function, so that it runs correctly. Moreover, the class does not have a closing brace to finish the class body correctly.

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

IdentifierErrorExample4.java

import java.util.Arrays;
public class IdentifierErrorExample4
{
public static void main(String args[])
{
int[] primes = {17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73};
int max_val;
max_val = primes[0];
for (int i = 1; i < primes.length; ++i)
{
if (primes[i] > max_val)
{
max_val = primes[i];
}    
}
System.out.println("Primes Numbers are: " + Arrays.toString(primes));
System.out.println("Largest Prime is: " + max_val);
}
}

Output:

Explanation

This Java program demonstrates finding the greatest prime number from an array of integers. To print the array of prime numbers later, it first imports the Arrays class from the java.util package. The main procedure initialises an array called primes with prime numbers. Subsequently, an integer variable called max_val is declared to hold the largest prime number discovered.

Using a for loop, the program iterates through the array from index 1 to the current max_val, comparing each member. When a greater prime number is discovered, max_val is updated appropriately. Using the Arrays.toString() method, it prints the array of prime numbers and the greatest prime number discovered after iterating over all of the members.

Conclusion

In conclusion, it is critical for Java developers, especially novices, to comprehend and resolve the "identifier expected" issue. Java syntax standards and guidelines are frequently broken, leading to errors like this one. Examples of these include utilising reserved terms as identifiers, putting code inside the body of the class, and failing to include semicolons at the conclusion of statements. Through a thorough understanding of Java identifiers and following best practices for writing, developers may troubleshoot and fix this typical compilation fault. To help find and fix identifier-related problems, using IDE features and code analysis tools can be helpful. Developers can improve the quality and dependability of their Java code and reduce the likelihood of "identifier expected" mistakes by practicing consistently and paying close attention to detail.

Next TopicJava Generate UUID

← prev next →