Java I'；我正在制作一个24小时时钟

我在做一个24点钟。我有下面的代码。我的问题是

int[]

时间等于

[0,0,0]

，并在每次迭代中打印出来
一些可能对你有帮助的更多信息。我将

数组计时器

设置为

[小时、分钟、秒]

。重置方法将选定的int值设置为零、保持不变或增加一。嵌套的while循环用于遍历时钟

public static int hours;
public static int minutes;
public static int seconds;
public static int [] TimeCounter = {hours, minutes, seconds};

//End of day
public static void reset(int [] midNight){
    hours = 0;
    minutes = 0;
    seconds = 0;
}

//End of a minute
public static void resetSeconds(int [] endOfMin){
    minutes++;
    seconds = 0;
}

//End of a Hour
public static void resetMinutes(int [] endOfHour){
    hours++;
    minutes = 0;
    seconds = 0;
}
public static void run(int [] time){
    hours = 0;
    minutes = 0;
    seconds = 0;
    System.out.println(Arrays.toString(time));
    while (hours < 25){
        if (hours == 24){
            if (minutes == 59){
                if (seconds == 60){
                    reset(time);
                }
            }
        }
        while (minutes < 61){
            if (minutes == 59){
                if (seconds == 60){
                    resetMinutes(time);
                    System.out.println(Arrays.toString(time));
                }
            }
            while (seconds < 61){
                if (seconds == 60){
                    resetSeconds(time);
                }
                System.out.println(Arrays.toString(time));
                seconds++;

            }
            System.out.println(Arrays.toString(time));
            minutes++;
        }
        System.out.println(Arrays.toString(time));
        hours++;
    }

}

public static void main(String[] args){

    run(TimeCounter);
}

公共静态整数小时；
公众静态int分钟；
公共静态整数秒；
公共静态int[]计时器={小时，分钟，秒}；
//一天结束
公共静态无效重置（整数[]午夜）{
小时=0；
分钟=0；
秒=0；
}
//一分钟结束
公共静态无效重置秒数（int[]endOfMin）{
分钟++；
秒=0；
}
//一小时后
公共静态无效重置分钟数（int[]endOfHour）{
小时++；
分钟=0；
秒=0；
}
公共静态无效运行（int[]时间）{
小时=0；
分钟=0；
秒=0；
System.out.println（Arrays.toString（time））；
而（小时<25）{
如果（小时==24）{
如果（分钟==59）{
如果（秒==60）{
重置（时间）；
}
}
}
而（分钟<61）{
如果（分钟==59）{
如果（秒==60）{
重置分钟（时间）；
System.out.println（Arrays.toString（time））；
}
}
同时（秒<61）{
如果（秒==60）{
重置秒（时间）；
}
System.out.println（Arrays.toString（time））；
秒++；
}
System.out.println（Arrays.toString（time））；
分钟++；
}
System.out.println（Arrays.toString（time））；
小时++；
}
}
公共静态void main（字符串[]args）{
运行（计时器）；
}

数组中的整数与变量中的整数不同。是的，您可以使用变量初始化数组，但是在初始化之后，数组int项将独立运行。如果要增加数组中的int项，必须直接执行：

myArray[someIndex]++

顺便说一句，根据我的评论，你不允许在这个程序中使用面向对象的概念吗？说明是否强制您对所有内容都使用静态？我问这个问题的原因是，一个更好的程序不会像您现在这样使用数组，而是会有用于秒、分钟和小时的int字段，并且会封装用于将秒滚动到分钟到小时的逻辑。这将更易于维护和增强

---

编辑
例如：

public class FooClock {
   public static final int SECONDS_PER_MINUTE = 60;
   public static final int MINUTES_PER_HOUR = 60;
   private static final int NOON = 12;
   private int hours;
   private int minutes;
   private int seconds;
   private boolean am = true;
   private String formatString = "%02d:%02d:%02d %s";

   public FooClock(int hours, int minutes, int seconds, boolean am) {
      this.hours = hours;
      this.minutes = minutes;
      this.seconds = seconds;
      this.am = am;
   }

   public void incrementSeconds() {
      seconds++;
      normalize();
   }

   public void incrementMinutes() {
      minutes++;
      normalize();
   }

   public void incrementHours() {
      hours++;
   }

   public void normalize() {
      if (seconds >= SECONDS_PER_MINUTE) {
         minutes += seconds / SECONDS_PER_MINUTE;
         seconds %= SECONDS_PER_MINUTE;
      }
      if (minutes >= MINUTES_PER_HOUR) {
         hours += minutes / MINUTES_PER_HOUR;
         minutes %= MINUTES_PER_HOUR;
      }
      if (hours >= 2 * NOON) {
         hours %= (2 * NOON);
         am = true;
      }
      if (hours >= NOON) {
         am = false;
      }
   }

   @Override
   public String toString() {
      String amString = am ? "AM" : "PM";
      return String.format(formatString, hours, minutes, seconds, amString);
   }

   public static void main(String[] args) {
      int total_seconds = 24 * SECONDS_PER_MINUTE * MINUTES_PER_HOUR;

      FooClock fooClock = new FooClock(0, 0, 0, true);
      System.out.println(fooClock);
      for (int i = 0; i < total_seconds; i++) {
         fooClock.incrementSeconds();
         System.out.println(fooClock + " ");
      }
   }
}

公共类foock{
公共静态最终整数秒每分钟=60；
公共静态最终整数分钟/小时=60；
私人静态最终整数中午=12；
私人整数小时；
私人整数分钟；
私人整数秒；
私有布尔值am=true；
私有字符串formatString=“%02d:%02d:%02d%s”；
公共时钟（整数小时、整数分钟、整数秒、布尔am）{
这个.小时=小时；
这个。分钟=分钟；
这个。秒=秒；
this.am=am；
}
public void incrementSeconds（）{
秒++；
规范化（）；
}
public void incrementMinutes（）{
分钟++；
规范化（）；
}
公共无效增量小时数（）{
小时++；
}
公共空间正常化（）{
如果（秒>=秒/分钟）{
分钟+=秒/秒/分钟；
秒%=每分钟秒数；
}
如果（分钟>=每小时分钟）{
小时+=分钟/分钟/小时；
分钟%=每小时分钟数；
}
如果（小时数>=2*正午）{
小时数%=（2*正午）；
am=真；
}
如果（小时>=中午）{
am=假；
}
}
@凌驾
公共字符串toString（）{
字符串amString=am？“am”：“PM”；
返回String.format（formatString、小时、分钟、秒、amString）；
}
公共静态void main（字符串[]args）{
int total_seconds=24*秒每分钟*分钟每小时；
FooClock FooClock=新的FooClock（0,0,0,true）；
系统输出打印LN（fooClock）；
对于（int i=0；i

数组中的整数与变量中的整数不同。是的，您可以使用变量初始化数组，但是在初始化之后，数组int项将独立运行。如果要增加数组中的int项，必须直接执行：

myArray[someIndex]++

顺便说一句，根据我的评论，你不允许在这个程序中使用面向对象的概念吗？说明是否强制您对所有内容都使用静态？我问这个问题的原因是，一个更好的程序不会像您现在这样使用数组，而是会有用于秒、分钟和小时的int字段，并且会封装用于将秒滚动到分钟到小时的逻辑。这将更易于维护和增强

---

编辑
例如：

public class FooClock {
   public static final int SECONDS_PER_MINUTE = 60;
   public static final int MINUTES_PER_HOUR = 60;
   private static final int NOON = 12;
   private int hours;
   private int minutes;
   private int seconds;
   private boolean am = true;
   private String formatString = "%02d:%02d:%02d %s";

   public FooClock(int hours, int minutes, int seconds, boolean am) {
      this.hours = hours;
      this.minutes = minutes;
      this.seconds = seconds;
      this.am = am;
   }

   public void incrementSeconds() {
      seconds++;
      normalize();
   }

   public void incrementMinutes() {
      minutes++;
      normalize();
   }

   public void incrementHours() {
      hours++;
   }

   public void normalize() {
      if (seconds >= SECONDS_PER_MINUTE) {
         minutes += seconds / SECONDS_PER_MINUTE;
         seconds %= SECONDS_PER_MINUTE;
      }
      if (minutes >= MINUTES_PER_HOUR) {
         hours += minutes / MINUTES_PER_HOUR;
         minutes %= MINUTES_PER_HOUR;
      }
      if (hours >= 2 * NOON) {
         hours %= (2 * NOON);
         am = true;
      }
      if (hours >= NOON) {
         am = false;
      }
   }

   @Override
   public String toString() {
      String amString = am ? "AM" : "PM";
      return String.format(formatString, hours, minutes, seconds, amString);
   }

   public static void main(String[] args) {
      int total_seconds = 24 * SECONDS_PER_MINUTE * MINUTES_PER_HOUR;

      FooClock fooClock = new FooClock(0, 0, 0, true);
      System.out.println(fooClock);
      for (int i = 0; i < total_seconds; i++) {
         fooClock.incrementSeconds();
         System.out.println(fooClock + " ");
      }
   }
}

公共类foock{
公共静态最终整数秒每分钟=60；
公共静态最终整数分钟/小时=60；
私人静态最终整数中午=12；
私人整数小时；
私人整数分钟；
私人整数秒；
私有布尔值am=true；
私有字符串formatString=“%02d:%02d:%02d%s”；
公共时钟（整数小时、整数分钟、整数秒、布尔am）{
这个.小时=小时；
这个。分钟=分钟；
这个。秒=秒；
this.am=am；
}
public void incrementSeconds（）{
秒++；
规范化（）；
}
public void incrementMinutes（）{
分钟++；
规范化（）；
}
公共无效增量小时数（）{
小时++；
}
普布利