Java中“独特”对象的列表

时间：2019-02-09 16:24:23

标签： java object unique

我正在和同学一起做学校作业。我们正在制作出租车应用程序，您可以在其中启动和停止出租车，询问当前价格，并在出租车停止时获得总价。目前，它工作正常。但是，例如，如果我们先启动出租车1，然后再启动出租车2，则会出现问题。即使我们从中获得唯一的对象，出租车1的开始和结束时间也会被新对象（出租车2）的开始和结束时间覆盖。和arraylist基于我在系统中键入的用户号码。

Main.java中的代码：

import java.text.DecimalFormat;
import java.util.Scanner;

public class Main {

    public static void main(String[] args) {
        Taxi taxi = new Taxi();
        System.out.println("Hej og velkommen til Damn Fast Taxis.");
        boolean isEnd = false;
        DecimalFormat decimalFormat = new DecimalFormat("#.0");
        while(!isEnd) {

            Taxi chosenTaxi;

            System.out.println("1. Start en taxi.");
            System.out.println("2. Stop en taxi.");
            System.out.println("3. Pause en taxi.");
            System.out.println("4. Spørg efter pris.");
            System.out.println("5. Gratis tur.");
            System.out.println("6. Tilføj antal taxier.");

            Scanner sc = new Scanner(System.in);
            String choice = sc.nextLine();

            switch (choice) {
                case "1":
                    if (taxi.getTaxiListPrint().size()>=1) {

                        Scanner startTaxiNumber = new Scanner(System.in);
                        int numberChoice = startTaxiNumber.nextInt();
                        chosenTaxi = taxi.chooseTaxi(numberChoice);

                        chosenTaxi.setStartTime();
                        break;
                    } else {
                        System.out.println("Ingen taxier er oprettet i systemet.");
                        break;
                    }

                case "2":

                    if (taxi.getTaxiListPrint().size()>=1) {
                        Scanner endTaxiNumber = new Scanner(System.in);
                        int numberChoice = endTaxiNumber.nextInt();
                        chosenTaxi = taxi.chooseTaxi(numberChoice);

                        chosenTaxi.setEndTime();

                        if (!chosenTaxi.isStopped()) {
                            System.out.println("Turen varede " + decimalFormat.format(((chosenTaxi.getEndTime() - chosenTaxi.getStartTime()) / 100)*0.1) + " sekunder.");
                            Price price = new Price();
                            String finalPrice = price.calculatePrice(chosenTaxi.getStartTime(), chosenTaxi.getEndTime(), decimalFormat);
                            System.out.println("Pris: " + finalPrice + " dollars.");
                            chosenTaxi.setStopped(true);
                        } else {
                            System.out.println("Denne taxi er allerede blevet stoppet.");
                        }
                        break;
                    } else {
                        System.out.println("Ingen taxier er oprettet i systemet.");
                    }
                case "3":
                    break;
                case "4":

                    if (taxi.getTaxiList().size()>=1) {
                        Scanner currentPriceTaxiNumber = new Scanner(System.in);
                        int numberChoice = currentPriceTaxiNumber.nextInt();
                        Taxi currentChosenTaxi = taxi.chooseTaxi(numberChoice);

                        currentChosenTaxi.setEndTime();
                        if (!currentChosenTaxi.isStopped()) {
                            Price priceNow = new Price();
                            String currentPrice = priceNow.calculatePrice(currentChosenTaxi.getStartTime(), currentChosenTaxi.getEndTime(), decimalFormat);
                            System.out.println("Pris: " + currentPrice + " dollars.");
                        } else {
                            System.out.println("Denne taxi er allerede blevet stoppet.");
                        }
                        break;
                    } else {
                        System.out.println("Ingen taxier er oprettet i systemet.");
                        break;
                    }

                case "5":

                    break;
                case "6":
                    System.out.println("Hvor mange taxier vil du tilføje?");
                    Scanner taxaNumber = new Scanner(System.in);
                    int number = taxaNumber.nextInt();
                    for (int i = 0; i<number;i++) {
                        taxi.addTaxi(taxi);
                    }
                    System.out.println(number + " " + "Taxa'er tilføjet!");
                    break;
                default:
                    isEnd = true;

     break;

出租车课：

import java.util.ArrayList;
import java.util.List;

public class Taxi {

    private long startTime;
    private long endTime;
    private boolean isStopped = false;
    private List<Taxi> taxiList = new ArrayList<>();

    public void addTaxi(Taxi taxi) {
        taxiList.add(taxi);
    }

    public Taxi chooseTaxi(int choice) {
        return taxiList.get(choice - 1);
    }

    public List<Taxi> getTaxiListPrint() {

        for(int i = 1; i<taxiList.size() + 1;i++) {
            System.out.println("Taxi: " + i);
        }
        return taxiList;
    }

    public List<Taxi> getTaxiList() {
        return taxiList;
    }

    public long getStartTime() {
        return startTime;
    }

    public long getEndTime() {
        return endTime;
    }

    public boolean isStopped() {
        return isStopped;
    }

    public void setStartTime() {
        this.startTime = System.currentTimeMillis();
    }

    public void setEndTime() {
        this.endTime = System.currentTimeMillis();
    }

    public void setStopped(boolean stopped) {
        isStopped = stopped;
    }
}

对不起，如果我的代码混乱，我是该语言的新手。简短的问题是：如何定义不同的对象，以使程序在每次创建新的计程车实例时都不会被覆盖？

非常感谢。 /尼克

2 个答案:

答案 0 :(得分：0)

我认为最简单的更改是将Taxi类中的这些方法更改为静态：

private static List<Taxi> taxiList = new ArrayList<>();

public static void addTaxi(Taxi taxi) {
    taxiList.add(taxi);
}

public static Taxi chooseTaxi(int choice) {
    return taxiList.get(choice - 1);
}

public static List<Taxi> getTaxiListPrint() {

    for (int i = 1; i < taxiList.size() + 1; i++) {
        System.out.println("Taxi: " + i);
    }
    return taxiList;
}

public static List<Taxi> getTaxiList() {
    return taxiList;
}

将这些方法更改为静态形式，例如：

Taxi currentChosenTaxi = taxi.chooseTaxi(numberChoice);

更改为

Taxi currentChosenTaxi = Taxi.chooseTaxi(numberChoice);

然后向经理添加其他出租车：

            case "6":
                System.out.println("Hvor mange taxier vil du tilføje?");
                Scanner taxaNumber = new Scanner(System.in);
                int number = taxaNumber.nextInt();
                for (int i = 0; i < number; i++) {
                    Taxi.addTaxi(new Taxi());
                }
                System.out.println(number + " " + "Taxa'er tilføjet!");
                break;
  

注意：您不需要每次都制作new Scanner(System.in)，如果放在循环之外就可以使用一个。

答案 1 :(得分：0)

仅包括组成您的班级Taxi的属性

正如评论所说，在您的taxiList类中拥有Taxi并不是一个好主意。您的Taxi类应仅包含构成 Taxi 的必要属性。更好的结构看起来像这样

public class Taxi {
    private long startTime;
    private long endTime;
    private boolean isStopped = false;

    // Add the necessary getters & setters for the above attributes here
}

通过List或TaxiManager类管理出租车

要持有taxiList，您有2个选择

  1. 在您的Main类中，定义一个List<Taxi> taxiList = new ArrayList<>()
  2. 创建一个单独的类来保存 list 和控制其项的逻辑。例如TaxiManager

如果在 Taxi 上可能执行的操作较少，则第一个选项是一个不错的选择。如果要从Main类抽象出租车管理逻辑，则第二选项更好。看起来像这样

public class TaxiManager {
    private List<Taxi> taxiList;
    public class TaxiManager() { taxiList = new ArrayList<>(); }

    // Here are some "management" methods you can use
    // DON'T FORGET TO HANDLE EXCEPTIONS (for example ArrayOutOfBounds, ...)

    public void addTaxi(Taxi newTaxi) { taxiList.add(newTaxi); }
    public Taxi getTaxiAtIndex(int index) { return taxiList.get(index); }
    public void stopTaxiAtIndex(int index) { taxiList.get(index).stop(); }

    // Add the necessary operations here
}

如何在您的Main类中使用它

创建一个新的TaxiManager并根据您选择的逻辑（switch case）调用您的方法

public class Main {
    public static void main(String[] args) {
        TaxiManager taxiManager = new TaxiManager();

        Scanner sc = new Scanner(System.in);
        String choice = sc.nextLine();

        switch (choice) {
            case "add": {
                taxiManager.addTaxi(new Taxi());
                break;
            }
            // Include other options
        }
    }
}

回答“唯一对象”的问题=>使用Singleton

  

确保一个类只有一个实例，并提供对其的全局访问点

如果您想从不同的“类”调用TaxiManager，并且仍然保留该经理的唯一性，那么这可能是您的TaxiManager的不错选择。然后，您可以放心，您的出租车不会重复。 如果您想这样，您的public class TaxiManager { private List<Taxi> taxiList; private TaxiManager() {} private static class SingletonHolder { private static final TaxiManager INSTANCE = new TaxiManager(); } public static TaxiManager getInstance() { return SingletonHolder.INSTANCE; } // Add other methods here } 看起来会像这样

Main

要在您的TaxiManager taxiManager = TaxiManager.getInstance(); 类中调用它，请使用此

%%shell
相关问题
最新问题