Java 我如何组合两种做相同事情但类型不同的方法？

我对java编程相当陌生，虽然我知道一些基本知识，但我觉得我的代码很长，没有必要。我想知道是否有办法将我的

elkStarter（）

和

foxStarter（）

方法组合成一个

starter（）

方法，这样我就可以减少代码

//Opening question, askes user to pick either an elk or fox
    public void systemStart(){
        for(int i =0;i<=100;i++){
           System.out.println("- - - - - - - - - - - - - - - - - -\n");
    }
    System.out.println("***STARTING NEW MOVEMENT MODEL***\n"+"-----------------------------------\n");
    iteration = 0;
    String animalType = JOptionPane.showInputDialog
                     ("Would you like an elk or a fox?");

    switch (animalType.toLowerCase()){
        case "elk": elkStarter("elk_1");
        break;
        case "fox": Foxtarter("fox_1"); 
        break;
        default: JOptionPane.showMessageDialog (null, "You didn't enter elk or fox..Please try again.");
        runAnotherModel();
        break;
    }
}

//systemStater goes to when "elk" is selected as the animal type.
public void elkStarter(){
    Elk elk_1 = new Elk();
    elk_1.namer("elk_1");
    System.out.println("You have just created an Elk called " + elk_1.name + ".\n" +
    "It has begun its life at (0,-0).");        
    elk_1.findPosition();

    JOptionPane.showMessageDialog (null, "Lets let our new elk roam a bit, shall we?");


    int loop = 0;                 
    while(loop==0){
        String animalDirection = JOptionPane.showInputDialog
                     ("Which way should our elk move? (forward(f), backward(b), up(u), down(d)) or type stop(s) to quit.");
        switch(animalDirection.toLowerCase()){
            case "forward": case "f":
            elk_1.walkForward();
            elk_1.findPosition();
            break;
            case "backward": case "b":
            elk_1.walkBackward();
            elk_1.findPosition();
            break;
            case "up": case "u":
            elk_1.walkUp();   
            elk_1.findPosition();
            break;
            case "down": case "d":
            elk_1.walkDown();
            elk_1.findPosition();
            break;
            case "stop": case "s":
            JOptionPane.showMessageDialog (null, "GoodBye! Thanks for trying my model!");
            loop=1;
            break;
            default: JOptionPane.showMessageDialog (null, "ummmm sorry that wasn't a direction...Please try again.");
            break;
        }
    }
}

//systemStater goes to when "fox" is selected as the animal type.
public void foxStarter(){
    Fox fox_1 = new Fox();
    fox_1.namer("fox_1");
    System.out.println("You have just created an Fox called " + fox_1.name + ".\n" +
    "It has begun its life at (0,-0).");        
    fox_1.findPosition();

    JOptionPane.showMessageDialog (null, "Lets let our new fox roam a bit, shall we?");


    int loop = 0;                 
    while(loop==0){
        String animalDirection = JOptionPane.showInputDialog
                     ("Which way should our fox move? (forward(f), backward(b), up(u), down(d)) or type stop(s) to quit.");
        switch(animalDirection.toLowerCase()){
            case "forward": case "f":
            fox_1.walkForward();
            fox_1.findPosition();
            break;
            case "backward": case "b":
            fox_1.walkBackward();
            fox_1.findPosition();
            break;
            case "up": case "u":
            fox_1.walkUp();   
            fox_1.findPosition();
            break;
            case "down": case "d":
            fox_1.walkDown();
            fox_1.findPosition();
            break;
            case "stop": case "s":
            JOptionPane.showMessageDialog (null, "GoodBye! Thanks for trying my model!");
            loop=1;
            break;
            default: JOptionPane.showMessageDialog (null, "ummmm sorry that wasn't a direction...Please try again.");
            break;
        }
    }
}

//开始问题，让用户选择麋鹿或狐狸
public void systemStart（）{
对于（int i=0；i而言，最好的方法是创建一个父类/接口，然后使用定义对象是狮子还是麋鹿的布尔值调用该函数。这称为类层次结构

所以你只需要替换代码的一部分

Animal somename;
if (isElk)
   somename = new Elk();
else
   somename = new Fox();

其中，isElk是一个布尔值，如果用户想要创建一个新的Elk对象，则为true；如果用户想要创建一个新的Fox对象，则为false。
您可以创建一个界面，并根据用户输入调用所需的实现

比如：

public interface Starter {
    void start();
}

public class ElkStarter implements Starter {

    private String name;
    // + constructor, getters, setters

    @Override
    public void start() {
        // ...
    }
}

// ...

public Starter getStarter(String animalType) {
    switch (animalType.toLowerCase()) {
      case "elk": return new ElkStart("elk_1");
      case "fox": return new FoxStart("fox_1");
      default: return null;
    }
}

public void systemStart() {
    // ...
    Starter starter = getStarter(animalType);
    // at this point, you do not know what Starter actually is
    if(starter != null) {
        starter.start();
    } else {
        // ...
    }
}

如果类
Elk
和
Fox
具有相同的父类，例如-
Animal
，那么我相信有多种方法可以使两个启动功能成为一个单一的

例如，您可以让start函数的调用者发送要处理的对象-

public void commonStarter(Animal animal) {
    ... // Do your logic on animal.
}


或者，您可以向
starter
函数发送一个参数，该参数将确定是创建
Elk
还是
Fox
，然后在此基础上，在类中创建正确的参数-

public void commonStarter(boolean isElk) {
    Animal animal = None;
    if(isElk) {
        animal = new Elk();
    } else {
        animal = new Fox();
    }
    ... // Do your logic.
}


但是这如何帮助缩短我的代码呢？我的elk和fox不需要只有一个方法，而需要有两个独立的方法吗？如果它们有一些共同的部分，你也可以使用一个包含共同代码的抽象类。第二个选项非常有效！除了我必须在elk（）和fox（）前面加上“new”之外当设置动物与它们相等时。是的，对不起，忘了：），修正了答案，谢谢。我相信问题的主要问题仍然没有解决。对不起，你为什么这么认为？