1.多态的实现 (1)定义一个抽象类Animal,包含一个抽象方法eat0。 (2)定义三个具体的动物类:Bird、 Fish、 Cat,它们都继承Animal类,并实现eat0方法。 (3)定义一个接口Iet,包含两个方法:play0和 getName.
时间: 2024-03-31 12:35:13 浏览: 106
(4)定义三个实现了Iet接口的类:Ball、Toy、Food,它们都实现了play0和getName方法。
(5)在一个测试类中,创建一个Animal类型的数组,并将Bird、Fish、Cat的实例添加进去。然后循环遍历这个数组,依次调用每个动物的eat0方法。
(6)再创建一个Iet类型的数组,并将Ball、Toy、Food的实例添加进去。然后循环遍历这个数组,依次调用每个对象的play0和getName方法。
这样就实现了多态,Animal、Bird、Fish、Cat都属于Animal类型,但各自实现了eat0方法;Ball、Toy、Food都属于Iet类型,但各自实现了play0和getName方法。在遍历数组时,可以直接调用父类或接口的方法,而不用关心具体实现类。
相关问题
1.多态的实现 (1)定义一个抽象类Animal,包含一个抽象方法eat()。(2)定义三个具体的动物类:Bird、Fish、Cat,它们都继承Animal类,并实现eat0)方法。 (3)定义一个接口IPet,包含两个方法:play(和 getName()用java编写
以下是多态的实现示例,使用 Java 编写:
```java
// 抽象类 Animal
abstract class Animal {
public abstract void eat();
}
// 具体类 Bird,Fish,Cat
class Bird extends Animal {
public void eat() {
System.out.println("Bird is eating.");
}
}
class Fish extends Animal {
public void eat() {
System.out.println("Fish is eating.");
}
}
class Cat extends Animal {
public void eat() {
System.out.println("Cat is eating.");
}
}
// 接口 IPet
interface IPet {
void play();
String getName();
}
// 实现具体接口类 Pet
class Pet implements IPet {
private String name;
public Pet(String name) {
this.name = name;
}
public void play() {
System.out.println(name + " is playing.");
}
public String getName() {
return name;
}
}
public class Test {
public static void main(String[] args) {
// 多态的应用
Animal[] a = new Animal[3];
a[0] = new Bird();
a[1] = new Fish();
a[2] = new Cat();
for (int i = 0; i < 3; i++) {
a[i].eat();
}
IPet p = new Pet("Tom");
p.play();
System.out.println(p.getName());
}
}
```
这个示例中,定义了一个抽象类 Animal,它包含一个抽象方法 eat(),然后定义了三个具体的动物类 Bird、Fish、Cat,它们都继承自 Animal 并实现了 eat() 方法。接着定义了一个接口 IPet,它包含两个方法 play() 和 getName(),然后实现了一个具体的类 Pet,它实现了 IPet 接口。最后在主函数中,使用多态的思想创建了 Animal 对象数组和 IPet 对象,并且通过接口调用了对应的方法。
1.多态的实现 (1)定义一个抽象类Animal,包含一个抽象方法eat0。 (2)定义三个具体的动物类:Bird、Fish、Cat,它们都继承Animal类,并实现eat0方法。 (3)定义一个接口Pet,包含两个方法:play0和getName()。 (4)在Cat类中实现IPet接口,并实现play0方法和getName()方法。 (5)编写一个测试类,在主函数中,创建一个数组,将其中的元素分别指向Bird、Fish、Cat对象,并通过循环调用eat0方法和play0方法。要求程序能够正确输出每种动物的eat0方法和只有Cat对象的play0方法。
好的,下面是实现多态的代码:
Animal.java:
```
public abstract class Animal {
public abstract void eat0();
}
```
Bird.java:
```
public class Bird extends Animal {
@Override
public void eat0() {
System.out.println("Bird is eating.");
}
}
```
Fish.java:
```
public class Fish extends Animal {
@Override
public void eat0() {
System.out.println("Fish is eating.");
}
}
```
Cat.java:
```
public class Cat extends Animal implements IPet {
@Override
public void eat0() {
System.out.println("Cat is eating.");
}
@Override
public void play0() {
System.out.println("Cat is playing.");
}
@Override
public String getName() {
return "Cat";
}
}
```
IPet.java:
```
public interface IPet {
void play0();
String getName();
}
```
Test.java:
```
public class Test {
public static void main(String[] args) {
Animal[] animals = new Animal[3];
animals[0] = new Bird();
animals[1] = new Fish();
animals[2] = new Cat();
for (Animal animal : animals) {
animal.eat0();
}
if (animals[2] instanceof IPet) {
IPet pet = (IPet) animals[2];
pet.play0();
}
}
}
```
输出结果:
```
Bird is eating.
Fish is eating.
Cat is eating.
Cat is playing.
```