El año pasado, revisé la programación, centrándome en Java después de un descanso. Mi objetivo era un lenguaje más desafiante que Python. Dediqué 3-4 meses a dominar los conceptos centrales de Java: su mecánica operativa, programación orientada a objetos (OOP), gestión de memoria y conectividad de base de datos a través de JDBC.

Recientemente, hice la transición al desarrollo web, comenzando con JavaScript. Después de unos días explorando JavaScript, estoy ansioso por compartir mis observaciones e ideas sobre las distinciones clave entre Java y JavaScript, y cómo es posible una transición suave.

Diferencias centrales

La diferencia más llamativa radica en la declaración de tipo de datos. JavaScript se escribe dinámicamente, a diferencia de la tipificación estática de Java. Si bien ambos enfoques tienen méritos y inconvenientes, nos centraremos en la distinción clave: la naturaleza de subproceso de JavaScript contrasta con las capacidades de múltiples subprocesos de Java.

java vs. javascript: una analogía simple

Imagine a Java como un soldado meticuloso y orientado a los detalles. Las instrucciones deben ser precisas, especificando tanto la tarea como su justificación. Javascript, por el contrario, se parece a un amigo relajado; Completa las tareas de manera eficiente sin detalles excesivos, simplemente proporcione la tarea y maneja la ejecución.

Tipo de datos Handling

java exige una declaración de tipo de datos explícitos (e.g., string , int , float , boolean ) al definir variables. JavaScript, sin embargo, es flexible; Las variables se declaran usando dejar o const (para constantes), con la determinación del tipo que ocurre en el tiempo de ejecución. Mientras que var sirvió un propósito similar, let y const ahora están preferidos.

Java Ejemplo:

class Main {
    public static void main(String[] args) {
        int a = 5;
        int b = 6;
        int result = a   b;
        System.out.println(result);
    }
}

JavaScript Ejemplo:

let a = 5;
let b = 6;

let sum = a   b;

console.log("The sum is: "   sum);

oop divergencias en java y javascript

Comprender OOP en JavaScript es crucial, dado su uso generalizado. Más allá de la tipificación dinámica de JavaScript, es propiedades basadas en prototipos y heredando las propiedades a través de prototipos. Post-ES6, JavaScript es compatible con OOP con clases, pero se basa fundamentalmente en los prototipos.

Los siguientes fragmentos de código ilustran las diferencias sintácticas en la creación de clase y método:

Java:

class Person {
    String name;

    Person(String name) {
        this.name = name;
    }

    void greet() {
        System.out.println("Hello, "   name);
    }

    public static void main(String[] args) {
        Person person = new Person("John");
        person.greet();
    }
}

javascript:

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

    greet() {
        console.log(`Hello, ${this.name}`);
    }
}

const person = new Person("John");
person.greet();

creación de objetos en javascript

En Java, la creación de objetos requiere una definición de clase. JavaScript ofrece flexibilidad; Los objetos se pueden crear directamente sin declaraciones de clase explícita.

java exige que cada objeto sea una instancia de una clase. JavaScript permite la creación directa de objetos:

javascript

const person = {
    name: "John",
    greet: function() {
        console.log(`Hello, ${this.name}`);
    }
};

person.greet();

mecanismos de herencia

La sintaxis de herencia muestra similitudes en ambos idiomas.

Java:

class Animal {
    void sound() {
        System.out.println("Some sound");
    }
}

class Dog extends Animal {
    void sound() {
        System.out.println("Bark");
    }
}

public class Main {
    public static void main(String[] args) {
        Dog dog = new Dog();
        dog.sound();
    }
}

javascript:

class Animal {
    sound() {
        console.log("Some sound");
    }
}

class Dog extends Animal {
    sound() {
        console.log("Bark");
    }
}

const dog = new Dog();
dog.sound();

consideraciones de encapsulación

La encapsulación de JavaScript es más débil que la de Java; carece de modificadores de acceso ( privado , protegido , public ). Sin embargo, la notación # (campo privado), introducida en ES2022, proporciona un grado de control de campo privado:

class Person {
    #name;

    constructor(name) {
        this.#name = name;
    }

    greet() {
        console.log(`Hello, ${this.#name}`);
    }
}

const person = new Person("John");
person.greet();
console.log(person.#name);  // Error: Private field '#name' must be declared in an enclosing class

aspectos de polimorfismo

java admite polimorfismo de tiempo de compilación (sobrecarga de métodos) y polimorfismo de tiempo de ejecución (anulación de método).

JavaScript no admite la sobrecarga de métodos debido a su naturaleza interpretada y falta de verificaciones de tiempo de compilación. La anulación del método, sin embargo, se admite:

class Animal {
    sound() {
        console.log("Some sound");
    }
}

class Dog extends Animal {
    sound() {
        console.log("Bark");
    }
}

const dog = new Dog();
dog.sound();  // Bark