For loop 用于返回范围的循环

我的BlueJ项目分为两类：州、省和国家。下面是我所在的州一级，然后是乡村一级。我一直在使用一种方法：“public int howmanyhavethispowlation（int min，int max）”，它以百万为单位计算人口（例如4，6），并返回人口在该范围内的州省份数量（例如400-600万）。我无法设置它并返回正确答案。我想知道我该怎么做。就我现在的方法而言，错误消息是我缺少一个return语句。我知道我的方法不对。我在下面列出了我的课程以及我在该方法上的进展：

public class StateProvince
{
private String name; //e.g. "British Columbia" or "California"
private String capital; //e.g. "Victoria or "Sacramento"
private int populationInMillions; //e.g. 4 or 38
private final static int DEFAULT_POPULATION_MILLIONS = 4;
private final static String DEFAULT_STATE_PROVINCE = "British Columbia";
private final static String DEFAULT_CAPITAL = "Victoria";

public StateProvince()
{
}

/**
* constructor that takes in all 3 parameters and assigns them if they follow              the rules:
* name: must be one of the 50 Unites States or 10 Canadian Provinces
* capital: must be the name of the capital city
* populationInMillions: must be between 0 and 38
*/

public StateProvince(String name, String capital, int populationInMillions)
{
if(isValidPopulation(populationInMillions) &&                            (isValidStateProvince(name) &&
       (isValidCapitalCity(capital))))
     {
          this.populationInMillions = populationInMillions;
          this.name = name;
          this.capital = capital;

     }else
     {
         this.populationInMillions = DEFAULT_POPULATION_MILLIONS; //
         this.name                 = DEFAULT_STATE_PROVINCE; //"British                   Columbia"
         this.capital              = DEFAULT_CAPITAL; //"Victoria"
     }
     }

     //StateProvince p1 = new StateProvince("British Columbia", "Victoria", 5);

   private boolean isValidStateProvince(String name)
   {
   String[] provinces = new String[10];
   provinces[0] = "British Columbia";
   provinces[1] = "Alberta";
   provinces[2] = "Saskatchewan";
   provinces[3] = "Manitoba";
   provinces[4] = "Ontario";
   provinces[5] = "Quebec";
   provinces[6] = "PEI";
   provinces[7] = "Newfoundland";
   provinces[8] = "New Brunswick";
   provinces[9] = "Nova Scotia";


   for(int index = 0; index < provinces.length; index++)
   {
      if(provinces[index].equalsIgnoreCase(name))
      {
          return true;
      }
      index++;
   }
   return false;           
   }

   private boolean isValidCapitalCity(String capital)
   {
   String[] capitals = new String[10];
   capitals[0] = "Victoria";
   capitals[1] = "Edmonton";
   capitals[2] = "Regina";
   capitals[3] = "Winnipeg";
   capitals[4] = "Toronto";
   capitals[5] = "Quebec City";
   capitals[6] = "Charlottetown";
   capitals[7] = "St. John's";
   capitals[8] = "Fredericton";
   capitals[9] = "Halifax";


   for(int index = 0; index < capitals.length; index++)
   {
      if(capitals[index].equalsIgnoreCase(capital))
      {
          return true;
      }
      index++;
   }
   return false;
   }

   private boolean isValidPopulation(int populationInMillions)
   {
   if(populationInMillions >= 4 || populationInMillions <= 38)
   {
       return true;
   }else
   {
       return false;
   }

   }

   public void setName()
   {
   this.name = name;
   }

   public void setCapital()
   {
   this.capital = capital;
   }

   public String getName()
   {
   return name;
   }

   public String getCapital()
   {
   return capital;
   }

   public int getPopulationInMillions()
   {
   return populationInMillions;
   }

   public String getDetails()
   {
   return ("The capital of " + getName() + " (pop. " + populationInMillions               + " million) is " + getCapital());
   }
   }


public class Country
{
private String country;
private StateProvince[] Canada;

public Country()
{
    Canada = new StateProvince[10];
    Canada[0] = new StateProvince("British Columbia", "Victoria", 4);
    Canada[1] = new StateProvince("Alberta", "Edmonton", 3);
    Canada[2] = new StateProvince("Saskatchewan", "Regina", 1);
    Canada[3] = new StateProvince("Manitoba", "Winnipeg", 1);
    Canada[4] = new StateProvince("Ontario", "Toronto", 13);
    Canada[5] = new StateProvince("Quebec", "Quebec City", 8);
    Canada[6] = new StateProvince("PEI", "Charlottetown", 0);
    Canada[7] = new StateProvince("Newfoundland", "St. John's", 0);
    Canada[8] = new StateProvince("New Brunswick", "Fredericton", 1);
    Canada[9] = new StateProvince("Nova Scotia", "Halifax", 1);
}

public void displayAllStates()
{

    for(int index = 0; index < Canada.length; index++)
    {
        if(Canada[0] != null)
        {
            System.out.println(Canada[index].getDetails());
        }
        index++;
    }

}

public void addStateProvince(StateProvince stateProvince)
{
    if(Canada != null)
    {
        for(int i = 0; i < Canada.length; i++)
        {
            if(Canada[i] == null)
            {
                Canada[i] = stateProvince;
                return;
            }
        }

    }
}

public int howManyHaveThisPopulation(int min, int max)
{

    for(int i = 0; i < Canada.length; i++)
    {
        if(i > min && i < max)
        {
            return Canada[i].getPopulationInMillions();
        }

    }
}

StateProvince公共类
{
私有字符串名称；//例如“不列颠哥伦比亚省”或“加利福尼亚州”
私有字符串资本；//例如“维多利亚”或“萨克拉门托”
私有整数人口百万；//例如4或38
私有最终静态整数默认值\u人口\u百万=4；
私有最终静态字符串DEFAULT\u STATE\u PROVINCE=“不列颠哥伦比亚”；
私有最终静态字符串默认值\u CAPITAL=“Victoria”；
公营省（）
{
}
/**
*构造函数，该构造函数接受所有3个参数并在它们遵循规则时分配它们：
*姓名：必须是50个美国或10个加拿大省份之一
*首都：必须是首都的名称
*人口百万：必须介于0和38之间
*/
public StateProvince（字符串名称，字符串大写，整数人口百万）
{
if（isValidPopulation（人口百万）和&（isValidStateProvince（名称）&&
（isValidCapitalCity（资本）））
{
this.populationInMillions=populationInMillions；
this.name=名称；
这个资本=资本；
}否则
{
this.populationInMillions=默认值\u POPULATION\u MILLIONS//
this.name=DEFAULT\u STATE\u PROVINCE；/“不列颠哥伦比亚省”
this.capital=DEFAULT_capital；/“Victoria”
}
}
//州省p1=新州省（“不列颠哥伦比亚省”、“维多利亚省”，5）；
私有布尔值isValidStateProvince（字符串名称）
{
字符串[]省份=新字符串[10]；
省份[0]=“不列颠哥伦比亚省”；
省份[1]=“阿尔伯塔省”；
省份[2]=“萨斯喀彻温省”；
各省[3]=“马尼托巴省”；
省份[4]=“安大略省”；
省[5]=“魁北克”；
省[6]=“裴”；
省[7]=“纽芬兰”；
各省[8]=“新不伦瑞克省”；
省份[9]=“新斯科舍省”；
对于（int index=0；index=4 | |人口数百万最小值和&i<最大值）
{
返回加拿大[i].getPopulationInMillions（）；
}
}
}