Hey there! As a Java expert just getting started with JavaScript for an API, I totally get the confusion when switching between the two—their approach to classes and encapsulation is pretty different. Let's translate your Client class to JS first, then break down the key differences.

JavaScript Equivalent of Your Java Client Class #

We'll use modern ES6+ class syntax with true private fields (supported in Node.js 16+ and modern browsers):

// Client.js
class Client {
  // Private fields (marked with #, only accessible inside the class)
  #username;
  #password;
  #host;
  // Private constant-like field (initialized once, we won't modify it)
  #port = 25565;

  constructor(username, password, host) {
    this.#username = username;
    this.#password = password;
    this.#host = host;
  }

  // Getter methods, just like your Java example
  getUsername() {
    return this.#username;
  }

  getPort() {
    return this.#port;
  }

  getPassword() {
    return this.#password;
  }

  getHost() {
    return this.#host;
  }
}

// Export the class to use it in other files
export default Client;

How to Use This Class in Another File #

In Node.js, you can import and instantiate the class like this:

// app.js
import Client from './Client.js';

// Create a new Client instance
const myMinecraftClient = new Client('FrostyPlayer', 'securePass123', 'mc.server.com');

// Access data via getter methods
console.log(myMinecraftClient.getUsername()); // Output: "FrostyPlayer"
console.log(myMinecraftClient.getPort()); // Output: 25565

// Important: Trying to access private fields directly will throw an error
// myMinecraftClient.#username → SyntaxError: Private field '#username' must be declared in an enclosing class

Key Differences Between Java and JavaScript Classes & Encapsulation #

Let's break down the core contrasts that might be tripping you up:

1. Class Fundamentals #

• Java: Strictly class-based, statically typed. Classes are rigid blueprints—you define exactly what each instance will have at compile time, and everything (almost) is tied to a class.
• JavaScript: Prototype-based, dynamically typed. ES6 classes are just "syntactic sugar" over JS's prototype inheritance system. Under the hood, instances link to a prototype object, not a strict class blueprint. You can even add/modify properties on instances at runtime, even if they weren't defined in the class.

2. Encapsulation & Member Access #

• Java: Enforces encapsulation with explicit access modifiers (private, protected, public). Private members are completely locked away from external code—you must use getters/setters to expose them. final guarantees a value can't be changed after initialization.
• JavaScript:
  • Before ES2022, there was no true private syntax—developers used conventions like _username to signal "private," but these values were still accessible outside the class.
  • ES2022 introduced private fields (prefixed with #), which are truly inaccessible outside the class. There's no final keyword; to make a constant-like field, you initialize it in the class body and avoid modifying it (JS doesn't enforce immutability here unless you use tools like Object.freeze).
  • All non-private members are effectively public—no need for a public modifier.

3. Constructor & Initialization #

• Java: Constructors share the exact name of the class. You must explicitly initialize all instance variables (or rely on default values). final variables must be initialized either in their declaration or the constructor.
• JavaScript: Constructors use the constructor keyword. You can initialize properties either in the constructor or directly in the class body (like #port = 25565). Dynamic typing means you don't have to declare variable types upfront.

4. Getter Syntax (Bonus) #

• Java: You write explicit getter methods as you did in your example.
• JavaScript: You can use getter syntax for more natural property-like access, while still protecting private fields:

  class Client {
    // ... private fields and constructor ...
  
    get username() {
      return this.#username;
    }
  }
  
  // Usage: myClient.username (no parentheses needed!)
  

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