What is Null Pointer Exception and How To Fix It?

The Optional class has been added to java8 to prevent a NullPointerException , although it is not always possible to use it for its intended purpose. Here is a link with recommendations on how to use Optional

Typical solution with a null check

 Article article = getFirstJavaArticle(); if (article == null) { article = fetchLatestArticle(); } 

And now the solution using Optional<T> . Imagine that getFirstJavaArticle() returns an Optional<Article>

 getFirstJavaArticle() .orElseGet(this::fetchLatestArticle); 

The solution with Optional allows us to avoid code with checks for null and work in a functional style. It is worth noting that Optional is not a panacea for all ills

The pattern NullObject is also used to prevent NullPointerException .

Abstract Entity class

 public abstract class AbstractCustomer { protected String name; public abstract String getName(); } 

Real implementation

 public class RealCustomer extends AbstractCustomer { public RealCustomer(String name) { this.name = name; } @Override public String getName() { return name; } } 

NullObject implementation

 public class NullCustomer extends AbstractCustomer { @Override public String getName() { return "Not Available in Customer Database"; } } 

Usage (as an example)

 public class CustomerFactory { public static final String[] names = {"Rob", "Joe", "Julie"}; public static AbstractCustomer getCustomer(String name){ for (int i = 0; i < names.length; i++) { if (names[i].equalsIgnoreCase(name)){ return new RealCustomer(name); } } return new NullCustomer(); } } 

Instead of returning null we return an instance of the NullCustomer class and do not fall from a NullPointerException . But I think there is a small Overhead: it is necessary to create a hierarchy of inheritance.

This is an Exception that occurs when you refer to an object that is = null (not initialized) or you try to call methods / access variables of an object that is = null. The solution to this problem is:

1. Check for null, if(Твой объект==null){//Your code}

2. try{}catch(NullPointerException e){//Your code}

3. When you throw a null, it usually indicates a "hierarchy of lines" (which is what was called, which led you to null). And there you can see where your object is not initialized, and there you can immediately correct the error.

4. It may occur in arrays / lists when you call object number n, despite the fact that the object is not previously recorded there. Look like that's it))

I advise you to use Optional to prevent NPE. This class was introduced in java 8.

For example

  @Entity public class Car { @Id @GeneratedValue private Long id; @Column(name = "name") @NotNull private String name; } 

Repository:

 public interface CarRepository extends JpaRepository<Car, Long> { Optional<Car> findById(Long id); } 

Service:

 @Service public class CarService { private CarRepository carRepository; @Autowired public CarService(CarRepository carRepository) { this.carRepository = carRepository; } public Car findById(Long id) { Car car = carRepository.findById(id).orElseThrow(() -> new RuntimeException("Requested entity was not found")); car.getHolder().setPassword(null); return car; } } 

Controller:

 @RestController @RequestMapping("/api") public class CarController { private CarService carService; @Autowired public CarController(CarService carService) { this.carService = carService; } @RequestMapping(value = "/cars/{id}", method = RequestMethod.GET) public ResponseEntity<Car> getCar(@PathVariable Long id) { try { Car carToFind = carService.findById(id); return ResponseEntity.status(HttpStatus.OK).body(carToFind); } catch (Exception ex) { return ResponseEntity.status(HttpStatus.BAD_REQUEST).build(); } } } 

In this case, if the repository can not find the car, it will not throw NPE. Optional helps to avoid checks for null and reduce the code and improve its readability.