En Java, la clase A extiende B B b=new A. ¿Es este polimorfismo o conversión implícita?

la clase B extiende A

Después de la herencia, generalmente se definen algunos miembros o métodos que no se encuentran en la clase principal.

A a = new B();

Esto está bien, cárgalo.

a es una instancia de un objeto de clase principal, por lo que no puede acceder a nuevos miembros o métodos definidos por la subclase.

============================================ = ===============

Si se define así:

clase A{

int i;

void f(){}

}

la clase B extiende A{

int j;

void f () {}//Reescribir

void g(){}

}

Entonces:

B b = nuevo B( );

b es una instancia de un objeto de subclase. No solo puede acceder a sus propias propiedades y métodos, sino también a las propiedades y métodos de la clase principal. Como b.i, b.j, b.f(), b.g() son todos legales. En este momento, b.f() está accediendo a f() en B

A a = new B()

Aunque a usa el constructor de B, después de la conversión, se convierte en una instancia. del objeto de la clase principal y no puede acceder a las propiedades y métodos de la subclase. a.i, a.f() son legales, mientras que a.j, a.g() son ilegales. En este momento, acceder a a.f() es acceder a f() en A

============================= ==== =============================

El cartel original también puede referirse a la pregunta de caiqiupeng.

A a = new B(); Esta declaración en realidad tiene tres procesos:

(1) A a

Declarar a como el objeto de clase principal. solo una referencia, no se asigna ningún espacio

(2) B temp = new B();

Se crea una instancia del objeto de clase B a través del constructor de la clase B. Es decir , inicialización

(3) a = (A)temp;

Convierta el objeto de subclase temporal en un objeto de clase principal y asígnelo a a. .

Después de los tres procesos anteriores, a se ha convertido completamente en una instancia de la clase A.

Las subclases a menudo tienen más atributos y métodos que las clases principales. La carga solo las descarta, lo cual es seguro, mientras que la degradación a veces los aumenta, lo que generalmente no es seguro.

============================================ = ================

Corrige tu error:

Después del upcast, a.f() debe corresponder al método de la clase B f ()

Después de llamar al constructor para crear una instancia, se ha determinado la entrada al método correspondiente.

Desde entonces, aunque a se ha subido como clase A, el método anulado f() sigue siendo el método f() de B. Es decir, cada objeto sabe a qué método debe llamar.

A a1 = new B();

A a2 = new C();

Aunque a1 y a2 son objetos de clase A, cada f( ) es diferente. Ésta es exactamente la encarnación del polimorfismo mencionado en el primer piso.

Este tipo de problema se explica muy claramente en "Pensamientos sobre programación Java". No lo he leído en mucho tiempo, así que estoy confundido.

ovix | 2007-03-01

12