CODEWITHSUNDEEP
javaoop
Sudantha
Sudantha

Reputation: 16204

Java multiple inheritance issue

I have a question like this :

Think a scenario like this 

public class Animal {

    protected String Name;
    Boolean canWork;

}

public class Dog {

  Enum TailType

}

And I need to have both of this classes attributes in a class of the third level which extends the both classes .. but using interfaces I don't think this can be achieved. Is it possible to do this using a design pattern or some else method ?

Summary : I want to have attributes from two classes to a concrete class

Upvotes: 0

Views: 191

Answers (6)

Marco167
Marco167

Reputation: 391

To achieve multiple inheritance, it is necessary to use Interfaces. You can either use inheritance by extending these classes on one another like:

//Your first class
public abstract class Animal{


//It is upto you to use an abstract method inside it. However it is not necessary to do so!
 //define an abstract method inside an abstract class.

}

//Your second class
public class Dog extends Animal{

}

//Your third class

 public class ThirdClass extends Dog{
 //here you can instantiate Dog
 private Dog dogObject = new Dog();

 public void anyMethod(){
      dogObject.anyMethodsThatAreDefinedInClassDogAndAnimal();
      }

 }

Hope this helps!!

Upvotes: 2

chubbsondubs
chubbsondubs

Reputation: 38751

You can have Dog extend Animal, then extend Dog by the third class, but unless your 3rd class is Poodle then you may have a problem you don't realize yet. That being inheritance is only appropriate when the relationship is a modeling criteria, and extending objects only to get their functionality is the wrong approach. Inheritance should follow the IS-A principle. That being your subclass IS-A base class in modeling terms. If it doesn't pass that test you are using inheritance when you shouldn't. After all you can use delegation to obtain their functionality. That meaning:

public class SomeClass {

    private Dog dog;

    public void bark() {
       dog.bark();  // this is reusing the functionality without extending
    }
}

Now SomeClass can call or invoke methods on Dog without extending it. Now the downside to this is a reference to Dog can't point to SomeClass, but if SomeClass is-not-a Dog that's probably good. However, if you have to allow Dog and SomeClass to share some typing so you can have a reference that points at either Dog or SomeClass then you can create an interface that both share:

public class SomeClass implements Barkable {
    private Dog dog;

    @Override
    public void bark() {
       dog.bark();
    }
}

public class Dog implements Barkable {

    @Override
    public void bark() {
       System.out.println( "Bark! Bark!" );
    }
}

With delegation/composition and interfaces you DON'T need multiple inheritance. It's a really simple technique to apply and master and you'll build systems that are much more flexible than relying on inheritance alone.

Upvotes: 3

Bryan Glazer
Bryan Glazer

Reputation: 852

Dog should be a subclass of Animal. Then your third class would be a subclass of Dog. This third class would have the attributes of Dog and Animal.

If Dog is not a subclass of Animal then you would need multiple inheritance to achieve what you want. Since Java does not support multiple inheritance you have to make Dog a subclass of Animal.

Or in case, your two classes are not in same inheritance hierarchy, then you have two options: -

  • Either make them interfaces, and then you can implement both the interfaces.
  • Or, use Composition instead of Inheritance, in which case, you would need to have the references to both the classes - Animal and Dog, as attribute in your class.

E.g: -

public class YourClass {
    Animal animal;
    Dog dog;
}

However, it doesn't make sense to have Animal and Dog class, with Dog not being a subclass of Animal. So, you should change that first, and then you would be able to use inheritance.

Upvotes: 1

AlexWien
AlexWien

Reputation: 28727

For good reasons modern OO languages like Java and C# do not support multiple inheritance.

The replacement to use in most cases is the interface:

public Interface NameAndWorkable {
  setName(String name)
  String getName();
  boolean canWork();
  setCanWork(boolean canWork);
}

public Interface TailAnimal {
   TailtypeEnum getTailType();
   setTailType(TailtypeEnum tailtype);
}

public class Animal implements NameAndWorkable {
  private String name;
  private boolean canWork;

  public setName(String name)
  public String getName();
  public boolean canWork();
  public setCanWork(boolean canWork);
}

public class Dog implements TailAnimal {

   private TailTypeEnum tailType;

   public TailtypeEnum getTailType();
   public setTailType(TailtypeEnum tailtype);
}

and now the third object with fullfills both Interfaces

public class WorkingNamedDog implements NameAndWorkable, TailAnimal {

  private String name;
  private boolean canWork;
  private TailTypeEnum tailType;

   // from NameAndWorkable 
   public setName(String name)
   public  String getName();
   public  boolean canWork();
   public  setCanWork(boolean canWork);

  // from TailAnimal
   public TailtypeEnum getTailType();
   public setTailType(TailtypeEnum tailtype);

}

Upvotes: 2

vishal_aim
vishal_aim

Reputation: 7854

if you are trying to have just attributes, I think you can use interfaces like:

interface A{
int a = 0;
}
interface B{
int b = 1;
}
class implements A, B{
//can access A.a and B.b
}

But this is not a good approach, interfaces are meant for contracts not just to contain constants (variables in interface are static and final by default)

Upvotes: 2

anubhava
anubhava

Reputation: 785196

You can extend one class and have another class as composition like this:

public class MyClass extends Dog {
    private Animal animal; // instance of Animal class
    // rest of the code to expose Animal class's attributes as per your need
}

Upvotes: 1

Related Questions