BtechOnline.Org

 this vs super

• this can be used to read all members declared within the class
• this can all be used to read all inherited members in the direct parent class
• this can be used in an instance method, constructor and instance block
• this cannot be used in a static method or static initializer block
• super can read only inherited members declared in the parent class
• super excludes any members found in the current class
• super always refer to the direct parent
• this() can be used to invoke current class constructor
• super() invokes constructor of the parent class
• if we choose to call this() or super() , it must be the first statement in the constructor body. There can be only one call.
• this refers to an instance of the class, while this() refers to a constructor call within the class
• Java compiler automatically inserts a call to the no-argument constructor super() if we do not explicitly call this() or super() as the first line of a constructor.
• static methods do not have reference to this or super

Constructor

• A special method that matches the name of the class and has no return type
• Constructors are executed when a new instance of the class is created (new Main()). This process is called instantiation, because it creates a new instance of the class.
• The method name and the class name should be exactly same (note that Java is case sensitive)

• Constructors can include parameters, like arrays, primitive types or generics. But cannot include var. The below constructor will not compile.

    class Main {
      public Main( var number ) {
  
      }
    }
  

• There can be multiple constructors in a class, provided that the constructor parameters are distinct.
• Declaring multiple constructors with different signatures is reffered to as constructor overloading.
• Every class in Java will have a constructor. If you didn't code it Java will include the default no-argument constructor automatically during compilation process.

• Private Constructor is a special constructor which is declared as private. Having private constructors prevents other classes from the class. It is generally used when the class has only static methods.

    class Main {
      private Main() {
  
      }
    }
  

• Classes with a private constructor can be extended only by an inner class, because an inner class is the only one that can access a private constructor by calling super().

Comparable Interface

is used to sort the objects of a user defined class. It contains only one method: compareTo()

public interface Comparable<T>{
  int compareTo(T o);
}

We can implement the logic of the sorting into the compareTo() method (an example is given below). compareTo() method must returns an integer based on the following rules:

• 0 is returned when current object is equal to the argument object
• -1 is returned when current object is smaller than the argument object
• 1 is returned when current object is greater than the argument object

class Employee implements Comparable<Employee> {
    private String empCode;
    private String name;
    private int age;
    //not including getters, setters, constructor etc
    @Override
    public String toString() {
        return "Emp{" + name + "," + age + "," + empCode + "}";
    }

    @Override
    public int compareTo(Employee o) {
        int result = this.name.compareTo(o.getName());
        if (result != 0) return result;
        return this.getAge() - o.getAge();
    }
}

public class Main {
    public static void main(String[] args) {
        List<Employee> employees = new ArrayList<>();
        employees.add(new Employee("402", "anu", 35));
        employees.add(new Employee("399", "binoy", 32));
        employees.add(new Employee("400", "anu", 31));
        //printing before sort
        System.out.println(employees); //outputs [Emp{anu,35,402}, Emp{binoy,32,399}, Emp{anu,31,400}]
        Collections.sort(employees);
        //printing after sort
        System.out.println(employees); //outputs [Emp{anu,31,400}, Emp{anu,35,402}, Emp{binoy,32,399}]
    }
}

Comparator Interface

Comparator is also an interface which is used to sort the objects of a user defined class. It contains compare() method. Using Comparable interface we can implement only one sorting logic. What if we need to implement sorting logic based on other data members also. At that time Comparator becomes handy. In the above example, of Comparable interface, if we need to sort the employees based on their employee code (empCode). Then we can implement it by modifying the main code as shown below:

//sorting based on empCode
Comparator<Employee> comparatorByEmpCode = (e1, e2) -> e1.getEmpCode().compareTo(e2.getEmpCode());
Collections.sort(employees, comparatorByEmpCode);
System.out.println(employees); //outputs [Emp{binoy,32,399}, Emp{anu,31,400}, Emp{anu,35,402}]

We can also combine the comparators to get a particular sorting sequence. For example say we need to display the employee based on their name. But when name is same then the employee with smallest age will be listed first. Find the example below:-

Comparator<Employee> comparatorByName = Comparator.comparing(Employee::getName);
Comparator<Employee> comparatorByAge = Comparator.comparing(Employee::getAge);
Comparator<Employee> comparatorCombined = comparatorByName.thenComparing(comparatorByAge);
Collections.sort(employees, comparatorCombined);
System.out.println(employees);

Comparable vs Comparator

As seen above both are used for sorting purposes. The differences between them are as follows:

• Comparable provides only a single sorting logic whereas with the help of Comparator we can implement multiple sorting logic.
• Comparable has compareTo() method with a single parameter. Comparator has compare() method with two parameters
• Comparable is present in java.lang package while Comparator is present in java.util package
• To implement sorting using Comparable we need to modify the class, but in the case of Comparator we do not need to modify the class.
• If a class implements Comparable interface then collection of that object can be sorted using Collections.sort() or Arrays.sort() method. They will be sorted based on the logic defined by compareTo() method.