No. No lo heredan.
El hecho de que alguna otra clase pueda usarlo indirectamente no dice nada sobre la herencia, sino sobre la encapsulación.
Por ejemplo:
class Some {
private int count;
public void increment() {
count++;
}
public String toString() {
return Integer.toString( count );
}
}
class UseIt {
void useIt() {
Some s = new Some();
s.increment();
s.increment();
s.increment();
int v = Integer.parseInt( s.toString() );
// hey, can you say you inherit it?
}
}
También puede obtener el valor del count
interior a UseIt
través de la reflexión. No significa, lo heredas.
ACTUALIZAR
Aunque el valor está ahí, la subclase no lo hereda.
Por ejemplo, una subclase definida como:
class SomeOther extends Some {
private int count = 1000;
@Override
public void increment() {
super.increment();
count *= 10000;
}
}
class UseIt {
public static void main( String ... args ) {
s = new SomeOther();
s.increment();
s.increment();
s.increment();
v = Integer.parseInt( s.toString() );
// what is the value of v?
}
}
Esta es exactamente la misma situación que el primer ejemplo. El atributo count
está oculto y la subclase no lo hereda en absoluto. Aún así, como señala DigitalRoss, el valor está ahí, pero no por herencia.
Ponlo de esta manera. Si tu padre es rico y te da una tarjeta de crédito, aún puedes comprar algo con su dinero, pero eso no significa que has heredado todo ese dinero, ¿verdad?
Otra actualización
Sin embargo, es muy interesante saber por qué el atributo está ahí.
Francamente, no tengo el término exacto para describirlo, pero es la JVM y la forma en que funciona que también carga la definición principal "no heredada".
Realmente podríamos cambiar el padre y la subclase seguirá funcionando.
Por ejemplo :
//A.java
class A {
private int i;
public String toString() { return ""+ i; }
}
// B.java
class B extends A {}
// Main.java
class Main {
public static void main( String [] args ) {
System.out.println( new B().toString() );
}
}
// Compile all the files
javac A.java B.java Main.java
// Run Main
java Main
// Outout is 0 as expected as B is using the A 'toString' definition
0
// Change A.java
class A {
public String toString() {
return "Nothing here";
}
}
// Recompile ONLY A.java
javac A.java
java Main
// B wasn't modified and yet it shows a different behaviour, this is not due to
// inheritance but the way Java loads the class
Output: Nothing here
Creo que el término exacto se puede encontrar aquí: la especificación de máquina virtual JavaTM