Scala能否独立运行？Java版本及JRE/JDK需求解析

1. Can Scala run independently without pre-installed Java? Does the Java version affect Scala? #

Short answer: No, Scala can’t run independently without Java installed. Here’s why: Scala compiles down to JVM (Java Virtual Machine) bytecode—just like Java does. Every Scala program relies on the JVM to execute its code, and even the Scala SDK will look for an existing Java installation to use under the hood.

As for Java version impact: Absolutely, the Java version you use matters. Scala releases are tied to specific Java compatibility ranges:

• Most modern Scala versions (2.13.x and later) support Java 8 and newer.
• Older Scala versions (like 2.12.x) might have limited support for Java 9+ features, or require workarounds for the module system introduced in Java 9.
• Using a Java version that’s too old for your Scala release will lead to compilation or runtime errors (e.g., trying to use Scala 2.13 with Java 7 won’t work, since Scala 2.13 requires Java 8+).

2. Can a new computer run Scala code with only Scala installed (no Java)? If not, why? What parts of Java does Scala depend on? JRE vs JDK? Differences between Java 8,9,10 with Scala? #

Can you run Scala without Java? #

Nope—you can’t. Even if you install Scala alone, it won’t be able to execute any code because it needs the JVM to run the bytecode it produces. The Scala installer might even fail if it can’t detect a Java installation.

What parts of Java does Scala depend on? #

Scala relies on three key parts of Java:

• JVM (Java Virtual Machine): This is the runtime environment that executes Scala’s bytecode. Without it, there’s no way to run Scala programs.
• Core Java Libraries: Scala uses many of Java’s standard libraries (like java.lang, java.util, java.io) directly. For example, Scala’s List interacts with Java’s collection APIs, and Scala’s string handling builds on Java’s String class.
• JDK Tools (for development): If you’re compiling Scala code (using scalac or build tools like sbt), you’ll need parts of the JDK (Java Development Kit) like the Java compiler (javac) and header files—Scala’s compiler uses these to interface with Java code and libraries.

JRE vs JDK: Which do you need? #

• JRE (Java Runtime Environment): Enough if you only need to run pre-compiled Scala programs. It includes the JVM and core libraries required to execute code.
• JDK (Java Development Kit): Required if you’re writing, compiling, or building Scala projects. It includes all parts of the JRE plus development tools like compilers, debuggers, and libraries needed for compiling Scala (and Java) code.

Differences between Java 8, 9, and 10 when running Scala #

Let’s break down the key impacts:

• Java 8: This is the most widely adopted Java version for Scala projects. It’s fully supported by all modern Scala versions, and many Scala libraries are built to target Java 8. It introduced lambdas and streams, which Scala integrates seamlessly with. Stability and compatibility are the main benefits here—you’re unlikely to run into unexpected issues.
• Java 9: The biggest change was the introduction of the Java Platform Module System (JPMS). This affected Scala because some Scala libraries relied on internal Java APIs that became encapsulated in modules. Older Scala versions (pre-2.13) might throw runtime errors when accessing these APIs. Newer Scala versions (2.13+) have adapted, but you might need to adjust build configurations (like adding --add-opens flags) to work around module restrictions. Performance-wise, Java 9 included improvements to the G1 garbage collector, which can help with memory-heavy Scala applications.
• Java 10: This was a minor release that added features like local variable type inference (var). For Scala, the compatibility story is similar to Java 9—you’ll face the same module system considerations. Performance improvements were incremental (like better JIT compilation), but the real difference from Java 8 is still the module system and potential compatibility hurdles with older Scala libraries.

In general, if you’re starting a new Scala project, Java 8 is a safe bet for maximum compatibility. If you want to use newer Java versions, go with Scala 2.13+ and check that your dependencies support JPMS.

内容的提问来源于stack exchange，提问作者cikavladimir