Instead of (x, y), it would be better to go OO and define a class named Point with inner x and y. When there are many variables they should clearly be grouped in a class. However, it's not clear for only two variables. But for your specific case, you should absolutely group them in one class because you will then be able to re-use your tree class for any classes (make your tree generic).

You should define your tree class as: KDTree<T> (the type T does not extend anything). You can than use your tree as a KDTree<Point> or KDTree<WhateverClass>. As specified by rolfl, Node should be some inner class of KDTree<T> and should not be visible from outside. So, to summarize:

public class KDTree<T> {
   private Node<T> leftChild;
   private Node<T> rightChild;
   ...

   private static class Node<S> {
      private S value;
      private Node next;
      ...
   }
}

rolfl's comment about "equality" of floating point values is also important to consider. You could maybe define a method point1.nearlyEquals(point2) in class Point.

Instead of using x and y, it would be better to go OO and define a class named Point with inner x and y. When there are many variables they should clearly be grouped in a class. However, it's not clear for only two variables. But for your specific case, you should absolutely group them in one class because you will then be able to re-use your tree class for any classes (make your tree generic).

You should define your tree class as: KDTree<T> (the type T does not extend anything). You can than use your tree as a KDTree<Point> or KDTree<WhateverClass>. As specified by rolfl, Node should be some inner class of KDTree<T> and should not be visible from outside. So, to summarize:

public class KDTree<T> {
   private Node<T> leftChild;
   private Node<T> rightChild;
   ...

   private static class Node<S> {
      private S value;
      private Node next;
      ...
   }
}

rolfl's comment about "equality" of floating point values is also important to consider. You could maybe define a method point1.nearlyEquals(point2) in class Point. Or maybe simply override the equals method.

Choosing between those two options is not trivial (nearlyEquals vs overriding equals). I discuss both choices below, but the discussion is somewhat advanced and convoluted.

If you create a method nearlyEquals, then your class KDTree would call that specific method when calling contains. That means you could not make KDTree generics (KDTree<T>) since it could only be used with nodes of type Point.

If instead you override the equals method in Point, you could keep KDTree<T> generic since contains would just call Object.equals for all types. The downside is that Point becomes a bit weird if equals is fuzzy. You might be aware that you should always override equals and hashCode as a consistent pair. However, I don't think you can redefine the hashCode in a consistent manner with a fuzzy equals. If those are not consistent, you could never use the class Point in a HashMap, for example.

There are many options to solve this dilemma. The simplest is to actually not make a generic KDTree<T>, but just define a KDTree where the child nodes are always of type Points. And since you don't have a generic KDTree anymore, there is no pressing need to group x and y in a Point class.

So we are back to your original solution!

A different solution would be to stick to strict equality for x and y (use the default equals in class Point). But as rolfl mentioned, you can have two points which should be the same, but end up being very slightly different because of rounding error. It is for you to consider how important that might be in your application.

Sorry for my convoluted answer, but I hope nonetheless that you will have learned something from this.