optional notwendig?

[frager2345]

Hi, also ich hab hier mal eine Frage:

public abstract class Immobilie {
        private int preis;
        private static double provision = 3.45;
        private Optional<Makler> makler;
        private Eigentuemer eigentuemer;
        protected Immobilie(int preis, Eigentuemer e) {
                setPreis(preis);
                linkEigentuemer(e);
}
        public void setPreis(int preis) {
                if(!checkPreis(preis)) {
throw new IllegalArgumentException("Der Preis muss gr ̈oßer als 10000 und durch 1000 teilbar sein.");
                }
                this.preis = preis;
        }
        public int getPreis() {
                return preis;
        }
        private static boolean checkPreis(int preis) {
                return (preis >= 10000) && (preis % 1000 == 0);
        }
        public static double getProvision() {
                return provision;
        }
        public abstract double getPreisProQm();
7
         public void linkMakler(Makler m) {
                this.makler = Optional.of(m);
        }
        public Optional<Makler> getlinkMakler() {
                return makler;
        }
        public void unlinkMakler() {
                this.makler = Optional.empty();
        }
        public void linkEigentuemer(Eigentuemer e) {
                this.eigentuemer = e;
        }
        public Eigentuemer getlinkEigentuemer() {
                return eigentuemer;
} }

Explizit z.B hier:

  public void unlinkMakler() {
                this.makler = Optional.empty();
        }

->Warum genau benutzt man hier Optional.empty() ? Diese setzt doch eine leere Instanz des Objektes an der Stelle, würde dann doch auch reichen this.makler = null, oder?
Gleiche Frage hier:

public void linkMakler(Makler m) {
                this.makler = Optional.of(m);
        }

 

[DrPils]

Genau dafür hast du Optional. Mit Optional wirst du dann praktisch gezwungen das nicht existieren eines Objektes zu behandeln. Während du null ignorieren kannst und es dir dann oft zur Laufzeit um die Ohren fliegt

 

[frager2345]

Genau dafür hast du Optional. Mit Optional wirst du dann praktisch gezwungen das nicht existieren eines Objektes zu behandeln. Während du null ignorieren kannst und es dir dann oft zur Laufzeit um die Ohren fliegt

Ahh ok, danke dir!

 

[Robert Zenz]

Optional ist eigentlich nicht so sehr fuer Felder gedacht, als fuer Rueckgabewerte.

Du gewinnst unmittelbar nichts durch den Austausch gegen ein Optional, wo es hilft ist die Deutlichkeit dass man von dieser Funktion ein null zurueck bekommen kann:

Reference reference = someObject.getReference();

// Gegenueber

Optional<Reference> reference = someObject.getReference();

Wo es dir aber so richtig gar nichts hilft ist wenn du dir ohnehin bewusst bist das es keinen Wert geben kann, wo dies auch ein legitimer Zustand ist, und du diesen Fall ohnehin abfragen musst:

public class Logic {
    private Reference reference = null;
    
    public void doSomething() {
        if (reference != null) {
            // do something
        } else {
            // do something different
        }
    }
}

// Gegenueber

public class Logic {
    private Optional<Reference> reference = null;
    
    public void doSomething() {
        if (reference.hasValue()) {
            // do something
        } else {
            // do something different
        }
    }
}

 

[frager2345]

Wo es dir aber so richtig gar nichts hilft ist wenn du dir ohnehin bewusst bist das es keinen Wert geben kann, wo dies auch ein legitimer Zustand ist, und du diesen Fall ohnehin abfragen musst:

Ja genau , deswegen war ich verwirrt, dass man bei so "klarem" Rückgabewert schon optional verwendet. Kommt ja aufs gleiche raus..
Danke für die anschaulichen Beispiele !
Gruß