A JavaScript Guide to Java

If you're a JavaScript developer diving into Java, the transition can be challenging. Not only are these two languages syntactically different, but they also operate in distinct environments. While JavaScript is dynamically typed and runs in browsers, Java is statically typed and runs in the Java Virtual Machine (JVM). This guide covers the key contrasts between JavaScript and Java and shows how to translate familiar JavaScript concepts into Java.

Key Takeaways

• JavaScript is interpreted in real-time by browsers; Java is compiled into bytecode before execution on the JVM.
• JavaScript variables aren't typed until runtime; Java requires type declarations at compile time.
• JavaScript uses functions as first-class objects; Java methods require access modifiers and return type specifications.
• Both languages support object-oriented programming but with different syntax and structure.
• JavaScript arrays are mutable by default, whereas Java utilizes ArrayList for mutable, variable-length arrays.

Running Code: Interpreted vs Compiled Languages

With JavaScript, your code is read and executed by the browser at runtime, which is why it's classified as an interpreted language. Take this simple example:

script.js

console.log('Hello world');

Java, on the other hand, is a compiled language. This means that Java code must be transformed into machine code before execution. Here's a simple "Hello, World!" program in Java:

HelloWorld.java

public class HelloWorld {
    public static void main(String[] args) {
        System.out.println("Hello world");
    }
}

To run the Java example, you first compile it with javac HelloWorld.java, which generates HelloWorld.class. This class file is then executed by the JVM using java HelloWorld.

Different Environments: Web Browsers vs JVM

JavaScript runs in a browser, harnessing its interaction with the DOM and assorted web APIs. Java code operates within the JVM, which translates Java bytecode into machine code that runs on the host system. This environment abstraction makes Java platform-independent.

Defining Variables

JavaScript is dynamically typed. You don't declare a variable's type, leaving the interpreter to infer it on the fly:

JavaScript

let name = "Sam";

In Java, variables must have a declared type due to static typing:

Java

String name = "Sam";

Why Static Typing?

While writing Java might require more upfront type declarations, this leads to more reliable and efficient code. Type errors are caught at compile time in Java, rather than at runtime as in JavaScript, preventing unexpected failures in production.

Functions

JavaScript's flexibility allows you to define functions without type constraints:

JavaScript function

const getName = function(name){
    console.log(name);
}

In Java, function definitions are more rigid. You must specify return and parameter types:

Java function

public void printName(String name){
    System.out.println(name);
}

Access Modifiers

Java's functions often start with an access modifier like public, private, or protected. These control the visibility and accessibility of classes, methods, and variables, unlike JavaScript, which lacks built-in access modifiers.

Classes

Both languages embrace object-oriented programming but differ in class syntax:

JavaScript (ES6)

class Person {
    constructor(age, name) {
        this.age = age;
        this.name = name;
    }
}

Java

public class Person {
    private int age;
    private String name;

    public Person(int age, String name) {
        this.age = age;
        this.name = name;
    }
}

Java requires access modifiers on all class members, providing more granular control over their exposure.

Objects (Dictionaries and Hash Maps)

JavaScript Dictionary

const dict = {a: 2, b: 6, c: 5};
// Access value: 2
console.log(dict.a);

Java HashMap

import java.util.*;
Map map = new HashMap<>();
map.put("a", 2);
// Access value: 2
System.out.println(map.get("a"));

JavaScript objects allow dynamic addition of properties without predefined types, but in Java, it's necessary to define key and value types, using classes like HashMap from java.util.

Arrays

ArrayList in Java provides functionality akin to JavaScript arrays:

JavaScript array

const arr = [1, 2, 3, 4];

Java array (using ArrayList)

import java.util.ArrayList;
ArrayList numbers = new ArrayList<>();
numbers.add(1);
numbers.add(2);

Java's base array type is fixed in size, making ArrayList a preferred choice for dynamic collections.

Loops

The syntax for looping in JavaScript is akin to Java:

JavaScript for loop

for(let i = 0; i < 5; i++) {
    console.log(i);
}

Java for loop

for(int i = 0; i < 5; i++) {
    System.out.println(i);
}

Both languages use the same loop structure, though Java requires explicit type declaration.

Conclusion

Java and JavaScript may operate differently, yet they share architectural similarities both rooted in object-oriented design. Modern JavaScript looks increasingly like Java, with TypeScript offering optional type binding and environments like the V8 engine employing JIT compilation. While shifting from JavaScript to Java might seem cumbersome, the journey enhances your coding capabilities, equipping you with skills crucial for future advancements in JavaScript.

FAQ

Is Java harder to learn than JavaScript?

It depends on your perspective. Java's strict type system and access control can seem demanding, but it offers advantages in code reliability and performance optimization.

Can JavaScript run outside the browser?

Yes, platforms like Node.js enable JavaScript to run on servers, allowing you to write full-fledged applications outside the browser.

Why use HashMap in Java over an array?

HashMap excels at fast data retrieval using keys, while arrays are more suited to ordered data that needs frequent index-based operations.

What does "static typing" mean?

Static typing requires declaring variable data types at compile time, catching type errors before the code runs, reducing runtime errors.