You're trying to execute "C:/". You'll want to execute something like:

"javaw.exe d:\\somejavaprogram\\program.jar"

Notice the path separators.

I'm assuming this is for an ad-hoc project, rather than something large. However, for best practice running external programs from code:

• Don't hardcode the executable location, unless you're certain it will never change
• Look up directories like %windir% using System.getenv
• Don't assume programs like javaw.exe are in the search path: check them first, or allow the user to specify a location
• Make sure you're taking spaces into account: "cmd /c start " + myProg will not work if myProg is "my program.jar".

You could pass a Runnable:

public static long measureExecution(Runnable code) {
    long start = System.nanoTime();
    code.run();
    long time = System.nanoTime() - start;
    return time;
}

At the place where you call the method, use an anonymous inner class to wrap the code you want to measure:

long time = measureExecution(new Runnable() {

    @Override
    public void run() {
        System.out.println("Do something");
    }
});

(If you were using Java 8, you could use a lambda expression instead of an anonymous inner class, which would make the code shorter and easier to read).

Since Java 6, you can compile and run a Java compilation unit defined as a String or a File using standard APIs in the SDK (a compilation unit is basically everything that goes inside a .java file - package, imports, classes/interfaces/enumerations), take a look at this example. You can't run an arbitrary Java snippet like the one in your question, though.

If at all possible, it'd be a better idea to embed a different scripting language that allows you to run snippets of code from a Java program - for example, JavaScript, Groovy, MVEL, BeanShell, etc.

javac is the Java compiler. java is the JVM and what you use to execute a Java program. You do not execute .java files, they are just source files. Presumably there is .jar somewhere (or a directory containing .class files) that is the product of building it in Eclipse:

java/src/com/mypackage/Main.java
java/classes/com/mypackage/Main.class
java/lib/mypackage.jar

From directory java execute:

java -cp lib/mypackage.jar Main arg1 arg2

tl;dr

In modern Java, as a convenience to beginner Java students, the java app will graciously compile, and then run, a .java file.

Think of it as java app detecting a source-code file, then sub-contracting the compilation work out to javac app, caching the compiled class in memory, and lastly continuing onwards to run the newly compiled class.

Details

A JDK comes bundled with a few dozen tools. A couple of these are crucial:

• javac — Compiles .java file of source code text into .class file of bytecode.
• java — Execute that .class file by launching a JVM.

The process steps are:

1. You write Java source code in a .java file, including a main method inside a class definition.
2. You submit that file to a compiler, such as the javac app bundled with every JDK.
3. The compiler outputs a .class file.
4. You execute (run) the main method by launching the java app bundled with every JDK.

You can skip some steps.

• Compile and run a single file:
  As of Java 11, you can point the java app to a .java file. The java app will automatically compile first, as if javac were called on your behalf. Then the java app will go on to run the newly compiled class.
  • No .class file is written to storage. The compiled class is cached in memory.
  • See JEP 330: Launch Single-File Source-Code Programs for all the details.
  • This behavior is what you noted: However, java HelloWorld.java was executed properly without making HelloWorld.class.
• Simplified main
  As a preview feature in Java 21, you can:
  • Write your java file without declaring a class. Just write the main method alone, with nothing around it.
  • Drop the public static from your main method declaration.
  • See JEP 445: Unnamed Classes and Instance Main Methods (Preview) for details.

Motivation

The Java team is making concerted efforts to ease the way for beginning Java programmers, to smooth over the initial speed bumps. They are trying to mask some of the elaborate ceremony, and make the tooling more friendly and accommodating.

The underlying structures and features of Java are still in place. This is not a “dumbing-down” of Java. These efforts are just attempts at making reasonable accommodations for beginners.

Hello World

Combining these features, getting started with a Hello World app is a simple as writing the following in a HelloWorld.java file:

void main() {
    System.out.println("Hello, World!");
}

… and then on the command-line calling:

java HelloWorld.java

Result on the console:

Hello, World!

That is a vast reduction in labor and confusion for a brand-new student of Java.

jshell

By the way… Another piece of making Java easier to use is jshell, a REPL for Java.

Both beginners and pros find jshell handy for running short bits of Java with immediate feedback.

BlueJ

Another useful tool for beginners is BlueJ, an IDE designed for students.