About Java method & a parameter which implements multiple interfaces

Question

I'm writing a Java application, and have a question. How can I implement a function with one parameter which should require an argument which implements multiple interfaces? For example:

interface Father
{
}
interface Teacher
{
}
public void foo(FatherAndTeacher person) // How do I do this?
{
 // Do something
}

I know I can use two parameters, such as:

public void foo(Father person1, Teacher person2)
{
 // Do something
}

but I think maybe having a single parameter which implements both interfaces would be better.

• Carcigenicate: I think you'll need to show a good code example. I don't find this very clear as-is.
• Vasily Vlasov: Yes,it is possible to implement two interfaces in Java. But still it is not clear what you asking for, could you be a little bit more specific? May be by example?
• Michael: I've rewritten your question to hopefully make it clearer. If I've misinterpreted your question, feel free to edit your question again :)
• WaterMoon: Thanks very much, that's right and great! Sorry about my English.

Answer 1

Two enforce a parameter to have 2 interfaces you have 2 basic options:

1. Create a common interface that extends both and use that as your parameter type:

   interface FatherAndTeacher extends Father, Teacher { 
   }
   

   The problem with that is that objects that don't implement that interface don't match.

2. Use generics where you can require matching objects to implement both interfaces:

   public <T extends Father & Teacher> void foo(T person) {
    // Do something
   }
   

   Note that this only works with interfaces, i.e. you can't do T extends Number & String (2 classes). It works with one object boundary though, in which case the class must be first: T extends ConcretePerson & Father is ok but T extends Father & ConcretePerson is not (where ConcretePerson is a class).

• Thomas: @Michael you're right, he didn't add it. I adapted the answer accordingly.
• WaterMoon: Thank you very very much! : ) ^v^, I get the success, and thank you very very much : ) ^v^.
• Thomas: @WaterMoon you're welcome. Note that you should accept one of the working answers then. :)
• WaterMoon: Sorry, first use, don't know about this.

Answer 2

You can use a composite interface by extending both of your Teacher and Father interfaces.

Here's an example:

interface Teacher
{
 void teach();
}
interface Father
{
 void makeBadJoke();
}
// ----- Composite interface! Doesn't add any methods.
interface TeacherAndFather extends Teacher, Father
{
 /*This can be empty*/
}
class Bob implements TeacherAndFather
{
 public void teach() { System.out.println("1 + 1 = 2"); }
 public void makeBadJoke() { System.out.println("Knock knock..."); } 
}
class Main
{
 private static void foo(TeacherAndFather foo)
 {
 foo.teach();
 foo.makeBadJoke();
 }
 public static void main (String... args)
 {
 foo(new Bob());
 }
}

• WaterMoon: That's a great way, thank you very much.I thought this way and sometimes I want create less interface.Thanks. : )
• Michael: @WaterMoon You're welcome. Remember to click the check mark next to whichever answer solved your problem.

Answer 3

just use Object as your function parameter type:

void doSomething(Object param);

or using generic method:

<T> void doSomething(T param);

or let the two interface both inherit from one same interface.

public interface Person {}
public interface Teacher extends Person {}
public interface Father extends Person {}
public class Test {
 public void foo(Person p) {
 //
 }
}

• Michael: Except in that case you can pass things to foo that are neither a Teacher or a Father.
• treesong: yes, the foo function itself should check where parameter is instance of Teathcer or Father
• Michael: Nice to be able to enforce it at compile-time though :)