Java Inheritance - modeling multiple objects

You should extract the behaviour into interfaces, not separate classes.

interface Swimmable{
    void swim();
}

interface Talkable{
    void talk();
}

interface Walkable{
    void walk();
}

class Person {
    void breed();
}

Notice how I named them Walkable instead of Walker. This indicates that this interface defines a behaviour and is not a standalone thing. Now your actual object can be called Walker, but lexically spoken walkable also makes more sense if you use it for other classes that want that behaviour.

There's a lot of hype about "composition over inheritance" but really this is just an inappropriate solution to programmers using the two interchangeable when they shouldn't.

Now if you want to create an entity that can swim and walk you can simply define it as such:

class Athlete extends Person implements Swimmable, Walkable {
    @Override
    void swim(){ }

    @Override
    void walk(){ }
}

and there will be no messing around with actual instances of the behaviour that will have to be called through another layer in the actual Athlete class, etc etc.

A Walker is a person who can walk and breed, A Talker is a person who can talk and breed, A Swimmer is a person who can swim,talk,walk and breed.

I would use interfaces to represent the traits, and use concrete classes to represent the types, e.g.:

public interface IWalker {
    public void walk ();
}

public interface IBreeder {
    public void breed ();
}

public interface ITalker {
    public void talk ();
}

public interface ISwimmer {
    public void swim ();
}

public class Person {
}

public class Walker extends Person implements IWalker, IBreeder {
    @Override public void walk () { ... }
    @Override public void breed () { ... }
}

public class Talker extends Person implements ITalker, IBreeder {
    @Override public void talk () { ... }
    @Override public void breed () { ... }
}

public class Swimmer extends Person implements ISwimmer, ITalker, IWalker, IBreeder {
    @Override public void swim () { ... }
    @Override public void walk () { ... }
    @Override public void talk () { ... }
    @Override public void breed () { ... }
}

This way you can, say, use IWalker everywhere that anything that can walk is expected, or Swimmer anywhere a specific type of person is expected, or Person anywhere a generic person is expected.

For the record, I don't particularly like the I* naming scheme for interfaces; but I picked them to be unique given the word choices.

I see interface as something that hold the ablity that an entity has, possibly that is why in JavaSE many interfaces are name XXXable, where XXX denotes ability e.g Comparable, 'Serializable' etc.

Here, Breeading, Talking, Walking, Swimming are ability of certain person. So an entity has some ablity. Therefore i make all those independent abilities as interfaces and entity(Swimmer, Talker, Walker) will implement those interface to get those ablities.

interface Breedable {
    public void breed();
}

interface Walkable {
    public void walk();
}

interface Talkable {
    public void talk();
}

interface Swimmable {
    public void swim();
}

class Swimmer implements Swimmable, Walkable, Talkable, Breedable {

    @Override
    public void breed() {
        // TODO Auto-generated method stub

    }

    @Override
    public void talk() {
        // TODO Auto-generated method stub

    }

    @Override
    public void swim() {
        // TODO Auto-generated method stub

    }

    @Override
    public void walk() {
        // TODO Auto-generated method stub

    }

I think what you should have is something like that.

public class Person
//Breed method here

public class Walker extends Person
//Walk method here

public class Talker extends Person
//Talk method here

public class Swimmer extends Person
//Swim, talk & walk method here

But what you should really do is thinking about separation of concerns. Is there enough common points between each of these objects to use inheritance? Maybe not.

class person{
 //breed function
 }
 class walker extends person{
 //walk function
 }
 class talker extends person{
 //talk function
 }
class swimmer extends talker{     
//swim function
//walk function
}