Ejemplo de Inner Clases

Este es un concepto polémico en Java.

Básicamente, después de estudiarlo, he llegado a las siguientes conclusiones:

1) Una inner class es una clase íntima con su clase outer.

2) Una inner class puede definir sus propias variables y acceder a las variables de outer.

3) Desde la clase outer, se puede instanciar inner classes y usarlas.

A continuación, introducimos un ejemplo descriptivo de inner clases. Básicamente, vemos que tenemos un array con datos y estos son recorridos mediante un iterador interno, que va recorriendo de dos en dos las posiciones e imprimiendo la información.

Un cordial saludo y suerte,

Jaime.

view source

print?

001./**

002. 

003.* Ejemplo de creacion de una outer class e inner class

004. 

005.* Esto es DataStructure es outer class, y después

006. 

007.* el método printEven, se apoya en una clase interna, llamada InnerEvenIterator,

008. 

009.* que básicamente accede a los datos de DataStructure y mediante una variable

010. 

011.* iterador interna los va recorriendo de dos en dos e imprimiéndolos.

012. 

013.* @author jaime

014. 

015.* Fuente: Oracle

016. 

017.*

018. 

019.*/

020. 

021.  

022. 

023./**

024. 

025.* INNER CLASSES

026. 

027.* Atributos: SIZE definido como final, array de ints.

028. 

029.*

030. 

031.*/

032. 

033.public class DataStructure {

034. 

035.//create an array

036. 

037.private final static int SIZE = 15;

038. 

039.private int[] arrayOfInts = new int[SIZE];

040. 

041./**

042. 

043.* Constructor: acceso sin problema a las variables.

044. 

045.*/

046. 

047.public DataStructure() {

048. 

049.//fill the array with ascending integer values

050. 

051.for (int i = 0; i < SIZE; i++) {

052. 

053.arrayOfInts[i] = i;

054. 

055.}

056. 

057.}

058. 

059./**

060. 

061.* PrintEven, creamos un InnerEventIterator (clase interna, que tiene íntima relación

062. 

063.* con nuestra clase) y vamos recorriendo e imprimiendo los valores pares del array.

064. 

065.*/

066. 

067.public void printEven() {

068. 

069.//print out values of even indices of the array

070. 

071.InnerEvenIterator iterator = this.new InnerEvenIterator();

072. 

073.while (iterator.hasNext()) {

074. 

075.System.out.println(iterator.getNext() + " ");

076. 

077.}

078. 

079.}

080. 

081./**

082. 

083.* Clase interna.

084. 

085.* InnerEventIterator: tiene un atributo next y después dos métodos internos, que pueden acceder

086. 

087.* a arrayOfInts (atributo interno de DataStructure.

088. 

089.* @author jaime

090. 

091.*/

092. 

093.private class InnerEvenIterator {

094. 

095.//Contador, que empieza en la posición 0

096. 

097.private int next = 0;

098. 

099.public boolean hasNext() {

100. 

101.//Comprueba si el elemento actual es el último dentro del array

102.return (next <= SIZE - 1);

103. 

104.}

105. 

106.public int getNext() {

107. 

108.//Registra un valor dentro del índice par del array.

109.int retValue = arrayOfInts[next];

110. 

111.//Obtiene el siguiente elemento y lo devuelve

112. 

113.next += 2;

114. 

115.return retValue;

116. 

117.}

118. 

119.}

120. 

121./**

122. 

123.* Método main de prueba

124. 

125.* @param s

126. 

127.*/

128. 

129.public static void main(String s[]) {

130. 

131.//Cremos un objeto y llamamos al método printEvent, que hemos visto que creará

132.//una clase inner interna para gestionar el método

133.DataStructure ds = new DataStructure();

134. 

135.ds.printEven();

136. 

137.}

138.}

Comments

[Elfeijo]

Gracias por la explicación de las inner y outer class, es muy clara, el pero que pongo es que no entiendo cuando conviene usar las clases inner y por qué.

[ajaristi]

Un ejemplo muy típico de las inner classes son Iterator que deben coservar el estado dentro del ciclo.

Este código es de la clase AbstractList de Java:


public ListIterator<E> listIterator(final int index) {
if (index<0 || index>size())
throw new IndexOutOfBoundsException("Index: "+index);

return new ListItr(index);
}


private class ListItr extends Itr implements ListIterator<E> {

ListItr(int index) {
cursor = index;
}

public boolean hasPrevious() {
return cursor != 0;
}
....

[jcarmonaloeches]

Digamos que Inner Classes se usa cuando quieres tener una clase con íntima relación con otra, y no te interesa su uso fuera de ella.
Por ejemplo: Un array de datos (clase outer, puede instanciar la clase iterador, clase inner o "interna" para recorrer la información) y su iterador (clase inner, con acceso a los datos de la clase outer o clase "externa"). En este ejemplo, el iterador no tiene sentido fuera de la clase outer.
Espero haberte ayudado,
Saludos,
Jaime.

[Elfeijo]

Pues un poco tarde pero gracias por las respuestas :)