Understanding the return type in a function - vb.net

Question

There are examples I have seen where the return type mentioned in the function declaration is different from the default return type mentioned in the Return statement present in the body of the function. I am trying to understand how this works. For that I have come up with the following hypothetical example:
I had defined a class library MyMathsLibrary as following:
Public Class MathOperations
Public Function ADD(ByVal a As Integer, ByVal b As Integer) As Integer
Return a + b
End Function
End Class
Then I imported the above class Library into another class library named FactoryMathsLibrary as follows:
Imports MyMathsLibrary
Public Class Factory
Shared Function createMathsObject() As Object
Return New MathOperations()
End Function
End Class
Finally, I write the following code piece:
Imports FactoryMathsLibrary
Module Module1
Sub Main()
Dim a, b As Integer
Dim m As Object = Factory.createMathsObject()
Console.WriteLine(m.GetType())'O/P: MyMathsLibrary.MathOperations
Console.WriteLine("a + b = {0}", m.ADD(10, 5))
Console.WriteLine("a - b = {0}", m.Minus(20, 7))
Console.ReadLine()
End Sub
End Module
Question 1:
The function createMathsObject returns a reference which gets stored in the variable m. The output of the GetType command confirms that the reference that is returned points towards an instance of MathOperations class. So if that is the case what role does the word OBJECT play in the statement - Shared Function createMathsObject() As Object?
Related question:
Suppose there is an interface with only the ADD function in it and the class MathOperations implements the interface. In this case the variable m can be both of the Interface type as well as OBJECT type. In both cases it should be able to store the references that createMathsObject returns. In such a case, the good practice seems to be to declare m of interface type. My question is, is this because we need to avoid late binding wherever possible or is there any other reason? One drawback of declaring m to be of interface type (which could be a justification behind declaring m to be Object type) is that we cannot access elements which are not defined in the interface - for example if we declare m as object type and the interface has only the ADD method defined it it, we cannot write something like m.minus(a,b). Here MINUS should be assumed to be a function that calculates the difference between two values but is not a part of the Interface - rather its exclusive to the MathOperations class.