No ano passado, revisitei a programação, concentrando -se em Java após um intervalo. Meu objetivo era uma linguagem mais desafiadora do que Python. Dediquei 3-4 meses a dominar os principais conceitos de Java: sua mecânica operacional, programação orientada a objetos (OOP), gerenciamento de memória e conectividade do banco de dados via JDBC.

recentemente, fiz a transição para o desenvolvimento da web, começando com JavaScript. Depois de alguns dias explorando JavaScript, estou ansioso para compartilhar minhas observações e insights sobre as principais distinções entre Java e JavaScript, e como uma transição suave é possível.

Core Diferences

A diferença mais impressionante está na declaração do tipo de dados. O JavaScript é dinamicamente digitado, diferentemente da digitação estática de Java. Embora ambas as abordagens tenham méritos e desvantagens, nos concentraremos na distinção principal: a natureza de thread única de JavaScript contrasta com os recursos multi-threades de Java.

java vs. javascript: uma analogia simples

imagine java como um soldado meticuloso e orientado a detalhes. As instruções devem ser precisas, especificando a tarefa e sua lógica. JavaScript, inversamente, se assemelha a um amigo descontraído; Ele completa tarefas com eficiência sem detalhes excessivos - simplificando a tarefa e lida com a execução.

Tipo de dados Handling

Java exige a declaração de tipo de dados explícita (por exemplo, string , int , float , boolean ) ao definir variáveis. JavaScript, no entanto, é flexível; As variáveis ​​são declaradas usando let ou const (para constantes), com a determinação do tipo ocorrendo no tempo de execução. Enquanto var serviram a um propósito semelhante, let e const agora são preferidos.

Java Exemplo:

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

Javascript Exemplo:

let a = 5;
let b = 6;

let sum = a   b;

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

oop divergências em java e javascript

O entendimento do OOP em JavaScript é crucial, dado seu uso generalizado. Além da digitação dinâmica do JavaScript, é baseada em protótipos, herdando propriedades por protótipos. Post-ES6, JavaScript suporta totalmente OOP com classes, mas baseia-se fundamentalmente em protótipos.

Os seguintes trechos de código ilustram diferenças sintáticas na Criação de classe e 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();

criação de objeto em javascript

Em Java, a criação de objetos requer uma definição de classe. O JavaScript oferece flexibilidade; Objetos podem ser criados diretamente sem declarações de classe explícitas.

Java exige que todo objeto seja uma instância de uma classe. JavaScript permite a criação direta de objetos:

javascript

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

person.greet();

mecanismos de herança

A sintaxe da herança mostra semelhanças nos dois 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();

considerações de encapsulamento

o encapsulamento de JavaScript é mais fraco que o de Java; Falta modificadores de acesso ( privado , protected , public ). No entanto, a notação # (campo privado), introduzido no ES2022, fornece um grau de controle 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

Polimorfismo Aspectos

Java suporta polimorfismo de tempo de compilação (sobrecarga do método) e polimorfismo de tempo de execução (substituição do método).

javascript não suporta a sobrecarga do método devido à sua natureza interpretada e falta de verificações no tempo de compilação. Método A substituição, no entanto, é suportada:

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

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

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