CODEWITHSUNDEEP
javajava-8
Nestor Milyaev
Nestor Milyaev

Reputation: 6595

In Java 8, can an interface default method access instance variables?

TL;TD In Java 8, is there a way for an interface default method to access instance variables?

For instance:

public interface Foo{
    default getBazModified(){
       return baz * 2; 
    }
}

public class Bar implements Foo {
   int baz;
   ...
}

I know that sounds like travisty but is there a way to do anything like that in Java 8?

Or is the only way is to have an abstract class that implements Foo, which would have both the instance variable baz declared and have a default implementation of getBazModified()?

Upvotes: 9

Views: 12115

Answers (4)

ALookingInView
ALookingInView

Reputation: 1

In essence your default method when running is running inside the instance of the class you are implementing. Therefore, instead of defining a getter method inside the class, you can always try to access the class parameters inside your default method using getDeclaredField. Keep in mind that you probably need to provide try..catch around it since if there is no parameter defined inside your class you get an exception.

public interface Foo {
    default getBazModified() {
        //since you have only one declared field in your class,
        //you can access it via index number 0
        // you can also use getDeclaredField("baz") if you 
        // prefer but then you are might get issues if you 
        //rename it. try.. catch would be needed here
        int baz = (int) this.getClass().getDeclaredFields()[0].get(this);

        return baz * 2; 
    }
}

public class Bar implements Foo {
    int baz;
   ...
}

Upvotes: -1

DASH
DASH

Reputation: 132

No. Because variables used inside a default method of an interface have access only to the variables defined inside the interface.

public interface Foo {
int BAZ=1;

default int getBazModified(){
    return BAZ * 2;
  }
}

Remember variables defined inside an interface are public,static and final and they must be initialized.

Now,

public class Bar implements Foo {
  int BAZ = 10;
}

within calling class..

 Foo foo = new Bar();
 System.out.print(foo.getBazModified()); // output: 2

You can only access instance variable inside "Bar" class by overriding default method. Like so,

public class Bar implements Foo {

  int BAZ = 10;

  @Override
  public int getBazModified() {
    return BAZ * 2;
  }
}

And know if,

Foo foo = new Bar();
System.out.print(foo.getBazModified()); // output: 20 (access instance variable)

Upvotes: 3

ernest_k
ernest_k

Reputation: 45329

An interface doesn't "see" its implementation's instance fields. This is not specific to interfaces, any super-type wouldn't know about its sub-types' specific fields (or any member type for that matter).

Your solution in this case is to declare an abstract getter method in the interface and use it to read the property of the subclass:

public interface Foo{
    default int getBazModified(){
       return this.getBaz() * 2; 
    }

    int getBaz();
}

And let the concrete class implement the getter:

public class Bar implements Foo {
   int baz;
   public int getBaz() {return this.baz;}
}

Upvotes: 17

Michael
Michael

Reputation: 44210

Did you try to compile it? The answer is no because the interface doesn't know whether there will even be a field named 'baz' or not.

I know that sounds like travisty but is there a way to do anything like that in Java 8?

Yes. An abstract class. That's literally exactly what abstract classes were designed for.

Upvotes: 1

Related Questions