Clases e interfaces internas static

Se conocen también con el nombre de clases anidadas {nested class es). Las clases e interfaces internas static sólo pueden ser creadas dentro de otra clase al máximo nivel. es decir directamente en el bloque de definición de la clase contenedora y 110 en un bloque más interno. Es posible definir clases e interfaces internas static dentro de una interface contenedora. 

Este tipo de clases internas se definen utilizando la palabra static. Todas las interfaces internas son implícitamente static. E11 cierta forma, las clases internas static se comportan como clases normales en un package. Para utilizar su nombre desde fuera de la clase contenedora hay que precederlo por el nombre de la clase contenedora y el operador punto (.) 

Este tipo de relación entre clases se puede utilizar para agrupar varías clases dentro de una clase más general. Lo mismo puede decirse de las interfaces internas. Las clases internas static pueden ver y utilizar los miembros static de la clase contenedora. No se necesitan objetos de la clase contenedora para crear objetos de la dase interna static. 

Los métodos de la clase interna static 110 pueden acceder dilectamente a los objetos de la clase contenedora, caso de que los haya: deben disponer de una referencia a dichos objetos, como cualquier otra clase. La sentencia import puede utilizarse para importar una dase interna static. en la misma forma que si se tratara de importar una clase de un package (con el punto (.)). Por ejemplo, si la interface Linkable es interna a la clase List, para implementar dicha interface hay que escribir,

... implements List.Linkable

y para importarla hay que usar,

import List.*; // o bien
import List.Linkable;

Otras características importantes son las siguientes: 

1. Pueden definirse clases e interfaces internas dentro de interface y clases contenedoras, con las cuatro combinaciones posibles. 

2. Puede haber varios niveles. esto es una clase interna static puede ser clase contenedora de otra clase interna static. y así sucesivamente. 

3. Las clases e interfaces internas static pertenecen al package de la clase contenedora. 

4. Pueden utilizarse los calificadores final, public. prívate y protected. Esta es una forma más de controlar el acceso a ciertas clases. A continuación se presenta un ejemplo de clase interna static:

// fichero ClasesIntStatic.java

class A {

int i=l;              // variable miembro de objeto

static int is=-l; // variable miembro de clase
public A(int i) {this.i=i;} // constructor

// a los métodos de la clase contenedora hay que pasarles referencias
//          a los objetos de la clase interna static

public void printA(Bs unBs) {

System, out.println("i=^,,+i+^,, unBs. j="+unBs . j) ;

> 

// definición de una clase interna static
static class Bs {
int j=2;

public Bs(int j) {this.j=j;} // constructor

// los métodos de la clase interna static no pueden acceder a la i
//         pues es una variable de objeto. Si pueden acceder a is

public void printBs() {

System.out.println(" j=" + j + " is=" + is) ;

> 

} // fin clase Bs

} // fin clase contenedora A

class ClasesIntStatic {

public static void main(String [] arg) {

A al = new A(ll), a2 = new A(12);

println("al.i=" + al.i + " a2.i=" + a2.i);

// dos formas de crear objetos de la clase interna static

A.Bs bl = new A.Bs(-lO); // necesario poner A.Bs

A.Bs b2 = al.new Bs(-ll); // b2 es independiente de al

// referencia directa a los objetos bl y b2

println("bl.j =" + bl.j + " b2.j=" + b2.j);

// los métodos de la clase interna acceden directamente a las variables
//         de la clase contenedora sólo si son static

bl.printBs(); // escribe: j=-10 is=-l
b2.printBs(); // escribe: j=-20 is=-l

// a los métodos de la clase contenedora hay que pasarles referencias
//         a los objetos de la clase interna, pera que puedan identificarlos

al.printA(bl); // escribe: i=ll unBs.j=-10
al.printA(b2); // escribe: i=ll unBs.j=-ll

} // fin de main()

public static void println(String str) {System.out.println(str);}
} // fin clase ClasesIntStatic