While PO reading Java 8 Optional he has few question in mind and can not understand why Optional added in Java, How it saves us from the almighty villain null pointer Exception. So he goes to master Shifu, But the Irony is Shifu does not sure about How it will save Java users from the null pointer, but it is oogways foretold so they go to Oogways for advice on Optional.
I was there when the conversation happened, I will try to depict the conversation.
PO : Master oogways, I am really confused why Optional added in Java, I can’t see any benefits , and I am bit skeptical how it saves from Nullpointer exception as it is nothing but a Container/Wrapper Object which held a reference to another Object, So the reference can be null and itself Optional wrapper class can be null, so I am confused what is the use case.
Oogway: From the birth of java the greatest sin is, The invention of null, Java tries to represent something absent as a null, but absent does not mean null it means not present. Java is a strong type language but null is such a value which can be assigned to any type, so it acts as a loose type variable, act as default value of reference, It is not blessing but a curse,
Every time we don’t know what would be the returned Object, developers returns a null, and caller, unfortunately, bears the load of the null check for return value unless null pointer exception blows up the flow.
Let see a small example,

package com.example.optional;

import java.util.ArrayList;
import java.util.List;

public class OptionalTest {
private static List<String> nameList = new ArrayList<String>();
static{
nameList.add(“Shamik”);
nameList.add(“Samir”);
nameList.add(“Swastika”);
}

public String findName(String nameToFind){
return nameList.contains(nameToFind)?nameList.get(nameList.indexOf(nameToFind)):null;
}

public static void main(String[] args) {
OptionalTest test = new OptionalTest();
String searchedName = test.findName(“Mayukh”);
System.out.println(” Hi , ” + searchedName.toUpperCase());
}
}
Here, The API developer exposes a method called findName, and silently return a null if the name is not found.  The caller of the API trust the API developer and called the method with an arbitrary name and try to print it in Uppercase. But it blows the caller’s code with null pointer exception.
Whose fault is it Callers or API developer?

API Developers Perspective: When caller gives a name and that name is not found in nameList what should I do? return a blank string or return a String “NA” but if the caller says that they don’t want “NA” or blank String, or One caller OK with the blank or “NA” String  and Other wants to handle the scenario by itself, so  as a developer when I am not sure what to return I always returns null. Yes, I am a good developer I can handle all the boundary cases.
Callers Perspective: findName is an API method I only command it to give me a search result “Tell Don’t Ask”, It is API method responsibility to handle boundary cases or cases if the searchable name is not found, It should give me a dummy implementation if the searchable name not found, like “NA”. So I do not bother to check the return value, It is not my responsibility, so he skips the null check and programs blown up.

Really who’s fault it is API developer or Caller?
Caller and Developer are right in their perspective, the confusion grows because API developer can’t signal the caller, The return value may be present or absent. Null means no reference !!! (But How caller will  Understand current retuned reference not point to any Object instance?), so always it is caller responsibility to do a null check even if the value is present. null is not so expressive, to indicate caller a value is present or absent as it can be easily assigned to return value silently. So Optional step in here it tries to say value may be present or may be absent so caller it is your duty to check value is present or absent whereas null returns silently without informing the nature of the value.
Optional is acting as a Container, It holds the reference and provides some method to test the reference inside is present or absent.
Let see How we can return Optional with above example.

package com.example.optional;

import java.util.ArrayList;
import java.util.List;
import java.util.Optional;

public class OptionalTest {
private static List<String> nameList = new ArrayList<String>();
static{
nameList.add(“Shamik”);
nameList.add(“Samir”);
nameList.add(“Swastika”);
}

public Optional<String> findName(String nameToFind){
return nameList.contains(nameToFind)?Optional.of(nameList.get(nameList.indexOf(nameToFind))):Optional.empty();
}

public static void main(String[] args) {
OptionalTest test = new OptionalTest();
Optional<String> searchedName = test.findName(“Mayukh”);
if(searchedName.isPresent()){
System.out.println(“HI,”+ searchedName.get());
}else{
System.out.println(“Name not found”);
}
}

}
Here, I use Optional.of() method which creates a new Optional object with the value passed in the ‘of’ method as a parameter, and if the value is not found in nameList I return and Empty optional which does not contain anything, don’t say it contains a null, Empty represents the Value is absent, In this way we say to the caller, my method may gives you a result which does not contain anything so prepare for it.
PO : Master Oogways I understood your point but still I have  confusions, here caller has to check if(Optional.ispresent()) to get a value which is present but if caller forget to do this check, It gives you a NoSuchElement Exception, So what is the value to use optional — seems it changed the null pointer exception to NoSuchElement Exception, nothing else, I don’t see a point here to use Optional, It can’t shield us from Null Pointer Exception.
Oogway: Ha Ha, That’s why I choose you as a Dragon Warrior, You are so intelligent and to the point, You learned new things very quickly. Let me share you some thoughts,
Null is Omnipresent no one can never ever remove or defeat it completely, What we can do is protect ourselves from null, educate our Java villagers from the rage of nulls.
Optional is like a warning bell in the city, rather than nulls come silently, By Optional API developers always warned  Java Villagers/ or callers, Null can be entering your village at any point of time.
So my point is, till now only efficient villagers or callers understand when to use, not null check to escape from Null pointers rage but still in a complex call or lots of chained calls they fall in the null pointers trap. Optional tries to fix that it gives remind about absent values. Absent values can come so  protect your call from that or rather always use Optional.ispresent() check with Optional.get.
Optional does not remove the null pointer exception it warns caller to handle the absent scenarios.
It is not a Technical improvement rather it is a Conceptual improvement added into Java8 which educate java programmers to handle a scenario where value can be present or absent.

PO: I realize this Master Now tell me the Best practices of Optional.
Oogway: I am too late for today, Please come Tomorrow I will discuss best practices.

Conclusion: Oogway taught us a valuable lesson Optional is not a replacement for the null check rather it tries to say caller about the nature of the returns value and implicitly reminds caller to handle the absent cases. If Caller forgets to do that it will end up with the NoSuchElementException, which is a clear evidence you are trying to do an operation where the element/value is not present. It is a big conceptual improvement, it encourages caller to handle absent cases, unlike null return value where the caller has a confusion API developer already tackle the null value or I have to do this?

Source link

Java8: Oogways Advice on Optional

Leave a Reply

Your email address will not be published. Required fields are marked *