L'année dernière, j'ai revisité la programmation, en me concentrant sur Java après une pause. Mon objectif était un langage plus difficile que Python. J'ai consacré 3 à 4 mois à la maîtrise des concepts principaux de Java: sa mécanique opérationnelle, sa programmation orientée objet (OOP), sa gestion de la mémoire et la connectivité de la base de données via JDBC.

Récemment, je suis passé au développement Web, en commençant par JavaScript. Après quelques jours à explorer JavaScript, j'ai hâte de partager mes observations et mes idées sur les principales distinctions entre Java et JavaScript, et comment une transition en douceur est possible.

Différences de base

La différence la plus frappante réside dans la déclaration de type de données. JavaScript est dynamiquement typé, contrairement au typage statique de Java. Bien que les deux approches aient des mérites et des inconvénients, nous nous concentrerons sur la distinction clé: les contrastes de nature unique de JavaScript avec les capacités multi-thread de Java.

java vs javascript: une analogie simple

Imaginez Java comme un soldat méticuleux et orienté vers le détail. Les instructions doivent être précises, spécifiant à la fois la tâche et sa justification. JavaScript, inversement, ressemble à un ami détendu; Il termine efficacement les tâches sans détails excessifs - fournissez simplement la tâche, et il gère l'exécution.

Gestion des types de données

Java oblige la déclaration de type de données explicite (par exemple, string , int , float , boolean ) lors de la définition des variables. JavaScript, cependant, est flexible; Les variables sont déclarées en utilisant let ou const (pour les constantes), avec la détermination du type se produisant au moment de l'exécution. Tandis que var a servi un objectif similaire, let et const sont maintenant préférés.

java Exemple:

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

javascript exemple:

let a = 5;
let b = 6;

let sum = a   b;

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

Divergences OOP dans Java et JavaScript

Comprendre OOP dans JavaScript est crucial, étant donné son utilisation généralisée. Au-delà du typage dynamique de JavaScript, il s'agit de propriétés héritées basées sur un prototype via des prototypes. Post-ES6, JavaScript prend en charge entièrement OOP avec les classes, mais s'appuie fondamentalement sur les prototypes.

Les extraits de code suivants illustrent les différences syntaxiques dans la création de la classe et de la méthode:

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();

Création d'objets dans javascript

Dans Java, la création d'objets nécessite une définition de classe. JavaScript offre une flexibilité; Les objets peuvent être créés directement sans déclarations de classe explicites.

Java exige que chaque objet soit une instance d'une classe. JavaScript permet la création d'objets directs:

javascript

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

person.greet();

Mécanismes d'héritage

La syntaxe de l'héritage montre des similitudes sur les deux langues.

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();

Considérations d'encapsulation

L'encapsulation de JavaScript est plus faible que celle de Java; Il manque de modificateurs d'accès ( privé , protégé , public ). Cependant, la notation # (champ privé), introduit dans ES2022, fournit un degré de contrôle de champ privé:

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

Aspects du polymorphisme

Java prend en charge le polymorphisme à temps de compilation (surcharge de méthode) et le polymorphisme d'exécution (méthode dominante).

JavaScript ne prend pas en charge la surcharge de méthode en raison de sa nature interprétée et de son manque de vérifications de temps de compilation. La méthode dominante, cependant, est prise en charge:

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

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

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