Java 存储和打印存储在抽象类的子类的对象数组中的值

我还在学java，所以请耐心点

以以前的工作为基础。所以我有一个抽象的股票类，ETF类和股息类都扩展了股票类。ETF和股息高于股票的计算价格。在另一个StockManager类中，我可以输入股票名称、股票价格以及ETF或股息的值。之前，我将这些输入存储到对象数组中

股票[]stk=新股票[股票限额]

既然股票是一个抽象类，我不能再这样做了。如何存储这些值？还是打印出来

此外，在StockManager中，您可以添加、删除、打印或查找库存的总成本

删除了一些不需要的东西 只是需要一些添加，打印和总成本的帮助

股票经理班

public class StockManager
{

   Scanner stdin = new Scanner(System.in);

   final int STOCKLIMIT = 6;
   int numberOfStocks = 0;

   Stock[] stk = new Stock[STOCKLIMIT]; //before stock was abstract

   String name;
   Double namePrice;
   int etfDividendVal;


   public void run()
   {
      String command = stdin.next();

      while (!command.equalsIgnoreCase("Q"))
      {
         if (command.equalsIgnoreCase("A"))
         {

            else
            {
               String commandTwo = stdin.next(); //either e for etf or d for dividend

               if (commandTwo.equalsIgnoreCase("E"))
               {
                  name = stdin.next();
                  namePrice = stdin.nextDouble();
                  etfDividendVal = stdin.nextInt();

                  //stk[numberOfStocks] = new Stock(name, namePrice); //object array when stock wasn't abstract

                  //store name, namePrice, and etfDividendVal somewhere now that stock is abstract

                  numberOfStocks++;
               }

               else if (commandTwo.equalsIgnoreCase("D"))
               {
                  name = stdin.next();
                  namePrice = stdin.nextDouble();
                  etfDividendVal = stdin.nextInt();

                  //stk[numberOfStocks] = new Stock(name, namePrice);

                  //where to store name, namePrice, and etfDividendVal somewhere now that stock is abstract

                  Stock stk = new Dividend();
                  numberOfStocks++;
               }
               }
            }
         }


         else if (command.equalsIgnoreCase("R")) //remove a stock
         {
            else
            {
               name = stdin.next();
               namePrice = stdin.nextDouble();

               for (int i = 0; i < numberOfStocks; i++)
               {
                  if (stk[i].getTicker().equals(name))
                  {
                     for(int z = i; z < numberOfStocks; z++)
                     {
                        if (z + 1 == numberOfStocks)
                           stk[z] = null;
                        else
                           stk[z] = stk[z+1];
                     }  
                     numberOfStocks--;
                  }
               }
            }
         }

         else if (command.equalsIgnoreCase("P"))
         {
            else
            {
               // print stock name, price, and etf/divident value
               }
            }
         }

         else if (command.equalsIgnoreCase("C"))
         {
            else
            {
               //print the total cost
            }
         }
      }
   } 
}

ETF类

public class ETF extends Stock
{
   public float numberOfStocks;

   @Override
   public double calculatePrice()
   {
      return (price * numberOfStocks);
   }
}

股息类别

public class Dividend extends Stock
{
   public float yieldPercentage;

   @Override
   public double calculatePrice()
   {
      return (price * yieldPercentage);
   }
}

应该是这样的

Pick an option:  A-Add R-Remove   P-Print    C-Total cost     Q-Quit
A
E
AMD
30.45
10
Pick an option:  A-Add R-Remove   P-Print    C-Total cost     Q-Quit
A
D
FXAIX
100
3
Pick an option:  A-Add R-Remove   P-Print    C-Total cost     Q-Quit
P
AMD 30.45 10.0
FXAIX 100.0 0.03
Pick an option:  A-Add R-Remove   P-Print    C-Total cost     Q-Quit
C
The total cost is: 307.4999999329448

---

您仍然可以创建一个数组

Stock[]

，因为

ETF

和

divident

都扩展

Stock

，所以可以将它们添加到数组中。要在从数组中检索的对象上使用

ETF

和

divident

中声明的方法，必须强制转换它们，如下所示：

ETF ETF=（ETF）stk[someIndexHere]。请注意，您不知道哪些对象实际上是
ETF
，哪些对象实际上是
股息
，如果您将它们转换为实际不是的类型，您将得到一个错误。您可以使用
instanceof
操作符检查
stk
中的对象是否为
ETF
或
divident
：

Stock stock = stk[0]; // Provided that there is a Stock at stk[0]

if (stock instanceof ETF) {
    ETF etf = (ETF) stock;
    // Now you can use etf as an ETF object
} else if (stock instanceof Dividend) {
    // The second if-statement is redundant since there are only
    // two possibilities, but in the future there might be more
    // classes extending Stock
    Dividend div = (Dividend) stock;
    // Now you can use div as a Dividend object
}

尽管
ETF
和
redivation
都没有实现任何新方法，但不需要强制转换<代码>实例，除非你想告诉你的用户他们正在处理哪种股票。
你有实际问题吗？“既然股票是一个抽象类，我不能再这样做了。”事实上，你可以。就像以前一样。任何变量或数组都可以具有抽象类型；数组元素必须是一个具体的类<代码>库存[]stk=新库存[库存限额]

是完全合法的，您可以在该数组中存储

ETF

和

Distribution

的实例，因为ETF的实例是由于继承而产生的股票实例。股息也是一样。因为我仍然可以创建一个数组Stock[]，所以我是否可以像以前一样使用相同的方法在其中存储输入？是的，您仍然可以使用它来存储输入。但是如果你的意思是使用与使用相同的股票创建相同的输入，那么不，你将要创建一个ETF或股息对象而不是股票对象，但你仍然可以将它们存储在数组中。在我底部的示例输入中，我将存储AMD作为名称，30.45作为价格，10作为ETF值是的，你可以使用相同的设定者和获取者，就像ETF和股息从股票中继承他们和他们的行为一样。是的，谢谢。我已经毫无问题地写出了代码。

Stock stock = stk[0]; // Provided that there is a Stock at stk[0]

if (stock instanceof ETF) {
    ETF etf = (ETF) stock;
    // Now you can use etf as an ETF object
} else if (stock instanceof Dividend) {
    // The second if-statement is redundant since there are only
    // two possibilities, but in the future there might be more
    // classes extending Stock
    Dividend div = (Dividend) stock;
    // Now you can use div as a Dividend object
}