Um ....

Changing the type of the parameter (from Foo for the first
function, and Bar for the section, to C in both cases) takes
away the point of the example.

The method doSomethingWithAClassThatIsAFoo() will presumably
do something sensible as long as the parameter it is passed
belongs to a class with a saySomething() method.  An object
of class C will work, but so would an object of class A,
right?  but by making the type of the parameter C, you make
it impossible to call this method with a parameter of type A,
even though that would (presumably) be a sensible thing to do.

To indicate that doSomethingWithAClassThatIsAFoo() should
accept objects of any class that has a saySomething() method,
the original code defines an interface Foo containing that
method.  If classes A and C are declared to "implement Foo",
this means that:

(1) Both A and C need to have a saySomething() method.

(2) You can pass an object that's a C (e.g., "test" in main
below) to doSomethingWithAClassThatIsAFoo(), but you could
also pass it an A, as in the following (untested!!) lines:

   A testA = new A();
   doSomethingWithAClassThatIsAFoo(testA);

You could also define other classes with saySomething() methods,
totally unrelated to A and C, and then pass objects of these
classes to doSomethingWithAClassThatIsAFoo().  The only requirement
is that the class have a saySomething() method, which you indicate
by saying that the class "implements Foo".

Well, I don't know if this is getting clearer or murkier ....

I also think there must be something very simple that would make all
of this clear to you, because I don't think the basic ideas should
be beyond someone who has mastered *some* programming language
(as it sounds like you have).  There must be someone reading this
group who can say the magic words that will make the light bulb
come on for you, but ....

I think a lot of the responses you're getting are bringing in lots
of details and complications that while interesting and relevant
probably just confuse you further.

It might help also if you described your previous programming
experience, particularly which language(s) you've used before.
(I thought this might be in one of your earlier posts, but I didn't
find it.  Apologies if I just missed it.)

I hope this isn't duplicated, but I'm not seeing my earlier post.
Anyway, by changing the method signature of the example, you've
defeated the purpose of the exercise. The original example had methods
that expected arguments of Foo and Bar. What this was doing was forcing
the passed arguments to implement the Foo or Bar interfaces. Our class,
class C, implemented both of these interfaces and so could be passed to
each method. Class C provided the look and feel of multiple inheritance
of classes A and B by implementing these interfaces and holding its own
copies of A and B. In Java, you cannot extend 2 base classes:

class C extends A,B // won't compile.

My suggestion was to provide interfaces and a class per interface that
you wish class C to extend. Then instead of extending A and B, you
implement each interface and hold instances of A and B, which receive
the forwarded method calls.

Maybe a different example will help you. Let's create a small example
where a fire house has employees, one of which is a dog. We create an
interface, IAnimal, to describe animal behaviour. We also create an
interface, IEmployee, to describe employee behaviour. We have an Animal
class that can be extended and an Employee class which can be extended.
We will create a WorkingDogHolder class to 'extend' both Animal and
Employee by implementing both the IAnimal and IEmployee interfaces and
holding instances of Dog and Employee. We will create a Secretary class
to pay employees and a Groomer class to groom animals. Because a
WorkingDogHolder is both and Animal and an Employee, we need to try and
fake some multiple inheritance:

public interface IAnimal {
   public void eat();
   public void receiveGrooming();
}

public interface IEmployee {
   public void receivePayment();
}

public class Animal implements IAnimal {

   /* (non-Javadoc)
    * @see IAnimal#eat()
    */
   public void eat() {
       System.out.println("Animals love to eat!");
   }

   public void receiveGrooming() {
       System.out.println("Animals love a good grooming");
   }
}

public class Dog extends Animal {
   public void eat() {
       System.out.println("Dogs love to eat!");
   }

   public void receiveGrooming() {
       System.out.println("Dogs love a good grooming");
   }
}

public class Employee implements IEmployee {

   /* (non-Javadoc)
    * @see IEmployee#receivePayment()
    */
   public void receivePayment() {
       System.out.println("I love payday!");
   }
}

public class WorkingDogHolder implements IAnimal, IEmployee {
   private final Employee employee_ = new Employee();
   private final Dog dog_ = new Dog();

   public void receivePayment() {
       this.employee_.receivePayment();
       this.eat();
   }

   public void eat() {
       this.dog_.eat();
   }

   public void receiveGrooming() {
       this.dog_.receiveGrooming();
   }
}

public class Groomer {
   public void groomAnimal(final IAnimal animal) {
       animal.receiveGrooming();
   }
}

public class Secretary{
   public void providePayment(final IEmployee employee) {
       employee.receivePayment();
   }
}

public class Main {

   public static void main(String[] args) {
       Employee humanEmployee = new Employee();
       WorkingDogHolder workingDog = new WorkingDogHolder();
       Dog normalDog = new Dog();
       Secretary secretary = new Secretary();
       Groomer groomer = new Groomer();

       secretary.providePayment(humanEmployee);
       secretary.providePayment(workingDog);
       //secretary.providePayment(normalDog);    //won't compile because
a normal dog

       //doesn't get paid
       groomer.groomAnimal(normalDog);
       groomer.groomAnimal(workingDog);
       //groomer.groomAnimal(humanEmployee);    //won't compile because a
human

           //can't be groomed in this example
   }
}

Will coughed up:

...[rip]...

Would you mind if we start at the beginning with what interfaces are, but in
a more example-driven way, rather than hoity toity theory?  This is going to
be very basic, and hopefully not insult you.  But I think there is a
misunderstanding somwhere in here.  Then you can tell me to what extent you
understand what I have to say, so we can procede from there.

Let's start with modeling a bunch of creatures.

Let's pretend that I want to model birds.  They know how to fly a certain
number of feet.  They also know how to chirp.  We'll leave the details of
how flight and chirping is actually accomplished out of the discussion /on
purpose/.  Note this is a real class, not an interface.

public class Bird extend Creature
{
   public void fly(int feet) { /* fly code here */ }
   public void chirp() { /* chirping code here */ }
}

Now let's pretend that we also have Bugs.  They know how to fly, but they
don't know much about chirping, but they can sure run.  Birds can't really
run.

public class Bug extend Creature
{
   public void fly(int feet) { /* fly code here */ }
   public void run(int feet) { /* run code here */ }
}

And we have Mammals.  They know how to run, but not fly nor chirp, nor
anything else much:

public class Mammals extend Creature
{
   public void run(int feet) { /* run code here */ }
}

We would like to keep track of the creatures that can fly, and of the ones
that can run.  So we build an interface representing these abilities:

public interface Airborne
{
   void fly(int feet);
}

public interface CanRun
{
   void run(int feet);
}

And then we make sure that the classes that we already have created
implement these interfaces.  Implementing the interfaces doesn't make them
have any abilities they didn't already have, it just allows us to put them
into useful categories (the OO purists are groaning here, but bear with me):

public class Bird implements Airborne
{
   public void fly(int feet) { /* fly code here */ }
   public void chirp() { /* chirping code here */ }
}

public class Bug implements Airborne, CanRun
{
   public void fly(int feet) { /* fly code here */ }
   public void run(int feet) { /* run code here */ }
}

public class Mammals implements CanRun
{
   public void run(int feet) { /* run code here */ }
}

Why the heck is this useful?  Well let's pretend you had the following
objects:

Bird bird1 = new Bird();
Bird bird2 = new Bird();
Bird bird3 = new Bird();
Bug bug1 = new Bug();
Bug bug2 = new Bug();
Mammal mammal1 = new Mammal();
Mammal mammal2 = new Mammal();
Mammal mammal3 = new Mammal();
Mammal mammal4 = new Mammal();
Mammal mammal5 = new Mammal();

You could then create an array of just the creatures that can fly:

Airborne[] flyingCreatures = { bird1, bird2, bird3, bug1, bug2 };

You would not be able to add any of the mammals:

// Error: mammal1 is not an Airborne object:
Airborne[] flyingCreatures = { bird1, bird2, bird3, bug1, bug2, mammal1 };

You could then also have a collection of the creatures that run.  Note, that
some of these also fly:

CanRun[] runningCreatures = {bug1, bug2, mammal1, mammal2, mammal3, mammal4,
mammal5}

...but of course, you would not be able to add any birds to this list.

All of this hoo-hah is an enforement of type-safety.  You now have a way of
specifying only things that fly, and only things that run.

For example, we could create a method that makes the given airborne create
fly a mile:

   public void flyAMile(Airborne flyingCreature)
   {
       flyingCreature.fly(5280);
   }

And we could then call this:

   flyAMile(bird2);

And specifically not this:

   flyAMile(mammal4);

I'm betting you have this part down cold already.  Do you?

You are confused.  Real interfaces never do anything, ever at runtime.

They allow a gadget like thread to call passedInRunnable.run() because
they defined an interface and require thier callbacks to look a certain way.

Interfaces are always backed by implementations at runtime, including
for Runnable, Comparable, Comparator, Serializable, Cloneable etc.

(dont go on about instanceof, constants, reflection or other
obfuscations please, it wont help this guy)

Will,

You have changed the example in a fundamental way by changing the
method signatures from something that expects a Foo or Bar to something
that expects class C. This completely defeats the original purpose,
which was to mimic multiple inheritance. If you want class C to inherit
the functionality of both A & B, you cannot do this directly in Java:

class C extends A, B // will not compile

What you can do is implement any number of interfaces you like. So, if
you create a class to implement the Foo interface (class A) and create
another class to implement the Bar interface (class B) and then create
a class that implements both Foo and Bar (class C) then you can provide
class C with instances of classes A & B and forward all method calls
from interfaces Foo and Bar to those class members. This provides the
'look and feel' of multiple inheritance. Of course, it isn't real
multiple inheritance because you could not pass instances of C to a
method that expects an instance of A, which you would be able to do if
'real' multiple inheritance was used.

Maybe a different example will help clear things up. Let's use a
variation of the Animal hierarchy:

The Animal class is the parent class for all animals.The Employee class
is the parent class for all employess of a fire station. The Secretary
class hands out the payment for all employees of the fire station. The
Secretary only hands out payments to classes that implement the
IEmployee interface. The WorkingDogHolder class needs to implement all
Animal behaviour and Employee behaviour, because these dogs can be
employees. Since most Dogs are not employees, we'll create a Dog class
that extends Animal via single inheritance. To provide the look and
feel of multiple inheritance for a Dog that is an Employee, we'll
create a WorkingDogHolder class that needs to provide behaviour for
both Dog and Employee. We'll do this by implementing both IAnimal and
IEmployee and holding instances to an Dog class and Employee class.
We'll also provide a Groomer class that will groom all animals, but not
Employees.

public interface IAnimal {
   public void eat();
   public void receiveGrooming();
}

public interface IEmployee {
   public void receivePayment();
}

public class Animal implements IAnimal {

   /* (non-Javadoc)
    * @see IAnimal#eat()
    */
   public void eat() {
       System.out.println("Animals love to eat!");
   }

   public void receiveGrooming() {
       System.out.println("Animals love a good grooming");
   }
}

public class Dog extends Animal {
   public void eat() {
       System.out.println("Dogs love to eat!");
   }

   public void receiveGrooming() {
       System.out.println("Dogs love a good grooming");
   }
}

public class Employee implements IEmployee {

   /* (non-Javadoc)
    * @see IEmployee#receivePayment()
    */
   public void receivePayment() {
       System.out.println("I love payday!");
   }
}

public class WorkingDogHolder implements IAnimal, IEmployee {
   private final Employee employee_ = new Employee();
   private final Dog dog_ = new Dog();

   public void receivePayment() {
       this.employee_.receivePayment();
       this.eat();
   }

   public void eat() {
       this.dog_.eat();
   }

   public void receiveGrooming() {
       this.dog_.receiveGrooming();
   }
}

public class Groomer {
   public void groomAnimal(final IAnimal animal) {
       animal.receiveGrooming();
   }
}

public class Secretary{
   public void providePayment(final IEmployee employee) {
       employee.receivePayment();
   }
}

public class Main {

   public static void main(String[] args) {
       Employee humanEmployee = new Employee();
       WorkingDogHolder workingDog = new WorkingDogHolder();
       Dog normalDog = new Dog();
       Secretary secretary = new Secretary();
       Groomer groomer = new Groomer();

       secretary.providePayment(humanEmployee);
       secretary.providePayment(workingDog);
       //secretary.providePayment(normalDog);    //won't compile because
                                               //a normal dog doesn't
                           //get paid
       groomer.groomAnimal(normalDog);
       groomer.groomAnimal(workingDog);
       //groomer.groomAnimal(humanEmployee);    //won't compile because
                                               //a human can't
                           //be groomed in this example
   }
}

Thomas G. Marshall <tgm2tothe10thpower@replacetextwithnumber.hotmail.com> wrote or quoted:

If you implement two different interfaces with the same method signature
in them in Java, the methods simply clash.

I wouldn't describe that as being "not a problem at all".