What is a Null Pointer Exception and how to fix it?

In java8, the Optional class was added to prevent NullPointerException, although it is not always possible to use it correctly. Here is a link with recommendations on how to use Optional

A typical solution with a check on null

Article article = getFirstJavaArticle();

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

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

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

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

The NullObject {[26 pattern is also used to preventNullPointerException]}

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;
   }
}

Implementation NullObject

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 class NullCustomer and do not fall from NullPointerException. But as it seems to me there is a small Overhead: you need to create an inheritance hierarchy.

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

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

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

3. When a null is thrown to you, it usually specifies a "row hierarchy"(which, as called, is what led you to null). And there you can see where your object is not initialized, there and you can immediately fix the error.

4. It can occur in arrays/lists when you call an object with the number n, despite the fact that the object is not previously written there. Like, everything))

I recommend using 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;
  }
}

The 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't find the machine, it won't throw out the NPE. Optional helps to avoid checks on null and to shorten the code and improve its readability.