While working on a project, I came across the following code segment which appears to provide code, entirely contained inside a new variable declaration, which appears to override a method. I've, come across code of this form before but admittedly, I do not fully understand it. If anyone could explain the programming mechanisms upon which this code is based, I'd be very truly grateful. Particularly, when are overridden methods of this sort permitted inside of variable declarations. What other sorts of data structures allow such behavior? When is it advantageous to write code of such nature? Why not override the method outside of a variable declaration?
tempRequests.sort(new Comparator<Integer>()
{
@Override
public int compare(Integer integer1, Integer integer2)
{
return integer1.compareTo(integer2);
}
});
What other sorts of data structures allow such behavior?
-> You can sort objects by implements interface Comparable. For example:
public class Car implements Comparable<Car> {
private String name;
@Override
public int compareTo(Car b) {
return name.compareTo(b.name);
}
}
->You can also use Comparator without override method compare inside the inner class.
public class Car implements Comparator<Car> {
private String name;
private double price;
@Override
public int compare(Car b1, Car b2) {
return b1.price - b2.price;
}
}
When is it advantageous to write code of such nature? Why not override the method outside of a variable declaration?
-> Image that after use sort object Car by name, you want to sort by something else (like by price, by weight).How to do this when you want to sort objects in different ways at different times? We use Comparator with define inside the inner class to do this.
*Additionally, Comparator is a functional interface since an only abstract method to implement. You can rewrite using a funky syntax in one line of code: Ex:
Compareator<Car> byPrice = (b1,b2) -> b1.price - b2.price;