Overlapping rectangles - multidimensional arrays
Class selection

First, I believe a multidimensional array is not good enough for describing rectangles. For instance, it's easy to forget what dimension responsible for what direction:

int[][] FirstRectangle = new[] { new[] { 2, 4 }, new[] { 8, 7 } };


What exactly is 2, 4, 8 and 7?
You have to remember. It's a bad design.

Instead you could use the built-in Rectangle struct or reinvent the wheel - write your own type.
In the latter case, it makes sense to move processing methods into your type.



Naming

I personally think that a method name should describe what the method do and what it returns.

So my suggestion is to rename methods Overlapping &rarr; IsOverlapping and GetOverlappingArea &rarr; PrintOverlappingArea.
Alternatively you could keep the name GetOverlappingArea (or Overlap, OverlapWith) and modify its code to create and return a new Rectangle instance which contains data of overlapping area. This method could be useful in the future.

Local variables should be named using camelCase: xOverlapping, yOverlapping.



Other notes

Instead of

if (XOverlapping &amp;&amp; YOverlapping) 
{
    return true;
}
else
{
    return false;
}


You could just

return XOverlapping &amp;&amp; YOverlapping;




Summarizing

public class Rectangle
{
    public readonly int Left;
    public readonly int Right;
    public readonly int Top;
    public readonly int Bottom;

    public Rectangle(int left, int right, int top, int bottom)
    {
        Left = left;
        Right = right;
        Top = top;
        Bottom = bottom;
    }

    public bool IsOverlapping(Rectangle other)
    {
        bool xOverlapping = other.Left &lt;= Right &amp;&amp; Left &lt;= other.Right;
        bool yOverlapping = other.Top &lt;= Bottom &amp;&amp; Top &lt;= other.Bottom;
        return xOverlapping &amp;&amp; yOverlapping;
    }

    public Rectangle OverlapWith(Rectangle other)
    {
        if (!IsOverlapping(other))
        {
            return null;
        }

        int left = Math.Max(Left, other.Left);
        int right = Math.Min(Right, other.Right);
        int top = Math.Max(Top, other.Top);
        int bottom = Math.Min(Bottom, other.Bottom);

        return new Rectangle(left, right, top, bottom);
    }

    public override string ToString()
    {
        return $"Left={Left}, Right={Right}, Top={Top}, Bottom={Bottom}";
    }
}




TODO

What else should be done?  


It always make sense to validate all input arguments in all public methods and constructors.
If you plan to compare rectangles with each other, it makes sense to implement IEquatable&lt;Rectangle&gt; interface and override the GetHashCode() method and optionally define == and != operators.