Letztes Jahr habe ich das Programm überarbeitet und mich nach einer Pause auf Java konzentriert. Mein Ziel war eine schwierigere Sprache als Python. Ich widmete 3-4 Monate der Beherrschung der Kernkonzepte von Java: seine Betriebsmechanik, die objektorientierte Programmierung (OOP), die Speicherverwaltung und die Datenbankkonnektivität über JDBC.

Vor kurzem habe ich in die Webentwicklung übergegangen, beginnend mit JavaScript. Nach ein paar Tagen, die JavaScript untersucht haben, bin ich bestrebt, meine Beobachtungen und Erkenntnisse zu den wichtigsten Unterscheidungen zwischen Java und JavaScript zu teilen und wie ein reibungsloser Übergang möglich ist.

Kernunterschiede

Der auffälligste Unterschied liegt in der Datentypdeklaration. JavaScript wird im Gegensatz zu Javas statisches Tippen dynamisch getippt. Während beide Ansätze Verdienste und Nachteile haben, konzentrieren wir uns auf die wichtigste Auszeichnung: Javascripts einzelne Thread-Natur steht im Gegensatz zu Javas Multi-Thread-Funktionen.

java vs. JavaScript: Eine einfache Analogie

Stellen Sie sich Java als akribische, detailorientierte Soldat vor. Anweisungen müssen präzise sein und sowohl die Aufgabe als auch die Gründe angeben. JavaScript ähnelt umgekehrt einem entspannten Freund; Es erledigt Aufgaben effizient ohne übermäßige Details - die Aufgabe einfach bereitzustellen und die Ausführung zu behandeln.

Datentyp Handling

java mandate explizite Datentyp -Deklaration (z. B. string , int , float , boolean ) beim Definieren von Variablen. JavaScript ist jedoch flexibel; Variablen werden mit deklariert oder const (für Konstanten), wobei die Typentscheidung zur Laufzeit auftritt. Während var einen ähnlichen Zweck diente, werden und const jetzt bevorzugt.

Java Beispiel:

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

JavaScript Beispiel:

let a = 5;
let b = 6;

let sum = a   b;

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

oop -Abweichungen in Java und Javascript

OOP in JavaScript zu verstehen ist angesichts seiner weit verbreiteten Verwendung von entscheidender Bedeutung. Über die dynamische Typisierung von JavaScript hinaus ist es prototypbasiert und erbt Eigenschaften über Prototypen. Post-es6, JavaScript unterstützt OOP vollständig mit Klassen, stützt sich jedoch grundlegend auf Prototypen.

Die folgenden Code -Snippets veranschaulichen syntaktische Unterschiede in der Erstellung von Klassen und Methoden:

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

Objekterstellung in javaScript

In Java erfordert die Objekterstellung eine Klassendefinition. JavaScript bietet Flexibilität; Objekte können direkt ohne explizite Klassenerklärungen erstellt werden.

Java verlangt, dass jedes Objekt eine Instanz einer Klasse ist. JavaScript erlaubt die direkte Erstellung von Objekten:

javaScript

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

person.greet();

Erbschaftsmechanismen

Vererbungssyntax zeigt Ähnlichkeiten in beiden Sprachen.

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

Kapselung Überlegungen

JavaScripts Kapselung ist schwächer als die von Java; Es fehlen Zugriffsmodifikatoren ( privat , protected , public ). Die in ES2022 eingeführte Notation # (privates Feld) bietet jedoch einen Grad privater Feldkontrolle:

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

polymorphismus Aspekte

java unterstützt Kompilierzeitpolymorphismus (Methodenüberladung) und Laufzeitpolymorphismus (Methode Übergeordnet).

JavaScript unterstützt aufgrund seiner interpretierten Art und des Mangels an Kompilierungszeitprüfungen keine Methodenüberladung. Die Verschiebung der Methode wird jedoch unterstützt:

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

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

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