The simple solution, as other people have said, is to split your two public classes into two separate .java files. That will solve both the error you've already encountered and another that you were going to encounter later... but "too many public classes" is not what your Java compiler is complaining about. The real reason you're getting that error is that you can't put import statements after class declarations.

The error message is easy to misread. It seems to be complaining about what you're importing --- probably provoking a response like, "But I am importing a class!". But note where the ^ is pointing --- not at java.util.*, but at the word import:

Calc.java:22: error: class, interface, or enum expected
    import java.util.*;
    ^
1 error

This error is actually complaining about the out-of-place import statement --- it shouldn't be there at all. Once you've declared your first class, it's too late to import anything else. In a roundabout way, it actually says so: By line 22 of Calc.java, nothing can appear at the top level but type declarations --- the "interface, class, or enum" it mentioned --- so encountering a line that starts with import is "unexpected", meaning not allowed.

You can verify this by commenting out the second import (line 22) and compiling. You'll still get errors, but different ones.

As an aside, you are allowed to import java.util.*; more than once. The redundant statements will be ignored... as long as they're in the right place. You can verify this by moving the second import up to around line 3 or 4 and compiling. Again, you'll still get errors, but not about that.

The Correct Order

A single .java file (called a "compilation unit" in the language spec) has the following three parts, which must appear in this order:

1. Zero or one package declarations.
2. Zero or more import statements.
3. Zero or more top-level type declarations, like class, enum, or interface.

From the Java 1.8 Language Specification, Section 7.3: "Compilation Units"]:

CompilationUnit is the goal symbol (§2.1) for the syntactic grammar (§2.3) of Java programs. It is defined by the following productions:

CompilationUnit: [PackageDeclaration] {ImportDeclaration} {TypeDeclaration}

A compilation unit consists of three parts, each of which is optional[...]

In case that last phrase made you wonder: Yes, a completely empty .java file will compile without warnings... and without producing any .class files.

Solutions

As has been pointed out by others, you can't have more than one top-level public class or other type declaration in a single file. Unless you're willing to nest one of Calc and NumCalc inside the other, they have to split up into Calc.java and NumCalc.java.

Actually, you could sidestep the problem by reducing one class's visibility to package-default, but that's fragile and not the way Java is generally done. If you tried to use the package-default class in any other .java file, even one in the same package, it would fail to compile because it couldn't find the supposedly-package-visible class --- either Calc would be in the wrongly-named NumCalc.java (not where the compiler will look for it), or NumCalc would be hiding out inside Calc.java.

But why bother with all that? You could combine the two classes into one class very easily, and have a more coherent project. (I'm not sure why they're separate classes in the first place.)

You shouldn't put everything in one file. Create a new file, DotCom and paste the code below

import java.util.*;
public class DotCom {
    private ArrayList < String > locationCells;
    private String name;
    public void setLocationCells(ArrayList < String > loc) {
        locationCells = loc;
    }
    public void setName(String n) {
        name = n;
    }
    public String checkYourself(String userInput) {
        String result = "miss";
        int index = locationCells.indexOf(userInput);
        if (index <= 0) {
            locationCells.remove(index);
            if (locationCells.isEmpty()) {
                result = "kill";
                System.out.println("you sunk " + name);
            } else {
                result = "hit";
            }
        }
        return result;
    }
}

Be sure to remove the code above from DotComBust.

2 same imports(import java.util.*; import java.util.*) cannot exist in 1 Java source file. What you have to do is either split it to 2 source files or remove the second import.

Per the java.util.function Javadoc,

Since:
      1.8

So upgrade to Java 8, or try to find an older version of the tutorial.

I'm new at this. How can you tell what you are running? I'm using Eclipse

To determine your current Java version in eclipse, go to

Help -> About Eclipse -> Installation Details (Button in
          lower Left) -> Configuration pane

Look for the line java.specification.version - on my machine that is

java.specification.version=1.8

Or the line java.runtime.version - on my machine that is

java.runtime.version=1.8.0_11-b12

That should be import java.util.*; What this statement means is include ALL the types those are present in java.util package.

If you want to include only specific type then you can use fully qualified name e.g. java.util.Calendar. This will include only the Calendar class.

There is a common misconception that import statement is used to include the required types to use in the code but that is not completely true. It just enables us to use the short name instead of its fully qualified name.

You can still use

package com.so;

public class ImportTest {


    public static void main(String[] args) {

        java.util.Date date = new java.util.Date();
        System.out.println(date);

    }

}

This will compile fine and print current date. The import statement just enables us to use short names for the types.

so when you use import statement then code becomes.

package com.so;

import java.util.Date;

public class ImportTest {


    public static void main(String[] args) {

        Date date = new Date();
        System.out.println(date);

    }

}

That isn't how you import a package, this

import java.util.function;

should be

import java.util.function.*;

To import the classes in the java.util.function package.

I guess you are using an IDE (like Netbeans or eclipse) which allows you to run the code even if certain classes are not compilable. During the application's runtime, if you access this class it would lead to this exception.

Solution :- Simply Clean Your Project and Build and Run Then Again.

The problem with importing * is that it increases the chance of naming conflicts.

Let's assume that in your program, you have a class called EventListener, since java.util also has a class called EventListener, right the way you have some conflicts to deal with, but you do not even care that java.util.EventListener in this context.

This really can be avoided, simply by not importing * and only importing specific classes that are truly needed.

import must be spelt with a lower-case "i". Try this!

...additionally, you might be wanting to say "import java.util.*;" because util is a package that contains many objects. The * tells it to import all of those objects!

The import goes here:

import java.util.Scanner;

public class JavaApplication2 {

    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        Scanner reader = new Scanner(System.in);
        // code here

    }
}

It is not a property of the class but a reference the compiler needs to be able to tell what "Scanner" (in this context) refers to. In this case it states that Scanner is defined in java.util which is part of the Java Runtime Environment (JRE).

Furthermore as you go on coding you should structure your files into folders. As soon as you do so you will have to add this type of line in the first line of the file: package folderName.folderName0. If you want to use one of your classes from another one you will have to add an import like: import folderName.folderName0.JavaApplication2

The line:

import java.util.*

doesn't just import Scanner. It brings everything from the java.util namespace into your imports.

You'll have AbstractCollection, Collection, Comparator, Deque, Enumeration, ... all the way to Vector and WeakHashMap.

Write what you mean and mean what you write. You aren't intending to bring everything in the java.util package into your namespace. You want to bring one class. Bringing in too much, especially in this day of easily adding imports to a class and collapsing all them at the top is unnecessary.

^{In days of old, long before IDEs for Java were commonplace, I'll certainly admit to doing an import of * into my class. It was easier to write the import in vi, and it saved a few back and forth to the compiles to say "oh, I don't have java.awt.Color in here, but I've already got java.awt.Button and java.awt.GridBagLayout and java.awt.GridBigConstraints and... frack... I'll just do import java.awt.* and be done with it" Those were in the days of old. You don't do that anymore, especially for one class.}

Furthermore, most IDEs will automatically convert the import of java.util.* into what you want, unless you actually are importing everything in the package (sometimes seen with "I'm importing all the my.package.exceptions that I wrote" or "I'm importing all the my.package.dtos that I wrote").