Why the parent class will call the subclass method in java?

I have two classes:

public class A {
	void add(int a){
		System.out.println("A.add");
	}

	void addAll(int[] a){
		System.out.println("A.addAll");
		for(int i = 0;i < a.length;i++){
			add(a[i]);
		}
	}
}

public class B extends A{
	@Override
	void add(int a){
		System.out.println("B.add");
		super.add(a);
	}
	
	@Override
	void addAll(int[] a){
		System.out.println("B.add");
		super.addAll(a);
	}
	
	
	public static void main(String[] args){
		(new B()).addAll(new int[]{1,2,3,4});
	}
}

And when I start to run this application, the output is

B.add
A.addAll
B.add
A.add
B.add
A.add
B.add
A.add
B.add
A.add

Why the addAll function in class A will call the add function in class B rather than call its own add function?

I think Derek has misunderstood your meant. Super indeed refers to the parent class (A), but you can see there's a @override keyword before B's add function. Since it is a B object calls addAll function (new B()), the A's add is override by B's add function. Therefore it calls B's add function first, then A's add function.

Because that's how polymorphism works. Any non-private/static/final method can be overrided, no matter you call it from outside of the class or inside.

In class A,you call a non-private method add() in addAll(). If you override add() method in subClass B, the addAll() in A will call the B's add() method.This is quite obvious.

In fact I think what confuse you is why it work like that.
In java, if you declare a method as non-private and non-final, you are telling that any subclass can change it's behavior, that's what override means. If you don't want subclass to change it's behavior, you can either declare it as private or final or make you class final.

This is dynamic method dispatch. The calling reference is of "B" which has overridden both add() and addAll() of "A". Now, when B's reference invokes addAll(), B's version is called. Nothing not obvious here. Now B's version of addAll has super.addAll(), which also think is intuitive.
What's interesting is that when the body of A's addAll() is invoked, it has invocation to "add()". Here, since the runtime reference using which the entire call chain was started is of B and B has overridden "add()" of A as well, thus B's version of "add()" is invoked from within the "addAll()" body of A.
Dynamic method dispatch and runtime polymorphism dictates this behaviour where all methods that are dispatched in an invocation depends on the actual reference that the invoking variable has.