{"id":392,"date":"2024-05-15T09:52:52","date_gmt":"2024-05-15T08:52:52","guid":{"rendered":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/?p=392"},"modified":"2024-06-07T09:55:11","modified_gmt":"2024-06-07T08:55:11","slug":"optionals-in-java","status":"publish","type":"post","link":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/?p=392","title":{"rendered":"Optionals in Java"},"content":{"rendered":"\n

Einf\u00fchrung<\/h4>\n\n\n\n

In der Programmierung treten h\u00e4ufig Situationen auf, in denen eine Variable m\u00f6glicherweise keinen Wert besitzt, was in vielen Sprachen durch null<\/code> dargestellt wird. In Java kann dies zu NullPointerException<\/code> f\u00fchren, einer der h\u00e4ufigsten Fehlerquellen. Um diesem Problem entgegenzuwirken, wurde mit Java 8 die Klasse Optional<\/code> eingef\u00fchrt. Optional<\/code> ist ein Container-Objekt, das entweder einen Wert enth\u00e4lt oder leer ist. Diese Klasse bietet eine elegante M\u00f6glichkeit, mit potenziell fehlenden Werten umzugehen und den Code sicherer und lesbarer zu gestalten.<\/p>\n\n\n\n

Was ist Optional<\/code>?<\/h4>\n\n\n\n

Optional<\/code> ist eine generische Klasse, die im Paket java.util<\/code> enthalten ist. Sie dient dazu, null-basierte Fehler zu vermeiden und explizit anzugeben, dass eine Variable leer sein kann. Anstatt mit null<\/code> zu arbeiten, kann ein Optional<\/code> verwendet werden, um die M\u00f6glichkeit eines fehlenden Wertes zu signalisieren.<\/p>\n\n\n

Optional<String<\/span>> optionalString = Optional.of(\"Hello, World!\"<\/span>);\nOptional<String<\/span>> emptyOptional = Optional.empty();<\/code><\/span>Code-Sprache:<\/span> JavaScript<\/span> (<\/span>javascript<\/span>)<\/span><\/small><\/pre>\n\n\n
Erstellung von Optional<\/code>-Objekten<\/h4>\n\n\n\n
Es gibt mehrere M\u00f6glichkeiten, Optional<\/code>-Objekte zu erstellen:<\/p>\n\n\n\n
    \n
  1. Optional.of(T value)<\/code><\/strong>: Erstellt ein Optional<\/code>, das den gegebenen Wert enth\u00e4lt. Falls der Wert null<\/code> ist, wird eine NullPointerException<\/code> geworfen.<\/li>\n<\/ol>\n\n\n
       Optional<String<\/span>> optional = Optional.of(\"Hello\"<\/span>);<\/code><\/span>Code-Sprache:<\/span> JavaScript<\/span> (<\/span>javascript<\/span>)<\/span><\/small><\/pre>\n\n\n
      \n
    1. Optional.ofNullable(T value)<\/code><\/strong>: Erstellt ein Optional<\/code>, das den gegebenen Wert enth\u00e4lt, falls dieser nicht null<\/code> ist. Andernfalls wird ein leeres Optional<\/code> erstellt.<\/li>\n<\/ol>\n\n\n
         Optional<String<\/span>> optional = Optional.ofNullable(null<\/span>); \/\/ Leeres Optional<\/span><\/code><\/span>Code-Sprache:<\/span> JavaScript<\/span> (<\/span>javascript<\/span>)<\/span><\/small><\/pre>\n\n\n
        \n
      1. Optional.empty()<\/code><\/strong>: Erstellt ein leeres Optional<\/code>.<\/li>\n<\/ol>\n\n\n
           Optional<String<\/span>><\/span> emptyOptional = Optional.empty();<\/code><\/span>Code-Sprache:<\/span> HTML, XML<\/span> (<\/span>xml<\/span>)<\/span><\/small><\/pre>\n\n\n
        Abfragen und Manipulation von Optional<\/code>-Objekten<\/h4>\n\n\n\n
        Optional<\/code> bietet verschiedene Methoden, um auf den enthaltenen Wert zuzugreifen und damit zu arbeiten:<\/p>\n\n\n\n
          \n
        1. isPresent()<\/code><\/strong>: Pr\u00fcft, ob ein Wert vorhanden ist.<\/li>\n<\/ol>\n\n\n
             if<\/span> (optional.isPresent()) {\n       System.out.println(\"Wert ist vorhanden\"<\/span>);\n   }<\/code><\/span>Code-Sprache:<\/span> JavaScript<\/span> (<\/span>javascript<\/span>)<\/span><\/small><\/pre>\n\n\n
            \n
          1. ifPresent(Consumer<? super T> action)<\/code><\/strong>: F\u00fchrt die angegebene Aktion aus, wenn ein Wert vorhanden ist.<\/li>\n<\/ol>\n\n\n
               optional<\/span>.ifPresent<\/span>(value<\/span> -<\/span>> System<\/span>.out<\/span>.println<\/span>(\"Wert<\/span>: \" + value<\/span>));<\/code><\/span>Code-Sprache:<\/span> CSS<\/span> (<\/span>css<\/span>)<\/span><\/small><\/pre>\n\n\n
              \n
            1. orElse(T other)<\/code><\/strong>: Gibt den enthaltenen Wert zur\u00fcck oder einen alternativen Wert, falls kein Wert vorhanden ist.<\/li>\n<\/ol>\n\n\n
                 String<\/span> result = optional.orElse(\"Standardwert\"<\/span>);<\/code><\/span>Code-Sprache:<\/span> JavaScript<\/span> (<\/span>javascript<\/span>)<\/span><\/small><\/pre>\n\n\n
                \n
              1. orElseGet(Supplier<? extends T> other)<\/code><\/strong>: Gibt den enthaltenen Wert zur\u00fcck oder ruft einen Supplier<\/code> auf, um einen alternativen Wert zu erzeugen.<\/li>\n<\/ol>\n\n\n
                   String<\/span> result = optional.orElseGet(() -> \"Standardwert\"<\/span>);<\/code><\/span>Code-Sprache:<\/span> JavaScript<\/span> (<\/span>javascript<\/span>)<\/span><\/small><\/pre>\n\n\n
                  \n
                1. orElseThrow(Supplier<? extends X> exceptionSupplier)<\/code><\/strong>: Gibt den enthaltenen Wert zur\u00fcck oder wirft eine Ausnahme, die vom angegebenen Supplier<\/code> erzeugt wird.<\/li>\n<\/ol>\n\n\n
                     String<\/span> result = optional.orElseThrow(() -> new<\/span> RuntimeException(\"Kein Wert vorhanden\"<\/span>));<\/code><\/span>Code-Sprache:<\/span> JavaScript<\/span> (<\/span>javascript<\/span>)<\/span><\/small><\/pre>\n\n\n
                    \n
                  1. get()<\/code><\/strong>: Gibt den enthaltenen Wert zur\u00fcck, falls vorhanden, andernfalls wird eine NoSuchElementException<\/code> geworfen. Diese Methode sollte mit Vorsicht verwendet werden, da sie potenziell eine Ausnahme werfen kann.<\/li>\n<\/ol>\n\n\n
                       String<\/span> value = optional.get();<\/code><\/span>Code-Sprache:<\/span> JavaScript<\/span> (<\/span>javascript<\/span>)<\/span><\/small><\/pre>\n\n\n
                    Funktionsweise in der Praxis<\/h4>\n\n\n\n
                    Ein h\u00e4ufiges Anwendungsszenario f\u00fcr Optional<\/code> ist der Umgang mit Methoden, die m\u00f6glicherweise keinen Wert zur\u00fcckgeben. Anstatt null<\/code> zur\u00fcckzugeben, kann ein Optional<\/code> verwendet werden, um die Abwesenheit eines Wertes anzuzeigen.<\/p>\n\n\n
                    public Optional<User> findUserById(String<\/span> id) {\n    User user = userRepository.findById(id);\n    return<\/span> Optional.ofNullable(user);\n}<\/code><\/span>Code-Sprache:<\/span> JavaScript<\/span> (<\/span>javascript<\/span>)<\/span><\/small><\/pre>\n\n\n
                    In diesem Beispiel wird ein Optional<\/code> zur\u00fcckgegeben, das entweder einen User<\/code> enth\u00e4lt oder leer ist, falls kein Benutzer mit der gegebenen ID gefunden wurde.<\/p>\n\n\n\n
                    Vorteile der Verwendung von Optional<\/code><\/h4>\n\n\n\n
                      \n
                    1. Vermeidung von NullPointerException<\/code><\/strong>: Durch den expliziten Umgang mit fehlenden Werten k\u00f6nnen NullPointerException<\/code> vermieden werden.<\/li>\n\n\n\n
                    2. Bessere Lesbarkeit und Wartbarkeit<\/strong>: Der Code wird klarer und expliziter, da sofort ersichtlich ist, dass ein Wert m\u00f6glicherweise fehlen kann.<\/li>\n\n\n\n
                    3. F\u00f6rderung von Best Practices<\/strong>: Die Verwendung von Optional<\/code> f\u00f6rdert den bewussten Umgang mit fehlenden Werten und zwingt den Entwickler, diese F\u00e4lle explizit zu behandeln.<\/li>\n<\/ol>\n\n\n\n
                      Kritik und Missbrauch von Optional<\/code><\/h4>\n\n\n\n
                      Trotz der Vorteile gibt es auch einige Kritikpunkte und Missbrauchsm\u00f6glichkeiten:<\/p>\n\n\n\n
                        \n
                      1. Nicht f\u00fcr Attribute geeignet<\/strong>: Optional<\/code> sollte nicht f\u00fcr Felder von Klassen verwendet werden. Es ist in erster Linie f\u00fcr R\u00fcckgabewerte von Methoden gedacht. Das Speichern von Optional<\/code>-Objekten in Klassenattributen kann unn\u00f6tig Speicher und Overhead erzeugen.<\/li>\n<\/ol>\n\n\n
                           \/\/ Schlechte Praxis<\/span>\n   public<\/span> class<\/span> User<\/span> <\/span>{\n       private<\/span> Optional<String> name;\n   }<\/code><\/span>Code-Sprache:<\/span> PHP<\/span> (<\/span>php<\/span>)<\/span><\/small><\/pre>\n\n\n
                          \n
                        1. Nicht f\u00fcr alle Situationen geeignet<\/strong>: Optional<\/code> sollte nicht \u00fcberall eingesetzt werden, wo null<\/code> vorkommen k\u00f6nnte. In vielen F\u00e4llen kann eine einfache null<\/code>-\u00dcberpr\u00fcfung ausreichend und effizienter sein.<\/li>\n\n\n\n
                        2. Overhead und Leistung<\/strong>: Die Verwendung von Optional<\/code> kann zus\u00e4tzlichen Overhead und eine geringf\u00fcgige Leistungseinbu\u00dfe bedeuten, insbesondere in performancekritischen Anwendungen.<\/li>\n<\/ol>\n\n\n\n
                          Fazit<\/h4>\n\n\n\n
                          Optional<\/code> ist ein m\u00e4chtiges Werkzeug in Java, das dazu beitr\u00e4gt, den Umgang mit potenziell fehlenden Werten sicherer und expliziter zu gestalten. Es f\u00f6rdert die best practices, indem es Entwickler dazu zwingt, F\u00e4lle fehlender Werte explizit zu behandeln. Allerdings sollte Optional<\/code> mit Bedacht eingesetzt werden, insbesondere nicht als Klassenattribute oder in performancekritischen Anwendungen. Richtig verwendet, tr\u00e4gt Optional<\/code> erheblich zur Verbesserung der Codequalit\u00e4t bei und reduziert die Wahrscheinlichkeit von NullPointerException<\/code>.<\/p>\n\n\n\n
                          Insgesamt ist die Einf\u00fchrung von Optional<\/code> ein bedeutender Schritt in Richtung sicherer und sauberer Java-Code, der die Best Practices des defensiven Programmierens unterst\u00fctzt und die Lesbarkeit sowie Wartbarkeit von Code verbessert.<\/p>\n","protected":false},"excerpt":{"rendered":"
                          Einf\u00fchrung In der Programmierung treten h\u00e4ufig Situationen auf, in denen eine Variable m\u00f6glicherweise keinen Wert besitzt, was in vielen Sprachen durch null dargestellt wird. In Java kann dies zu NullPointerException f\u00fchren, einer der h\u00e4ufigsten Fehlerquellen. Um diesem Problem entgegenzuwirken, wurde mit Java 8 die Klasse Optional eingef\u00fchrt. Optional ist ein Container-Objekt, das entweder einen Wert […]<\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[4],"tags":[],"class_list":["post-392","post","type-post","status-publish","format-standard","hentry","category-plain_java"],"_links":{"self":[{"href":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/index.php?rest_route=\/wp\/v2\/posts\/392","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/index.php?rest_route=\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/index.php?rest_route=\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/index.php?rest_route=\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/index.php?rest_route=%2Fwp%2Fv2%2Fcomments&post=392"}],"version-history":[{"count":1,"href":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/index.php?rest_route=\/wp\/v2\/posts\/392\/revisions"}],"predecessor-version":[{"id":393,"href":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/index.php?rest_route=\/wp\/v2\/posts\/392\/revisions\/393"}],"wp:attachment":[{"href":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/index.php?rest_route=%2Fwp%2Fv2%2Fmedia&parent=392"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/index.php?rest_route=%2Fwp%2Fv2%2Fcategories&post=392"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/index.php?rest_route=%2Fwp%2Fv2%2Ftags&post=392"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}