(OOP) Implementing a pre-programmed function in a class

Question

An experimental/theoretical question concerning any OOP language (Java, C#, Typescript, etc..)

Usually, when implementing an interface in a class, one has to override all the functions of that interface in the class by having to write the code for each function from that interface. And every class that implements this interface has to have its own code for those functions. Suppose we have an interface called Test that has a function called foo() in which I want the following code System.out.println("This is an interface function");.
Usually one has to make an interface and declare the function and then writes the code in every implementing class But what if there is some "theoretical" way of having all of the function written in the interface and every implementing class can just call it without having to override. Something like the following (using Java as a base language):

interface Test {
    public foo() {
        System.out.println("Test log.")
    }
}

class Class1 implements Test {
    constructor() {}

}
class Class2 implements Test {
    constructor() {}

}

class Main {
    public static void main() {
        Class1 f1 = new Class1();
        Class2 f2 = new Class2();
        f1.foo();
        f2.foo();
    }
}

Answer 1

Java has this feature since Java 8. Interfaces can have default implementations where the class is free to override them, but not required to do so.

interface Test {
    default void foo() {
        System.out.println("Test log.");
    }
}