compile time error messages : Java Glossary

// oops missing [] in attempt to define an array literal
new String { "x", "y" };

// how to create string array literal
new String[] { "x", "y" };

• Usually this is just a missing semicolon,
• sometimes it can be caused by unbalanced () on the previous line.
• sometimes it can be cause by junk on the previous line. This junk might be far to the right off the screen.
• Sometimes it is caused by spelling the keyword if incorrectly nearby.
• Sometimes it is a missing + concatenation operator. C programmers often make this one on multi-line Strings since the concatenation operator is implied in C.

// Ambiguous Class import.
// If you were to use SomeClass, which one did you mean?
import x.y.SomeClass;
import a.b.SomeClass;

// Ambiguous Class import for x.y.SomeClass and a.b.SomeClass
// but the compiler won't mind unless you actually use SomeClass.
import x.y.*;
import a.b.*;

• You forgot to make the class public.
• In JBuilder, check the properties for your project. Your root directories should be plain C:\ not J:\com\mindprod\thepackage\

It ain’t what you don’t know that gets you into trouble. It’s what you know for sure that just ain’t so.
~ Mark Twain (1835-11-30 1910-04-21 age:74)

Cannot find symbol constructor XXX, means you likely you did an explicit XXX() to call the superclass constructor first thing in your constructor instead of using super().

Cannot find symbol method XXX, where XXX is your class’s superclass constructor means you likely you did an explicit XXX() to call the superclass constructor first thing in your constructor instead of using super().

Possible causes of the error for constructors and methods:

• Wrong syntax for calling: constructor: new X(), instance: x. someMethod(), static: SomeClass.someMethod ().
• The method you want is protected or private.
• You left out a parm.
• You added an extra parm.
• You have the parms in the wrong order.
• You have the type of a parm wrong, e.g. it wants a File, but you gave it a String.
• Symbols are case-sensitive. You have a mismatch.
• Confused package. Javac.exe is looking in the wrong package or class, e.g. java.util.List vs java.awt.Listawt.List. Use fully qualified references to rule that out.
• The referenced class did not compile because it has a syntax error.
• The needed class/jar files are not on the classpath.
• Cannot find symbol method sort(java.util.ArrayList<Xxx>) could mean you have not implemented Comparator on the class you are trying to sort.
• There is some other syntax error, than the compiler interprets its strange way as an undefined symbol.

• No such variable or method. Perhaps it exists, but not in the current scope, e.g. you are trying to use a variable defined inside a loop outside that loop.
• Possibly you are trying to use a constructor without new as if it were an ordinary method.
• You left off the () on your method call.
• If the error message is pointing to code that uses the standard classes, chances are you either misspelled it, or forgot to import the class, or misspelled the import. If it is pointing to one of your methods or variables chances are you misspelled it either in the definition or reference. Java is picky. You must get upper-lower case precisely correct too.
• If the code is pointing to one of your classes that is clearly there, perhaps you forgot to put C:\ on the classpath — the mother of all packages where com is in com.mindprod.thispackage lives. If you are not using packages, perhaps you forgot to put. on your classpath. A symptom of this is you can compile successfully if you rebuild everything, but not if you just recompile the changed modules.
• You are using a method of the object when the reference is to an interface that does not contain that method. Either cast to specific object, or change the reference to a specific object reference, e. g. addNever is a method of MultiFilter, but not of FileNameFilter.
• Watch for subtle spelling differences between declaration and reference, e.g. Hashtable and HashTable. Copy/paste the definition on top of the reference to be sure they are absolutely identical. Your eyes can fool you.
• In an implements clause, you may have used a period where you should have used a comma.
• If is complaining about the superclass of your constructor, the problem is you must either explicitly call super(), or there must be a superclass constructor with a matching signature.
• Cannot Find Symbol

• class name does not match source filename.
• Putting more than one public class per file.
• Getting the capitalisation wrong in the filename on the javac command line or in the filename itself.

There is nothing wrong with the text of your program; the problem is in how you tried to compile it. You left off the *.java extension when compiling with javac.exe, e.g. at the command line you typed:

• You are using Internet Explorer which has a defective or missing Java.
• Some other syntax error ahead of the class declaration is preventing the compiler from seeing the class declaration.
• The class is not in the proper file in the proper directory.
• The class is not public.
• The class does not have the correct case, either in the class name or the file name.
• The corresponding class or java file is not on the CLASSPATH (considering the package name.)

• Put your package statement before all the imports. The imports come before your class declarations.
• Make your class public, not protected.
• You may have too many } so that you have finished off your class before you intended too. Using a source code beautifier that aligns code block and {} will help make these sorts of errors obvious.

• You are attempting to instantiate a non-static named inner class without an instantiated the outer class. Solution: declare the named inner class as static or instantiate your inner class like this as described under nested classes.
• You used an expression like JApplet.this in an inner class. You must specify the precise name of the enclosing class, e.g. MyApplet. this not one of its superclasses. If you wanted a superclass reference you would have to use (JApplet) MyApplet. this.

// base class
class SalesTaxItem implements Comparable<SalesTaxItem>
{
...
}

The best way I know of to bypass the problem is to write both classes without the implements Comparable. Then write two Comparators instead.

You might have written new ArrayList <String>[ 100] instead of new ArrayList< String>( 100);

To be charitable, Java’s generics are Mickey Mouse. One of the side effects of the el-cheapo implementation is that you can’t have arrays of generic collections, e. g. the following is illegal

Java computes its static initialisation in a simplistic top to bottom way. It is not clever, in using natural order like a spreadsheet. Any value you reference must be defined lexically earlier in the class. This holds both for the order of initialisations and for the order of assignments in a static init or instance init block.

• You may not reference an enum constant that has not yet been defined. e.g. you cannot reference other enum constants in an enum constructor call.
• You must declare static finals before you define them in a static init block. Put your static init blocks after all your static final variables.
• You must define the value of a static final before you can use it in defining the value of another static final.

The direct superclass of an enum type named E is Enum<E>. In addition to the members it inherits from Enum<E<, for each declared enum constant with the name n the enum type has an implicitly declared public static final field named n of type E. These fields are considered to be declared in the same order as the corresponding enum constants, before any static fields explicitly declared in the enum type. Each such field is initialized to the enum constant that corresponds to it. Each such field is also considered to be annotated by the same annotations as the corresponding enum constant. The enum constant is said to be created when the corresponding field is initialized. The direct superclass of an enum type named E is Enum<E<. In addition to the members it inherits from Enum<E<, for each declared enum constant with the name n the enum type has an implicitly declared public static final field named n of type E. These fields are considered to be declared in the same order as the corresponding enum constants, before any static fields explicitly declared in the enum type. Each such field is initialized to the enum constant that corresponds to it. Each such field is also considered to be annotated by the same annotations as the corresponding enum constant. The enum constant is said to be created when the corresponding field is initialized.
~ Java Language Spec

• The error message will point to perfectly good code. Look just ahead of it for a missing } or ;
• static int x = 0; Static variables have to be defined outside all methods inside a class.
• you wrote x + = 2; instead of x += 2; You also may have used an ) when you meant a }.
• you wrote case: STRAWBERRY instead of case STRAWBERRY :
• You nested a method inside another method.

• undefined (missing) method.
• You wrote MyClass x = MyClass(); instead of MyClass x = new MyClass();

• You wrote doSomething( String[] choices ) rather than doSomething( choices )
• There is a stray } just before of where it is complaining.

• missing caps on a class name declaration.
• Caps on a variable/method declaration

• this.x = x; Effectively you wrote this.x = this.x; because there is no x parameter.

• // This method does nothing,
  // just sets this.brush to itself.
  // Note misspelling brash for brush.
  // No warning!
  // Eclipse compiler will warn you though.
  public voidsetBrush ( int brash )
     {
     this.brush = brush;
     }

• The array is automatically initialised to null. This will likely soon lead to a java.lang.NullPointerException when you try to apply some method to one of the elements of the array. Note Null PointerException, not NullReferenceException. You forgot to initialise an array of strings or objects to some value.
• You forgot to initialise an int array to some value or populate it with objects.

• In a static method, you used an instance method without an object, e.g. MyClass.xxx(). You must first create an object with MyClass o = new MyClass();, then use o.xxx(); to invoke the method.
• You used an instance variable (one without the static attribute) inside a static method. static methods don’t have access to any particular object, so can’t use any of the instance (per object) fields. You may have used a reference to an inner class inside a static method. Make that inner class an ordinary separate class. Inner classes are always linked to an instance of the main class. You may have tried to instantiate an inner class in some static code. You need to make the inner class static to be able to use it without a mother object.
• You tried to access an instance variable or method of the outer class from static nested class.
• You tried to instantiate/reference a non-static inner class from a static method of the outer class. Either make the inner class static, or make it an independent class, or make the invoking method an instance method.
• This sounds bizarre, but you were using an enum with some enum private methods. Remove the private keyword and magically all will work. Use an IDE like IntelliJ Idea to show you will methods can be private. This is a side effect of the way enums are implemented. enum constants with a body of their own methods are implemented as anonymous inner classes defined in a static init block. They can’t access the private methods of the mother class. The error message is misleading. The problem is one of scope, not context.

• The compiler was expecting a statement and you gave it something else, e. g. you wrote if (i > 7) 42;. You might have used a variable name beginning with a digit or punctuation or some other improper character.
• Perhaps you used == instead of = in an assignment statement, turning it into an expression instead of a statement.
• you wrote x + = 2; instead of x += 2;
• Perhaps you had a stray semicolon in a statement made of dozen of concatenations.

• Java is case-sensitive. The package is called java.applet, not Java.Applet. Package names are supposed to be pure lower case.
• Check that the package is available on the classpath or in some jar in the appropriate ext directory. You can use winzip to examine the jar file directories to find out which classes they contain. To help discover which jar does contain your class use Google on the package name + jar. Then get that jar on the classpath or in the ext directory.
• This error can so come up when you try to allocate an inner class object, e.g.

  import java.awt.geom.Ellipse2D;
  
  ...
  
  // allocate an inner class Float object of the Ellipse2D class
  return new Ellipse2D.Float( x,  y,  w,  h );

  You should use an import for the outer class. You don’t need to import the inner, though you may optionally do so. Don’t try to use * notation to import the inner class..

/**
 * Defining a layout version for a class.
 * Watch the spelling and keywords!
 */
public static final long serialVersionUID = 3L;

• extra }, or literally a missing type, especially in constant declarations like: public static final SOMETHING=3; instead of public static final int SOMETHING=3;
• Executable code has to be inside some method, in a static initialiser block or in an instance initialiser block. It can’t be just dangling inside a class or outside any class. Check that your {} are balanced. Code you think is in a method may actually be outside because of an extra unbalanced }.

• caps on a variable reference
• missing variable declaration

• Look for a missing { slightly before where it is complaining.
• Usually it means you put a semicolon where one was not supposed to be ahead of a {, such as at the end of an implements or extends clause. There are many errors of this type the compiler cannot catch because Java slavishly copied C syntax. For example, getting your semicolons wrong in a for loop will generally not generate an error, just give surprising results.

• Missing } at the end of a class.
• Missing } is on a line containing // before the }.
• Failure to enclose initialiser code in {} or static {}.
• Code has to live inside some method, or inside some initialiser. It can’t just be left lying out in the middle of the class declarations.
• forgetting static { } around class init code.
• Perhaps 

  // Oops, interfaces extend other interfaces,
  // only classes can implement them.
  interface X implements Y
     {
     // ...
     }

  instead 

  // Correct. An interface extends another interface,
  // it cannot implement it.
  // A class extends another class or implements an interface.
  // An interface cannot extend or implement a class.
  interface X extends Y
     {
     // ...
     }