So verwenden Sie Pattern Matching für Typumwandlung und -extraktion in Java 14

So verwenden Sie Pattern Matching für die Typumwandlung und -extraktion in Java 14

Eine sehr leistungsstarke Funktion wird in Java 14 eingeführt – Pattern Matching. Diese Funktion macht die Typbeurteilung präziser und bequemer, insbesondere bei der Durchführung von Umwandlungen und Typextraktionen. In diesem Artikel wird die Verwendung von Pattern Matching zur Typumwandlung und -extraktion in Java 14 vorgestellt und anhand von Codebeispielen veranschaulicht.

In früheren Java-Versionen mussten wir normalerweise zwei Schritte durchlaufen, um Typumwandlung und -extraktion durchzuführen. Zuerst müssen wir den Typ des Objekts mithilfe des Schlüsselworts „instanceof“ überprüfen und es dann mithilfe von „cast“ in den Zieltyp konvertieren. Dieser Ansatz ist sehr mühsam und fehleranfällig, insbesondere wenn es um komplexe Objektbeziehungen geht.

Pattern Matching in Java 14 vereinfacht den Prozess der Typbestimmung durch die Einführung neuer Instanzen der Syntax und des Mustervergleichs in Switch-Anweisungen. Schauen wir uns einige Beispiele an, um zu verstehen, wie man sie verwendet.

Betrachten wir zunächst ein einfaches Beispiel. Angenommen, wir haben eine abstrakte Klasse Shape, die eine Methode namens Fläche enthält, und wir müssen die Fläche basierend auf verschiedenen Formen berechnen. Wir können mehrere spezifische Formklassen definieren, z. B. Kreis, Rechteck und Dreieck.

abstract class Shape {
    abstract double area();
}

class Circle extends Shape {
    double radius;

    Circle(double radius) {
        this.radius = radius;
    }

    double area() {
        return Math.PI * radius * radius;
    }
}

class Rectangle extends Shape {
    double width;
    double height;

    Rectangle(double width, double height) {
        this.width = width;
        this.height = height;
    }

    double area() {
        return width * height;
    }
}

class Triangle extends Shape {
    double base;
    double height;

    Triangle(double base, double height) {
        this.base = base;
        this.height = height;
    }

    double area() {
        return 0.5 * base * height;
    }
}

In früheren Java-Versionen mussten wir häufig „instanceof“ verwenden, um den spezifischen Formtyp zu überprüfen und eine Konvertierung des Umwandlungstyps durchzuführen:

Shape shape = ...; // 初始化一个形状对象

if (shape instanceof Circle) {
    Circle circle = (Circle) shape; // 强制类型转换
    double area = circle.area();
    // 其他处理...
} else if (shape instanceof Rectangle) {
    Rectangle rectangle = (Rectangle) shape;
    double area = rectangle.area();
    // 其他处理...
} else if (shape instanceof Triangle) {
    Triangle triangle = (Triangle) shape;
    double area = triangle.area();
    // 其他处理...
}

In Java 14 können wir die neue „Instanceof“-Syntax für präziseres Codeschreiben verwenden:

Shape shape = ...; // 初始化一个形状对象

if (shape instanceof Circle circle) {
    double area = circle.area();
    // 其他处理...
} else if (shape instanceof Rectangle rectangle) {
    double area = rectangle.area();
    // 其他处理...
} else if (shape instanceof Triangle triangle) {
    double area = triangle.area();
    // 其他处理...
}

In Mit dieser neuen Syntax haben wir den Cast-Code auf die rechte Seite von „instanceof“ verschoben und können die lokalen Variablen „Kreis“, „Rechteck“ und „Dreieck“ direkt im nachfolgenden Code verwenden. Dies hat den Vorteil, dass wir diese lokalen Variablen nicht explizit deklarieren müssen, was die Einfachheit und Lesbarkeit des Codes verbessert.

Neben der Typbeurteilung in bedingten Anweisungen kann Pattern Matching auch in switch-Anweisungen verwendet werden. In früheren Java-Versionen konnten wir im Fall der switch-Anweisung nur Konstanten zum Abgleich verwenden. In Java 14 können wir Typmuster zum Abgleich verwenden. Schauen wir uns ein Beispiel an:

Shape shape = ...; // 初始化一个形状对象

switch (shape) {
    case Circle circle -> {
        double area = circle.area();
        // 其他处理...
    }
    case Rectangle rectangle -> {
        double area = rectangle.area();
        // 其他处理...
    }
    case Triangle triangle -> {
        double area = triangle.area();
        // 其他处理...
    }
}

In dieser neuen Switch-Anweisung können wir je nach Formtyp zuordnen und die lokalen Variablen Kreis, Rechteck und Dreieck direkt im nachfolgenden Code verwenden. Auf diese Weise müssen wir keine wiederholte Typprüfung und erzwungene Typkonvertierung durchführen, was das Schreiben und Warten von Code erheblich vereinfacht.

Zusammenfassend lässt sich sagen, dass die Verwendung von Pattern Matching für die Typumwandlung und -extraktion in Java 14 unseren Code erheblich vereinfachen und die Lesbarkeit und Wartbarkeit des Codes verbessern kann. Durch die Einführung der neuen Instanz von Syntax und Mustervergleich in Switch-Anweisungen können wir redundanten Code eliminieren und Typkonvertierungsfehler vermeiden.

Es ist jedoch wichtig zu beachten, dass Pattern Matching nur in Java 14 und höher verwendet werden kann. In älteren Java-Versionen müssen wir immer noch traditionelle Methoden zur Typbestimmung und -erzwingung verwenden. Daher ist es bei der Verwendung von Pattern Matching wichtig, sicherzustellen, dass Ihr Code auf der richtigen Java-Version ausgeführt wird.

Ich hoffe, dieser Artikel hilft Ihnen, Pattern Matching in Java 14 zu verstehen und zu verwenden. Das Schreiben von klarem und prägnantem Code ist das Ziel eines jeden Programmierers, und Pattern Matching ist für die Java-Sprache ein großer Schritt auf dem Weg zu diesem Ziel.

Das obige ist der detaillierte Inhalt vonSo verwenden Sie Pattern Matching für Typumwandlung und -extraktion in Java 14. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!