java编写Flyable接口，定义speed( )方法；

好的，这是一个关于Java编程的问题。Flyable接口定义了speed()方法，这个方法可以表示飞行速度。接口定义如下：

public interface Flyable {
    int speed();
}

在实现Flyable接口时，需要覆盖speed()方法，返回一个整数值，表示飞行速度。例如：

public class Bird implements Flyable {
    @Override
    public int speed() {
        return 50;
    }
}

这个Bird类实现了Flyable接口，覆盖了speed()方法，返回了一个表示鸟飞行速度的整数值50。

相关问题

2.按以下要求编程 (1编写Animal类，定义leg厲性、有参构造西数对1eg赋初值，定义空的 sound0方法； (2)编写Flyable接口，定义speed()方法； (3)编写Glede类继承Animal类并实现Flyable接口，定义speed属性，有参构造 方法对leg和speed赋初值，speed()方法返回speed属性，sound()方法输出〝嘎 ..." o (④编写测试程序，定义包含2个元素的Glede对象数组，分别调用speed()方法 和sound()方法。

好的，以下是代码实现：

// Animal类
public class Animal {
    protected int leg;

    public Animal(int leg) {
        this.leg = leg;
    }

    public void sound() {
        System.out.println("Animal sound");
    }
}

// Flyable接口
public interface Flyable {
    public int speed();
}

// Glede类
public class Glede extends Animal implements Flyable {
    private int speed;

    public Glede(int leg, int speed) {
        super(leg);
        this.speed = speed;
    }

    public int speed() {
        return this.speed;
    }

    public void sound() {
        System.out.println("嘎嘎嘎");
    }
}

// 测试程序
public class Test {
    public static void main(String[] args) {
        Glede[] gledes = new Glede[2];
        gledes[0] = new Glede(2, 50);
        gledes[1] = new Glede(2, 60);

        for (Glede glede : gledes) {
            System.out.println("speed: " + glede.speed());
            glede.sound();
        }
    }
}

注：以上代码中，Animal类定义了leg属性和sound()方法，Glede类继承了Animal类并实现了Flyable接口，定义了speed属性和speed()方法和sound()方法。测试程序定义了一个包含两个元素的Glede对象数组，并分别调用了speed()方法和sound()方法。

java：编写程序，定义一个名为Swimmable（可游泳的）的接口，其中包含void swim()方法，定义另一个名为Flyable(可飞的)的接口，其中包含void fly()方法。 定义一个名为Animal的抽象类，其中包含一个抽象方法void eat()。定义一个名为WildDuck(野鸭)的类实现上述两个接口，并继承Animal类。 编写main()方法，在其中创建一个WildDuck实例，调用它的各种方法。将WildDuck实例分别赋值给一个Swimmalbe引用、Flyable引用和Animal引用，测试通过这些引用能否调用相应接口或抽象类中定义的方法。

好的，以下是您所需的Java代码：

// Swimmable接口
interface Swimmable {
    void swim();
}

// Flyable接口
interface Flyable {
    void fly();
}

// Animal抽象类
abstract class Animal {
    abstract void eat();
}

// WildDuck类实现Swimmable、Flyable接口并继承Animal抽象类
class WildDuck extends Animal implements Swimmable, Flyable {
    @Override
    void eat() {
        System.out.println("WildDuck is eating.");
    }

    @Override
    public void swim() {
        System.out.println("WildDuck is swimming.");
    }

    @Override
    public void fly() {
        System.out.println("WildDuck is flying.");
    }
}

// 测试
public class Test {
    public static void main(String[] args) {
        WildDuck wildDuck = new WildDuck();

        // 通过Swimmable引用调用swim()方法
        Swimmable swimmable = wildDuck;
        swimmable.swim();

        // 通过Flyable引用调用fly()方法
        Flyable flyable = wildDuck;
        flyable.fly();

        // 通过Animal引用调用eat()方法
        Animal animal = wildDuck;
        animal.eat();
    }
}

输出结果如下：

WildDuck is swimming.
WildDuck is flying.
WildDuck is eating.

以上代码实现了定义Swimmable、Flyable接口和Animal抽象类，并在WildDuck类中实现了这些接口并继承了Animal类。在main()方法中，创建了一个WildDuck实例，并将其分别赋值给Swimmable、Flyable和Animal引用，测试了通过这些引用能否调用相应接口或抽象类中定义的方法。