Java 在返回类/对象名称的抽象类中实现方法

所以我有一个结构-一个叫做

Animal

的接口：

public interface Animal {

    public String move ();

    public String makeSound();

    public String getType();

}

然后是一个名为

AbstractBird

的抽象类，它实现了

Anima

：

public abstract class AbstractBird implements Animal {
    public String birdType;
    public String getType() {
        return birdType;
    }
    @Override
    public String move() {
        return "Fly";
    }
}

然后有几个类扩展了

AbstractBird

，它们具有相同的结构，叫做

Dove

，

Hawk

，

Eagle

等等。。就像这样：

public class Eagle extends AbstractBird {
    public Eagle() {
        birdType = "Eagle";
    }

    @Override
    public String makeSound() {
        return "Noone knows";
    }
}

然后是我的类

AnimalSound

，它有

main

方法：

public class AnimalSound {
    public static void main(String[] args) {
        Eagle e = new Eagle();
        Dove d = new Dove();
        Hawk h = new Hawk();
        play(e);
        play(d);
        play(h);
    }
    public static void play(Animal a) {
        System.out.println("````````````");
        System.out.println(a.getType());
        System.out.println(a.makeSound());
        System.out.println(a.move());

    }
}

如您所见，我有一个方法

getType（）

，它返回

birdtype

。这个方法本身是在抽象类中实现的，这是可以的，但是为了得到正确的

birType

，我需要为每个类编写构造函数，在这里我可以初始化

birdType

，这是我不太喜欢的部分。因此，我的问题是如何在抽象类中实现

getType（）

方法，以便它返回类的名称和/或对象的名称。我不确定在我的示例中，哪一个更好——类具有鸟的名称，但考虑到这一点，我认为返回到对象的名称可能更有意义。

@Leron

以下是一个例子：

class Untitled {
  private static abstract class Animal {
    public String getType() {
      return this.getClass().getSimpleName();
    }
  }

  private static class Bird extends Animal {

  }

  private static class Dog extends Animal {

  }

  public static void main(String[] args) {
    Animal bird = new Bird();
    System.out.println(bird.getType()); // prints Bird

    Animal dog = new Dog();
    System.out.println(dog.getType()); // prints Dog
  }
}

因此，您将获得正确的类型名，并且不需要在每个派生类型中实现构造函数。延迟绑定将为您解决此问题。

@Leron

以下是一个例子：

class Untitled {
  private static abstract class Animal {
    public String getType() {
      return this.getClass().getSimpleName();
    }
  }

  private static class Bird extends Animal {

  }

  private static class Dog extends Animal {

  }

  public static void main(String[] args) {
    Animal bird = new Bird();
    System.out.println(bird.getType()); // prints Bird

    Animal dog = new Dog();
    System.out.println(dog.getType()); // prints Dog
  }
}

---

因此，您将获得正确的类型名，并且不需要在每个派生类型中实现构造函数。延迟绑定将为您解决此问题。

您不应该；类名是为程序员设计的，而不是为最终用户设计的。无论如何，这个.getClass（）.getName（）。另外，您不应该有一个公共字段——将其设置为私有并在AbstractBird的构造函数中初始化；类名是为程序员设计的，而不是为最终用户设计的。无论如何，这个.getClass（）.getName（）。另外，您不应该有一个公共字段——将其设置为私有并在AbstractBird的构造函数中初始化它。