Question

我有一个练习要解决，我有正确的答案，但我无法得到它......有人可以帮助我在每一步之后发生的事情。这是练习。我们有两个类：在这里输入代码

public class CA
{ 
    protected String descricao;
    private float valor;
    public CA(String descricao, float valor)
    {
        this
        .descricao = descricao;
        this.valor = valor;
    }

    public String getDescricao()
    {
        return descricao;
    }

    public float getValor()
    {
        return valor;
    }

    public float teste(float a)
    {
        return soma(a);
    }

    public float soma(float a)
    {
        return valor + a;
    }
}

和第二个：

public class CB extends CA
{
    private final int maxStock = 15;
    private int stock;
    public CB(String descricao, float valor)
    {
        super(descricao,valor);
        stock = 0;
    }

    public int getStock()
    {
        return stock;
    }

    public void setStock(int actual)
    {
        stock = actual;
    }

    public int emFaltaStock()
    {
        return (maxStock-stock);
    }

    public float soma(float a)
    {
        return getValor() + a * 2;
    }

    public boolean noLimite(int minStock)
    {
        return ((minStock-stock) <= 0);
    }
}

问题是这些陈述的结果是什么：

CB cb1 = new CB("cb1",10);
CA ca1 = cb1;
float v1= ca1.soma(2);

我知道它会是14岁，但为什么呢？有谁能告诉我？

Answer 1

这是我们称之为（多态）的展览。在第一个语句中设置CB值（子类值）时。并在第二个语句中使用超类ca1引用调用子类实例。在第3个语句中，当您使用superClass ca1引用调用方法时，由于java中的多态性，将调用子类CB方法。因此结果是14.

Answer 2

请尝试了解流程

CB cb1 = new CB("cb1",10); // Object of CB has been created 
CA ca1 = cb1;             // Referencing  CA instance to CB instance
float v1= ca1.soma(2);   // Calling *soma* Method

因为 soma 是一个覆盖方法...即使用ca1.soma(2);也会调用CB的方法，因为ca1实际上是指CB实例。方法调用取决于实例，而不取决于参考。

Answer 3

我知道它会是14岁，但为什么呢？有谁能告诉我？

为什么因为，这就是Polymorphism的美丽。

第1步：CB cb1 = new CB("cb1",10);

此处为valor = 10

的值

第2步：CA ca1 = cb1;

此reference的{{1}} CA reference。

第3步：CB

因此，当您致电float v1= ca1.soma(2);时，系统会调用soma的方法并将值返回为CB。

通过：What is polymorphism?

Answer 4

这是因为您创建了一个子类的对象并将其分配给超类，如下所示：

Father obj = new Child();

如果您有这样的声明，那么您的声明完全相同：

CB cb1 = new CB("cb1",10);
CA ca1 = cb1;
float v1= ca1.soma(2);
OR
CA ca1 = new CB("cb1",10);
float v1= ca1.soma(2);

并且在父亲和孩子中共享类似签名的方法，总是会继续子方法〜

这种技术在面向对象编程中非常有用，因为你可能有很多子类正在扩展一个父类，每个子类可能都有一个不同算法的覆盖方法

这种方法在面向对象编程中调用Polymorphism。

继承，每一步之后发生的事情

4 个答案: