编写程序实现Java的多重继承

Java语言本身不支持多重继承，但可以通过接口的方式来实现类似多重继承的功能。以下是一个实现多重继承的示例程序：

interface A {
    void foo();
}

interface B {
    void bar();
}

class C implements A, B {
    public void foo() {
        System.out.println("foo");
    }
    
    public void bar() {
        System.out.println("bar");
    }
}

public class Main {
    public static void main(String[] args) {
        C c = new C();
        c.foo(); // 输出 "foo"
        c.bar(); // 输出 "bar"
    }
}

在上述示例程序中，接口A和B定义了各自的方法foo和bar。类C实现了接口A和B，并重写了其定义的方法。在主函数中，我们创建了一个类C的实例，并调用了其实现的方法foo和bar。由于类C实现了接口A和B，因此具备了这两个接口的行为，实现了类似多重继承的功能。

相关问题

编写程序实现 Java 多重继承。

在 Java 中，不支持多重继承，但可以通过接口实现多重继承的效果。下面是一个 Java 程序的示例，演示了接口实现多重继承的效果：

interface A {
   public void methodA();
}

interface B {
   public void methodB();
}

class C implements A, B {
   public void methodA() {
      System.out.println("methodA of interface A");
   }

   public void methodB() {
      System.out.println("methodB of interface B");
   }
}

public class Test {
   public static void main(String args[]) {
      C c = new C();
      c.methodA();
      c.methodB();
   }
}

在上面的代码中，定义了两个接口 A 和 B，分别包含一个方法 methodA 和一个方法 methodB。类 C 实现了接口 A 和 B，重写了其中的 methodA 和 methodB 方法。在 main 方法中创建了 C 对象 c，并调用了其 methodA 和 methodB 方法来输出结果。由于类 C 实现了接口 A 和 B，因此具有了多重继承的效果，同时也可以避免 Java 中不支持多重继承的问题。

实现一个金丝猴类，要求继承自动物类，并实现包括金丝猴，是受保护，而且是有价值的动物的多重继承的功能，用Java 编写

好的，以下是Java代码实现：

// 动物类
class Animal {
    // 动物名称
    String name;
    // 是否受保护
    boolean isProtected;

    // 构造函数
    public Animal(String name, boolean isProtected) {
        this.name = name;
        this.isProtected = isProtected;
    }

    // 动物的介绍
    public void introduce() {
        System.out.println("我是一只" + name);
    }
}

// 有价值的动物接口
interface Valuable {
    // 是否有价值
    boolean isValuable();
}

// 受保护的动物接口
interface Protected {
    // 是否受保护
    boolean isProtected();
}

// 金丝猴类，继承自动物类，并实现有价值的动物接口和受保护的动物接口
class GoldenMonkey extends Animal implements Valuable, Protected {
    // 是否有价值
    boolean isValuable;

    // 构造函数
    public GoldenMonkey(String name, boolean isProtected, boolean isValuable) {
        super(name, isProtected);
        this.isValuable = isValuable;
    }

    // 是否有价值的实现
    public boolean isValuable() {
        return isValuable;
    }

    // 是否受保护的实现
    public boolean isProtected() {
        return isProtected;
    }

    // 多重继承的功能
    public void multipleInheritance() {
        System.out.println("我是一只金丝猴，我实现了多重继承，我既是动物，又是有价值的受保护动物");
    }

    // 金丝猴的介绍
    public void introduce() {
        super.introduce();
        System.out.println("我是一只" + (isProtected ? "受保护的" : "未受保护的") + (isValuable ? "有价值的" : "无价值的") + "金丝猴");
    }
}

// 测试类
public class Test {
    public static void main(String[] args) {
        GoldenMonkey monkey = new GoldenMonkey("金丝猴", true, true);
        monkey.introduce();
        monkey.multipleInheritance();
    }
}

运行结果为：

我是一只金丝猴
我是一只受保护的有价值的金丝猴
我是一只金丝猴，我实现了多重继承，我既是动物，又是有价值的受保护动物