Instance variable of interface type does not have access to implementation class methods where as instance variable of type implementation class do

As far as I can understand, your problem is the following:

// Interface with no methods
public interface Functions {
}

// Implementation class with a method defined in it
public class Implementation implements Functions {
    public void foo() {
        System.out.println("Foo");
    }
}

public class Main {
    public static void main(String[] args) {
        // Create a variable from the interface type and
        // assign a new instance of the implementation type
        Functions f = new Implementation();
        // You try to call the function
        f.foo();     // This is a compilation error
    }
}

That's the correct behavior, this is not possible. Because the compiler sees that variable f has the (static) type of Functions, it only sees the functions defined in that interface. The compiler is not aware of whether the variable actually contains a reference to an instance of the Implementation class.

To solve the issue you either should declare the method in the interface

public interface Functions {
    public void foo();
}

or make your variable have the type of your implementation class

Implementation f = new Implementation();

You are restricted to the methods defined by the Reference type, not the Instance type, for example:

AutoClosable a = new PrintWriter(...);
a.println( "something" );

Here, AutoClosable is the reference type and PrintWriter is the instance type.

This code will give a compiler error because the only method defined in AutoClosable is close().

You cannot do that, consider this example:

interface Foo {

}

And class:

class FooBar implements Foo {
   public void testMethod() { }
}

class FooBarMain {
    public static void main(String[] args) {
       Foo foo = new FooBar();
       //foo.testMethod(); this won't compile.
    }
}

Because at the compile time, compiler will not know that you are creating a new FooBar();and it has a method called testMethod() which will be determined dynamically. So it expects whatever you are accessing via interface variable should be available in your interface.

What you can do is if you want to access that method via interface variable, it's better to move that method to interface and let clients implement it.

Let me know if you have doubts on this.