Java中的构造函数中的super（Myclass.class）是什么意思？

Question

I am seeing the following kind of code repeatedly in Mapreduce programs. This is just a snippet of code taken out. The entire code is available here

what does the super call in the constructor do? Does it call the constructor of IntPair.class ? why is such a call necessary.

public static class KeyComparator extends WritableComparator {
        protected KeyComparator() {
          super(IntPair.class, true);
        }
        @Override
        public int compare(WritableComparable w1, WritableComparable w2) {
          IntPair ip1 = (IntPair) w1;
          IntPair ip2 = (IntPair) w2;
          int cmp = IntPair.compare(ip1.getFirst(), ip2.getFirst());
          if (cmp != 0) {
            return cmp;
          }
          return -IntPair.compare(ip1.getSecond(), ip2.getSecond()); //reverse
        }
      }

Answer 1

super(), when used in the constructor will call the constructor of the class which is extended. In this case, it will call the WriteableComparator constructor. You can see more details on super in the java documentation here: Java super link

In particular, see the section titled "Subclass Constructors".

Answer 2

Does it call the constructor of IntPair.class?

No, It's just a argument that is passed in the super class constructor.

why is such a call necessary?

To avoid the call of no arguments constructor of the super class that is by default added by the compiler.

If there are multiple constructors in the super class then you can be specified which constructor of the super class should be called based on arguments.

---

Sample code: (Look at the output when KeyComparator object is created)

class WritableComparator {
    public WritableComparator(){
        System.out.println("default constructor is called");
    }
    public WritableComparator(Class<?> clazz, boolean flag) {
        System.out.println("two arguemnts constructor is called");
    }
}

class KeyComparator extends WritableComparator {
    public KeyComparator() {
        //super(); // by default added by the compiler
        super(IntPair.class, true);
    }
}

Answer 3

IntPair.class notation is used to get object describing this class. Like here:

Class<?> type = Integer.class;

This type variable is not an instance of Integer class, but instance of object describing Integer type.

Some classes requires you to pass them type of objects you want them to work with. Then, they can for example create new instances of those classes, using this type object.

more about Class class