SCJP 6
Clase 8 – Inner Classes
Ezequiel Aranda
Sun Microsystems Campus
Ambassador

Disclaimer & Acknowledgments
> Even though Ezequiel Aranda is a full-time employee of Sun
Microsystems, the contents here are created as his own
personal endeavor and thus does not reflect any official
stance of Sun Microsystems.
> Sun Microsystems is not responsible for any inaccuracies in
the contents.
> Acknowledgments – The slides of this presentation are made
from “SCJP Unit 8” by Warit Wanwithu and Thanisa
Kruawaisayawan and SCJP Workshop by P. Srikanth.
> This slides are Licensed under a Creative Commons
Attribution – Noncommercial – Share Alike 3.0
> http://creativecommons.org/licenses/by-nc-sa/3.0/

AGENDA
> enerics Vs. Arrays
G
> lases internas
C
> lases internas “regulares”
C
> lases internas locales a un método
C
> lases internas anónimas
C
> lases estáticas anidadas
C

Generics Vs. Arrays
Animal
<<abs>> checkup()
Bird Cat Dog

Generics Vs. Arrays (II)
public void checkAnimals(ArrayList<Animal>
animals){
for(Animal a : animals) {
a.checkup();
}
}
doc.checkAnimals(dogs); // dogs: List<Dog>
doc.checkAnimals(cats); // cats: List<Cat>
doc.checkAnimals(birds); // birds: List<Bird>
> Porqué no funciona?
¿
> Cómo solucionarlo?
¿

Generics Vs. Arrays (III)
Animal[] animals = new Animal[3];
animals[0] = new Cat();
animals[1] = new Dog();
List<Animal> animals = new
ArrayList<Animal>();
animals.add(new Cat()); // OK
animals.add(new Dog()); // OK
> sto funciona con ambos, Arrays y Generics.
E

Generics Vs. Arrays (IV)
> unciona siempre:
F
public void addAnimal(Animal[] animals) {
animals[0] = new Dog(); Animal[]
}
> unciona a veces:
F
public void addAnimal(ArrayList<Animal>
animals) {
animals.add(new Dog());
}

Generics Vs. Arrays (V)
> a razón por la cual es peligroso pasar como
L
parámetro una colección de un subtipo es
porque podríamos agregar algo erróneo en la
colección (o en el Array).

Generics Vs. Arrays (VI)
public void foo() {
Dog[] dogs = {new Dog(), new Dog()};
addAnimal(dogs);
}
public void addAnimal(Animal[] animals) {
animals[0] = new Dog();
}
> sto funciona perfectamente, y es correcto.
E

Generics Vs. Arrays (VII)
public void foo() {
Cat[] cats = {new Cat(), new Cat()};
addAnimal(cats);
}
public void addAnimal(Animal[] animals) {
animals[0] = new Dog();
}
> cabamos de poner un gato en un Array de
A
perros.

Generics Vs. Arrays (VIII)
> in embargo, y a diferencia que realizando
S
el mismo ejemplo con colecciones
parametrizadas, el código anterior, compila
> o que permite que compile es la existencia
L
de la excepción ArrayStoreException, que
previene que se de el problema visto
anteriormente en tiempo de ejecución.

Generics Vs. Arrays (IX)
> ero no existe un equivalente
P
a esta excepción para
colecciones, debido a que las
parametrizaciones se eliminan
en tiempo de ejecución.
> s decir, la JVM conoce el tipo de los Arrays
E
en tiempo de ejecución, pero no el tipo de
una colección.

Codificando una inner class “regular”
> lamamos regulares a las clases internas que
L
no son:
> státicas
E
> ocales a un método
L
> nónimas
A
> na inner class regular no puede tener
U
declaraciones estáticas de ningún tipo
> a única forma de acceder a la clase interna
L
es a través de una instancia de la clase
externa.

class MyOuter {
private int x = 7;
class MyInner {
public void seeOuter() {
System.out.println(\"Outer x is
\" + x); }}
}
> ste código es perfectamente legal. Nótese
E
que la clase interna esta accediendo a un
miembro privado de la clase externa. Esto es
correcto, dado que la clase interna es un
miembro de la clase externa también.

Instanciando una clase interna
> esde el interior de la clase externa:
D
MyInner mi = new MyInner();
> esde el exterior de la clase externa
D
(incluyendo código de métodos estáticos
dentro de la clase externa):
MyOuter.MyInner
> ara instanciar un objeto de la clase interna
P
debemos usar una referencia a la clase
externa:
obj = new MyOuter().new MyInner();
u outerObjRef.new MyInner();

this
> this” es una referencia al objeto que esta en
“
ejecución actualmente.
public void myMethod() {
MyClass mc = new MyClass();
mc.doStuff(this);
}

Haciendo referencia a la instancia de la clase
interna/ externa desde la clase interna
class MyOuter {
private int x = 7;
class MyInner {
public void seeOuter() {
System.out.println(\"Outer x is \"+ x);
System.out.println(\"Inner class ref is
” + this);
System.out.println(\"Outer class ref is
” + MyOuter.this);
}
}
}

Clases internas locales a un método
class MyOuter2 {
private String x = \"Outer2\";
void doStuff() {
class MyInner {
public void seeOuter() {
System.out.println(\"Outer x is \" + x);
}
}
MyInner mi = new MyInner();
mi.seeOuter(); }
}

Que puede y que no puede hacer una clase
local a un método
> efiniendo una clase interna dentro de un
D
método, solo podremos crear objetos de esa
clase dentro del método.
> uede ser una clase abstracta.
P
> o puede tener métodos o atributos estáticos
N
salvo que la clase interna sea estática
también.

Que puede y que no puede hacer una
clase local a un método (II)
> uede acceder a las variables de la clase
P
externa.
> o puede acceder a las variables locales al
N
método.
> alvo que sean declaradas “final”
S
> os únicos modificadores que podemos
L
aplicar a una clase interna local a un método
son “abstract” y “final”.
> omo siempre, no podemos aplicar los dos al
C
mismo tiempo.

Que puede y que no puede hacer una
clase local a un método (III)
class MyOuter2 {
private String x = \"Outer2\";
void doStuff() {
String z = \"local variable\";
class MyInner {
public void seeOuter() {
System.out.println(\"Outer x is \" + x);
System.out.println(\"Local variable z
is\"+ z);
// Esto no compila. Dado que se accede a z desde la
clase interna, z debe ser declarada final.
} } } }

Clases internas anónimas
class Popcorn {
public void pop() {
System.out.println(\"popcorn\");
}
}
class Food {
Popcorn p = new Popcorn() {
public void pop() {
System.out.println(\"anonymous popcorn\");
}
}; // debe colocarse un punto y coma aquí
}
> La variable p no hace referencia a una instancia de
Popcorn, sino a una instancia de una subclase
anónima de Popcorn.

class Popcorn {
public void pop() {
System.out.println(\"popcorn\");
}
}
class Food {
Popcorn p = new Popcorn() {
public void sizzle() {
System.out.println(\"anonymous sizzling
popcorn\");
}
public void pop() {
System.out.println(\"anonymous popcorn\");
}
};
public void popIt() {
p.pop(); // OK
p.sizzle(); //KO ¿Porqué no funciona?
}}

Clases internas anónimas:
implementando una interfaz
interface Cookable {
public void cook();
}
class Food {
Cookable c = new Cookable() {
public void cook() {
System.out.println(\"anonymous cookable
implementer\");
}
}; Nota: no existe un mecanismo para implementar mas
} de una interfaz de esta forma

class MyWonderfulClass { Clases internas anónimas:
void go() { clases definidas en
Bar b = new Bar(); argumentos
b.doStuff(new Foo() {
public void foof() {
System.out.println(\"foofy\");
} // fin foof
}); //fin inner class y declaración del método
} // fin go()
} // fin class
interface Foo {
void foof();
}
class Bar {
void doStuff(Foo f) { }
}

Clases estáticas anidadas
class BigOuter {
static class Nest {
void go(){System.out.println(\"hi\"); } }
}
class Broom {
static class B2 {
void goB2(){System.out.println(\"hi 2\"); }
}
public static void main(String[] args) {
BigOuter.Nest n = new BigOuter.Nest();
n.go();
B2 b2 = new B2();
b2.goB2(); }}

Clases estáticas anidadas (II)
> Las clases no son exactamente “estáticas”. No existe
tal cosa.
> En este caso el modificador “static” indica que la
clase interna es un miembro estático de la clase
externa.
> Esto quiere decir que podemos acceder al mismo sin
la necesidad de crear una instancia de la clase
externa.
> No puede acceder a los miembros de la clase
externa de la misma forma que lo haría una clase
interna (exceptuando a los estáticos, claro está).

Preguntas