-1

我想对超类 Object 调用子类方法，但是由于我在子类中声明了另一个整数，所以它给了我一个异常，是否有解决方法来实现这一点？

public static void main(String[]args){

    A a = new A(2,3);
    B b = new B(3,5,6);

    System.out.println("A object: ");
    a.showij();
    System.out.print("sum = ");
    ((B) a).sum(); < ==== this line gives me the error, can't cast
    System.out.println("B object: ");
    b.showij();
    System.out.print("sum = ");
    b.sum();

}

public class B extends A {

int k;

public B(){
    super();
}

public B(int a, int b, int c) {
    super(a, b);
    k = c;
}

public void sum(){
    System.out.println( i + j + k);
}
}


public class A {

int i,j;

public A() {

}

public A( int a, int b){
    i = a;
    j = b;      
}

public void showij(){
    System.out.println("\ti: " + i + " j: " + j);
}
}

*编辑：这是整个事情

4

2 回答 2

1

如果 B 扩展了 A，这仍然意味着 A 是一个单独的类，当您仅实例化 A 时，您不能将其强制转换为 B，因为它与 B 无关。

您可以将 B 转换为 A，因为派生类始终可以转换为它的超类。事实上，你甚至不需要演员。但这是不可能的，反之亦然。

假设 B 扩展 A。

  B b = new B(1,2,3,4,5);
  A a = b; <- This is valid.

  a.sum();

这在语法上是正确的，但它仍然会调用 B 的 sum 函数，因为它是 B 的对象。

但是，在 Java 中，您不能像在 C++ 中那样显式调用类外的超级函数。你必须在你的函数中定义它，然后像这样从 B 调用它：

class B extends A
{
    @Override
    public int sum()
    {
        super.sum();
    }
}

如果这不是可取的，您必须声明一个不同的函数名称，该名称不会被派生类覆盖，但除非您将类设为最终类，否则您不能依赖特定行为，以确保它不能被派生。

更新

示例代码：

public class A
{
    private int mI;
    private int mJ;

    public A(int i, int j)
    {
        mI = i;
        mJ = j;
    }

    public int sum()
    {
        return mI+mJ;
    }

    public void showij()
    {
        System.out.println("I: "+ mI + " J: "+mJ);
    }

    public void print()
    {
        System.out.println("A called "+ sum());
    }
}

B类：

public class B
    extends A
{
    private int mK;

    public B(int i, int j, int k)
    {
        super(i, j);
        mK = k;
    }

    public int sum()
    {
        return super.sum()+mK;
    }

    public void showk()
    {
        System.out.println("K: "+ mK);
    }

    public void print()
    {
        System.out.println("B called "+ sum());
    }
}

测试主要：

public class test
{
    public static void main(String[] args)
    {
        A a = new A(1, 2);
        B b = new B(3, 4, 5);

        a.print();
        b.print();
        a.showij();
        b.showij();
        b.showk();
        a = b;
        b.print();
    }
}
于 2013-06-30T05:59:57.403 回答
0

您的代码确实可以编译，因为将类型转换为其子类是有效的。但是由于这个原因导致了 Class cast 的运行时异常。

A a = new A(2,3); --> Your instance is of type A

((B) a).sum();  --> and you are casting it to B, which cannot happen because the object is not of type B

然而，这种说法会奏效

A a = new B(2,3, 6); --> As per the declaration type of instance is A but the actual instance created is B. So even if a is cast to B it works.
((B) a).sum();
于 2013-06-30T06:22:14.057 回答