如何在java中为类注入接口？

Question

i have my DTO class that is :

public class EmailResponse {

    // Make public to avoid getters and setters
    public Email email;
    public RequestData reqData;    

    public EmailResponse() {
        super();
    }

}

and i want to implement to it this interface:

public interface IAssertionErrorDo {
    public void onErrorDo();
}

but i want to do it during execution, i don't want to touch "EmailResponse" because it would not be ok to make it implements that interface due they don't belong to the same layer, i mean, EmailResponse would belong to service layer and IAssertionError would belong to test layer. I am using TestNG.

Do you know how i could do this? Regards

EDIT: My implementation is this:

EmailResponse emailResponse = emailService.getUserEmail(userId);

And the reason i want to do this "injection" is because i have

public class LoggingAssert
    extends Assertion {

    private static final Logger LOGGER = LoggerFactory.getLogger(LoggingAssert.class);
    private IAssertionErrorDo dataE;
    @Override
    public void onAssertFailure(IAssert a, AssertionError ex) {
        LOGGER.info("[ERROR] " + a.getMessage());
        if (this.dataE != null) {
            this.dataE.onErrorDo();
        }
    }

    public LoggingAssert setOnErrorDo(IAssertionErrorDo object) {
        this.object = object;
        return this;
    }
}

---

loggingAssert.setOnErrorDo(emailResponse).assertNotNull(emailResponse.getEmail().getId(),
            "Checking created email doesn't exists");

So i want to if assert fails execute method onErrorDo() from emailResponse

Answer 1

You could do

public class MyEmailResponse extends EmailResponse implements IAssertionErrorDo {
...
}

Answer 2

implementation calls in interfaces, you can call more than 1 interface if you want by adding commas to separate them..

to call interface methods you simply just use the method's name.

like this:

public class MyEmailResponse implements IAssertionErrorDo 
{
  public void onErrorDo() {//define it's behavior}
} 

if you extend a class you use: super.MyMethod() to call the a method inside the extended class, but if you already have an extended class and want a method from another class you have to create an object for that class first then call it, thus:

MyClass mc = new MyClass();

if it is in a different package then

myPackage.MyClass mc = new myPackage.MyClass(); then you call your method from that class using the object you created, which is in this case mc.. so:

mc.MyMethod();

if you want it to return a variable then you will need to add a return statement in that method with the variable you want it to return.

interfaces are usually used for global an changing environments (dynamics), for example if you developed a program and it needs a driver to connect to databases then you will make an interface and send it to the database developers, and each one will fill the codes in that interface and send it back... this guarantees consistency. when you implement an interface you have to define every method inside it (even if you leave it empty) and you cannot change the interface's methods names nor add... it is used in other areas as well, i don't think you need to use it in your case.