Java 继承，每一步之后会发生什么

我有一个练习要解决，我有正确的答案，但我不能得到它。。。有人能帮我看看每一步之后发生了什么吗。这是练习。我们有两个类：在这里输入代码

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;
    }
}

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

第二点：

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岁，但为什么？有人能告诉我吗？

请试着理解流程

CB cb1 = new CB("cb1",10);
CA ca1 = cb1;
float v1= ca1.soma(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实例。方法调用依赖于实例而不是引用。
它展示了我们所称的（多态性）。
CB cb1 = new CB("cb1",10);
CA ca1 = cb1;
float v1= ca1.soma(2);

在第一条语句中设置CB值（子类值）时。
在第2条语句中调用具有超类ca1 reference的子类实例。
在第3条语句中，当您使用超类ca1引用调用方法时，由于java中的多态性，将调用子类CB方法。因此，结果是14

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

我知道会是14岁，但为什么？有人能告诉我吗

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

为什么，因为这就是多态性的美

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

步骤1：
CB cb1=新的CB（“cb1”，10）

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

这里的值
valor=10

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

第二步：
ca1=cb1

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

这里
CA的
reference
是
CB的
reference

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

第三步：
float v1=ca1.soma（2）

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

因此，当您调用
soma
时，将调用
CB
方法，并将值返回为
14.0

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

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

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

Father obj = new Child();

如果您的声明与此完全相同：

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

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);

在父亲和孩子中有一种签名类似的方法，总是使用child方法~

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

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

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

这种方法在面向对象编程中调用多态性
 你期望的答案是什么？我已经写下来了，答案是14。你的意思是你得到的答案是14？这就是你所期望的？你想知道为什么答案是14？基本上，你已经创建了一个
CB
。将其称为
CA
不会将其更改为
CA
。它仍然是一个
CB
，当您使用
soma
时，它使用
CB
中定义的一个。
CB cb1 = new CB("cb1",10);
CA ca1 = cb1;
float v1= ca1.soma(2);