JAVA：如何在对象的子类中调用方法？

我试图解决这个问题，但实际上我不懂语法。 考虑下面的代码：

class Parent {
   private String productCode1;      // Format X9999
   private String productCode2;

    public Parent(String productCode1, String productCode2)
    {
        this.productCode1= productCode1;
        this.productCode2= productCode2;

    } 

}

然后我有一个子类，它包含我要调用的方法

public Child extends Parent{
    private String[] serialNumbers;

    public Child(String productCode1, String productCode2, String... args){
        super(productCode1,  productCode2,);
        int i = 0;

        for(String serialN: args){
            serialNumbers = new String[10]; 
            serialNumbers[i]= serialN;
            i++;
        }

        public String[] getSerialNumbers(){     //This is the method i want to call
            return this.serialNumbers;
        }
}

这是库存类

public class Inventory{

public ArrayList<Parent> products;

public Inventory(){

    products = new ArrayList<Parent>();  //Some hard coded items
    products.add(new Parent("A0001", "abcdefg"));
    products.add(new Parent("B0010", "abcdefg"));
    products.add(new Parent("C0100", "abcdefg"));
    products.add(new Child("D1000",  "abcdefg", "firstSN", "secondSN", "thirdSN"));
}

public static ProductLine getProduct(ArrayList<Parent> products, String productCode){

    for(int i = 0; i < products.size(); i++){
         ProductLine product = products.get(i);
         if(product.getProductCode().equals(productCode)){
             return product;  
         }
    }

    return null;

}

我试着像：

String[] serNumb = ((ItemisedProductLine)pFound).getSerialNumbers();

它可以编译，但他（如预期的）在运行时给我一个“不能将父对象强制转换为子对象”

我希望我解释得很好

---

很抱歉问了这么长的问题…

为什么父类没有getSerialNumbers方法？我认为您有2种选择：在父类中实现，或者不考虑逻辑中的父类（用实例进行测试）。< /p> 为什么父类没有GETIAL ALILATION方法？我认为您有2种选择：在父类中实现，或者不考虑逻辑中的父类（用实例进行测试）。您不能执行演员阵容，因为

父项

根本不是

子项

您可以使用

instanceof

检查您拥有的对象的类型，然后仅在您拥有

Child

的实例时执行强制转换和调用，但您通常希望避免这样做。这不好啊

您可以做的一件事是将

getSerialNumbers（）

方法放在

Parent

中，并始终返回空数组，然后在

Child

中重写它，以实际返回子

的序列号

当然，这里也值得重新考虑整个类层次结构。所有继承自
父类的类都有序列号有意义吗？如果是这样，您应该考虑将所有的序列号处理移到<代码>父< /代码>。
Parent
的子类会比
Child
的子类更多吗？如果不是的话，也许孩子应该被淘汰。
对。您不能执行演员阵容，因为
父项
根本不是
子项

您可以使用
instanceof
检查您拥有的对象的类型，然后仅在您拥有
Child
的实例时执行强制转换和调用，但您通常希望避免这样做。这不好啊

您可以做的一件事是将
getSerialNumbers（）
方法放在
Parent
中，并始终返回空数组，然后在
Child
中重写它，以实际返回子
的序列号

当然，这里也值得重新考虑整个类层次结构。所有继承自
父类的类都有序列号有意义吗？如果是这样，您应该考虑将所有的序列号处理移到<代码>父< /代码>。
Parent
的子类会比
Child
的子类更多吗？如果不是，也许应该删除子类。
除非它是父类中定义的抽象方法，否则不能调用子类的方法。因为JVM不理解子类中包含的方法。为此，您可以在
Inventory
类中执行以下操作

public class Inventory{

public ArrayList<Parent> products;

public Inventory(){

    products = new ArrayList<Parent>();  //Some hard coded items
    products.add(new Child("A0001", "abcdefg"));
    products.add(new Child("B0010", "abcdefg"));
    products.add(new Child("C0100", "abcdefg"));
    products.add(new Child("D1000",  "abcdefg", "firstSN", "secondSN", "thirdSN"));
}

public static ProductLine getProduct(ArrayList<Parent> products, String productCode){

    for(int i = 0; i < products.size(); i++){
         ProductLine product = products.get(i);
         if(product.getProductCode().equals(productCode)){
             return product;  
         }
    }

    return null;

}

公共类目录{
公共ArrayList产品；
公共库存（）{
products=new ArrayList（）；//一些硬编码项
产品。添加（新产品（“A0001”、“abcdefg”）；
产品。添加（新产品（“B0010”、“abcdefg”）；
产品。添加（新产品（“C0100”、“abcdefg”）；
产品。添加（新儿童（“D1000”、“abcdefg”、“firstSN”、“secondSN”、“thirdSN”））；
}
公共静态ProductLine getProduct（ArrayList products、String productCode）{
对于（int i=0；i
您不能调用子类的方法，除非它是父类中定义的抽象方法。因为JVM不理解子类中的方法。为此，您可以在
清单
类中执行以下操作

public class Inventory{

public ArrayList<Parent> products;

public Inventory(){

    products = new ArrayList<Parent>();  //Some hard coded items
    products.add(new Child("A0001", "abcdefg"));
    products.add(new Child("B0010", "abcdefg"));
    products.add(new Child("C0100", "abcdefg"));
    products.add(new Child("D1000",  "abcdefg", "firstSN", "secondSN", "thirdSN"));
}

public static ProductLine getProduct(ArrayList<Parent> products, String productCode){

    for(int i = 0; i < products.size(); i++){
         ProductLine product = products.get(i);
         if(product.getProductCode().equals(productCode)){
             return product;  
         }
    }

    return null;

}

公共类目录{
公共ArrayList产品；
公共库存（）{
products=new ArrayList（）；//一些硬编码项
产品。添加（新产品（“A0001”、“abcdefg”）；
产品。添加（新产品（“B0010”、“abcdefg”）；
产品。添加（新产品（“C0100”、“abcdefg”）；
产品。添加（新儿童（“D1000”、“abcdefg”、“firstSN”、“secondSN”、“thirdSN”））；
}
公共静态ProductLine getProduct（ArrayList products、String productCode）{
对于（int i=0；i
如果您的目标是确定对象的类型是父对象还是子对象，则可以使用instanceof关键字：

if(pFound instanceof Child) {
     //...
}

如果要使用序列号区分类型，父类还必须实现getSerialNumber方法。
如果您的目标是确定对象的类型是Parent还是Child，则可以使用instanceof关键字：

if(pFound instanceof Child) {
     //...
}

如果要区分使用序列号的类型，父类还必须实现getSerialNumber方法。
这是
OOP
编程模型中的一个简单问题：


任何
子
实例也是
父
实例
任何
父
实例也可以是
子
实例

如果您按以下方式更改
库存
类构造函数，则程序工作正常：

public Inventory()
{
    products = new ArrayList<Parent>();  //Some hard coded items
    products.add(new Child("A0001", "abcdefg"));
    products.add(new Child("B0010", "abcdefg"));
    products.add(new Child("C0100", "abcdefg"));
    products.add(new Child("D1000",  "abcdefg", "firstSN", "secondSN", "thirdSN"));
}

public Inventory（）
{
products=new ArrayList（）；//一些硬编码项
产品。添加（新产品（“A0001”、“abcdefg”）；
产品。添加（新产品（“B0010”、“abcdefg”）；
产品。添加（新产品（“C0100”、“abcdefg”）；
产品。添加（新儿童（“D1000”、“abcdefg”、“firstSN”、“secondSN”、“thirdSN”））；
}

或者更好的方法是通过
instanceof