Why is multiple inheritance bad?

Question

Hi all,
Can someone give me examples explaining why multiple
inheritence is bad?
My arguments, why the absence multiple inheritence
is bad are below:
1) The absence of multiple inheritance gives me sometimes
headaches. If I implement an interface for overriding just
one method, I must then in some cases (likely in
AWT-programming) "empty-implement" 10 other methods.
2) If I use the adapter class to avoid this, then I cannot
derive my class from another one.

Answer 1

In my opinion, the lack of multiple inheritance is
not a real problem. You can easily bypass this using
a delegate pattern. Example:
class Base1 {
public void method1() {
class Base2 {
public void method2() {
If you want to create a class which inherits from
Base1 and Base2, take the following approach:
Create Interfaces for Base1 and Base2:
intface BaseInterface1 {
public void method1();
interface BaseInterface22 {
public void method2();
Now, let Base1 and Base2 implement the Interfaces.
class Base1 implements Base1Interface {
public void method1() {
class Base2 implements Base2Interface {
public void method2() {
The the subclass can inherit from one baseclass
and implement the other one. Base2 is an attribute
(instance variable) of the new class:
class Devided extends Base1 implements Base2Interface {
Base2 base2;
// Methods of Base2Interface:
public void method2() {
base2.method2();
This looks like a lot of handcraft, but modern IDEs
like Eclipse or VisualAge (ok, not really modern)
give the developer the advantages of self-written
plug-ins. Using such a plug-in, you can easily
automate the creation of the interfaces and the
delegate. In my previous company we wrote several
"wizards" for VisualAge to prevent us from doing
stupid steps again and again.