Java：如何创建10只猫？当Cat（“Cat”i）=；猫名；不象在其他语言中那样工作

使用循环，我可以创建

My cat is: Cat1
...
My cat is: Cat1

然而，当我尝试使用

  Cat ("cat"+i) = new Cat("Cat" + i);

我在犯错误

那么，最简单的方法是什么来纠正我的代码以产生错误呢

cat1 ... cat10 cat instances?


public class TestCat{ 
  public static void main(String [] args){ 

 for (int i=1; i<10; i++){     
   //Cat ("cat"+i) = new Cat("Cat 1");
   Cat cat1 = new Cat("Cat 1");  
   System.out.println("My cat is:  " + cat1 ); 
  }
 } 
} 

class Cat{

 static String catName;
 public Cat(String catName){
   this.catName=catName;
 }
 public String toString(){
   return catName;
}
}

cat1。。。cat10 cat实例？
公共类TestCat{
公共静态void main（字符串[]args）{
对于（int i=1；i您正在硬编码cat编号：

Cat cat1 = new Cat("Cat 1"); 

您应该将其更改为：

Cat cat1 = new Cat("Cat " + i); 

对吗？
您需要一个数组

  String[] cats = new String[10];

  for(int i = 0; i < cats.length; i++){
     cats[i] = "Cat" + i;
  }

String[]cats=新字符串[10]；
对于（int i=0；i

这将创建并存储10只猫

那么，打印与此类似：

  for(int i = 0; i < cats.length; i++){
     System.out.println("My cat is " + cats[i]);
  }

for（int i=0；i
对于（int i=1；i您可以执行以下操作：

for (int i=1; i<10; i++){
        Cat cat = new Cat("Cat"+i);
        System.out.println("My cat is:  " + cat );
}

for（int i=1；i上面有很多答案，所以我只想补充一点，您不能在Java中动态更改变量名，因此下面粗体的部分是否定的：

Cat（“Cat”+i）=新的Cat（“Cat 1”）；
公共类TestCat
{ 
公共静态void main（字符串[]args）
{ 
猫[]猫=新猫[10]；
对于（int i=1；i这看起来像是一个学术问题，因此我将这样处理。您需要在某个位置存储十只猫。您可以在一个数组中执行此操作

public class TestCat{ 
  public static void main(String [] args){ 

    Cat[] cats = new Cat[10];

    // Create my cats
    for (int i= 0; i < 10; i++) {     
      cats[i] = new Cat("Cat " + i + 1);  
    }

    // Print them out
    for (Cat aCat : cats) {
      System.out.printLn("My Cat is: " + aCat);
    }
  } 
} 

公共类TestCat{
公共静态void main（字符串[]args）{
猫[]猫=新猫[10]；
//创造我的猫
对于（int i=0；i<10；i++）{
猫[i]=新猫（“猫”+i+1）；
}
//打印出来
适用于（Cat aCat:Cat）{
System.out.printLn（“我的猫是：”+aCat）；
}
} 
} 
Java不支持动态命名变量，因此您无法通过“cat10”创建“cat1”：

（顺便问一句，你来自哪种语言？）

Java的方法是创建一个数组（如其他人所建议的）。如果不知道需要多少实例，可以动态调整数组大小：

public class TestCat
{
    static class Cat
    {
        private String name;

        Cat(String name)
        {
            this.name = name;
        }

        @Override
        public String toString()
        {
            return "Cat{" +
                    "name='" + name + '\'' +
                    '}';
        }
    }
    public static void main(String[] args)
    {
        Cat[] someCats = createCats(10);
        printCats(someCats);

        Cat[] lotsaCats = createCats(42);
        printCats(lotsaCats);
    }

    private static void printCats(Cat[] cats)
    {
        // Print them out
        for (Cat aCat : cats)
        {
            System.out.println("My Cat is: " + aCat);
        }
    }

    private static Cat[] createCats(int ncats)
    {
        Cat[] cats = new Cat[ncats];

        // Create my cats
        for (int i = 0; i < ncats; i++)
        {
            cats[i] = new Cat("Cat " + i + 1);
        }
        return cats;
    }
} 

公共类TestCat
{
静态类猫
{
私有字符串名称；
Cat（字符串名称）
{
this.name=名称；
}
@凌驾
公共字符串toString（）
{
返回“Cat{”+
“name=”+name+“\”+
'}';
}
}
公共静态void main（字符串[]args）
{
Cat[]someCats=createCats（10）；
印刷猫（一些猫）；
Cat[]lotsaCats=createCats（42）；
印刷猫（lotsaCats）；
}
专用静态无效打印猫（猫[]猫）
{
//打印出来
适用于（Cat aCat:Cat）
{
System.out.println（“我的猫是：”+aCat）；
}
}
专用静态Cat[]createCats（int NCAT）
{
Cat[]猫=新猫[NCAT]；
//创造我的猫
对于（int i=0；i

您也可以使用列表而不是数组。
如果您不知道将有多少只猫，请使用集合

  String[] cats = new String[10];

  for(int i = 0; i < cats.length; i++){
     cats[i] = "Cat" + i;
  }

public class TestCat
{ 
  public static void main(String [] args)
  { 

    Cat[] cats = new Cat[10];    
    Vector catsUnlimited = new Vector(10);    
    Cat myCat = null;

    for (int i=1; i<11; i++)
    {     
    myCat = new Cat("Cat" + i); 
      cats[i-1]= myCat; 

      catsUnlimited.addElement(new Cat("Cat" + i));

      System.out.println("My cat is:  " + cats[i-1] ); 
    }

    System.out.println("Known cats");
    for (int x = 0; x < catsUnlimited.size(); x++)
    {        
     System.out.println("Cat #" + (x+1) + ":" +(Cat)catsUnlimited.get(x));
    }    
  } 
} 

罪魁祸首是：

public class Cat
{
     static String catName;

移除
静态
，你就是金色的。
你可以创建n猫的数量：

代码：

public class TestCat
{

  public static void main(String [] args) throws IOException
  {  
      int x=0; 
      DataInputStream in=new DataInputStream(System.in);
      x=Integer.parseInt(in.readLine());
      Cat[] cats = new Cat[x];
      for (int i=1; i<x; i++)
      {     
          cats[i-1]= new Cat("Cat" + i);       
          System.out.println("My cat is:  " + cats[i-1] ); 
      }
   }
}

公共类TestCat
{
公共静态void main（字符串[]args）引发IOException
{  
int x=0；
DataInputStream in=新的DataInputStream（System.in）；
x=Integer.parseInt（in.readLine（））；
猫[]猫=新猫[x]；
for（int i=1；inice！谢谢！如果我们不知道需要创建多少个Cat，那该怎么办…但我们至少知道一个？Cat（“Cat”+i）=新Cat（…）是不可能的，因为Java不支持动态命名变量。这就是为什么其他人建议使用数组的原因。我个人会使用一个列表。谢谢你建议另一个路径！
My cat is:  Cat1
My cat is:  Cat2
My cat is:  Cat3
My cat is:  Cat4
My cat is:  Cat5
My cat is:  Cat6
My cat is:  Cat7
My cat is:  Cat8
My cat is:  Cat9
My cat is:  Cat10
Known cats
Cat #1:Cat10
Cat #2:Cat10
Cat #3:Cat10
Cat #4:Cat10
Cat #5:Cat10
Cat #6:Cat10
Cat #7:Cat10
Cat #8:Cat10
Cat #9:Cat10
Cat #10:Cat10

public class Cat
{
     static String catName;

public class TestCat
{

  public static void main(String [] args) throws IOException
  {  
      int x=0; 
      DataInputStream in=new DataInputStream(System.in);
      x=Integer.parseInt(in.readLine());
      Cat[] cats = new Cat[x];
      for (int i=1; i<x; i++)
      {     
          cats[i-1]= new Cat("Cat" + i);       
          System.out.println("My cat is:  " + cats[i-1] ); 
      }
   }
}