Conceptos básicos

Compilación y ejecución Tipos de datos Comentarios

Compi l ac i ón Ti po Tamaño Ej empl o Def aul t Comentarios de una

sola línea
javac Nombr eDel Ar c hi v o. j av a boolean no det er mi nado t r ue / f al s e 0
// Comentario
byte 1 by t e 128 0
Ej ec uc i ón Comentarios de multiples
short 2 by t es 32, 767 0
líneas
char 2 by t es ' a' ' \ u0000'
java Nombr eDel Ar c hi v o /*
int 4 by t es 212, 345 0
Comentario
Pas o de par ámet r os float 4 by t es 1234. 12F 0. 0f
de múltiples
long 8 by t es 123948573L 0
líneas
java Nombr eDel Ar c hi v o ar g1 ar g2 double 8 by t es 1247593. 1739 0. 0d
*/
Sentencia if Operadores aritméticos Niveles de acceso Creación de objetos

if (ex pr es i ón bool eana) { private Mi s ma c l as e

//Acción en caso verdadero Suma a + b [ Ref er enc i a] nombr e=new
} else { Res t a a - b default Mi s mo paquet e Cons t r uc t or ( par ámet r os ) ;
Mul t i pl i c ac i ón a * b
//Acción en caso falso Di v i s i ón a / b Ej empl o
} protected Di f er ent e paquet e a
Módul o a %b
I nc r ement o a ++ t r av és de her enc i a Perro roscko=new Perro();
Dec r ement o a --
Pr e i nc r ement o ++ a public Des de c ual qui er
if (ex pr es i ón bool eana) { l ugar
Pr e dec r ement o -- a
//Acción en caso verdadero Operador ternario
} else if (ex pr es i ón bool eana) {
/** At aj os de as i gnac i ón Definición de variables
* Acción en caso de que la segunda ( ex pr es i ón bool eana ) ?
condición sea verdadera a +=1; I nc r ement a a en 1 v al or s i es v er dader o :
t i po de dat o nombr e = v al or v al or s i es f al s o
**/ a - =1 Dec r ement a a en 1
} else { Ej empl o Ej empl o
/**
* Acción en caso de que ninguna boolean permitirPaso = (edad > 18)
int x = 0 ;
condición se cumpla Operadores de comparación ? true : false;
**/
} Definición de atributos
menor que a < b
may or que a > b
Loop while menor o i gual a <= b Operador instanceof
[ modi f i c ador de ac c es o] [ t i po de
may or o i gual a >= b dat o] [ nombr e de v ar i abl e] = v al or ;
while (ex pr es i ón bool eana ) { I gual a == b
//Sentencias a repetir Di f er ent e a != b ej empl o Dev uel v e v er dader o s i a es
public int edad=18; una i ns t anc i a c r eada a
} Operadores lógicos par t i r de l a c l as e Per r o

Loop do while Definición de métodos boolean res=a instanceof Perro;

a = t r ue b=f al s e
do {
/* AND a && b = f al s e [ modi f i c ador de ac c es o] v al or de
OR a | | b = t r ue Operadores a nivel
* Sentencias a repetir, se ejecuta al r et or no nombr e del mét odo de bits
NOT a ! = f al s e ( par ámet r os ) {
menos una vez
/ / Sent enc i as
*/ Not a: && y | | s e l es c onoc e } Cor r i mi ent o a l a i z qui er da
} while (true); c omo de cor t o ci r cui t o de t al <<
modo que, s i c on ev al uar el Ej empl o
For loop pr i mer el ement o es s uf i c i ent e public String getName(){ Cor r i mi ent o a l a der ec ha
par a det er mi nar el r es ul t ado,
return "Alex"; >>
for (i ni c i al i z ac i ón; el s egundo el ement o no s e
ev al úa. }
ev al uac i ón;i nc r ement o / dec r ement o Oper ador AND &
/ ac c i ón) { En c as o de que no s e des ee es e Definición de constructores
// Sentencias a repetir Oper ador OR |
c ompor t ami ent o y s e qui er an
} ej ec ut ar ambos , es pos i bl e Oper ador XOR ^
ut i l i z ar & y | . [ modi f i c ador de ac c es o] nombr e de
for (int i = 0; i < 10; i++) { Sentencia switch l a c l as e ( par ámet r os ) {
/ / Sent enc i as Palabra reservada
// Sentencias a repetir
} final
} switch (e) {
Ej empl o En una c l as e : Hac e que no
c ont i nue: Dej a de ej ec ut ar l a case 'a':
i t er ac i ón ac t ual y s al t a a l a s e pueda her edar de el l a.
/* public Perro(String name) {
s i gui ent e.
* sentencias en caso de que e sea System.out.print("Se creó " + name); En un mét odo : Hac e que no
} s e pueda s obr ees c r i bi r .
igual a 'a'
br eak : Rompe el c i c l o ac t ual .
*/ Definición de una clase En una v ar i abl e pr i mi t i v a:
Es pos i bl e ut i l i z ar t ags par a No s e puede c ambi ar s u
det er mi nar c ual de l os dos c i c l os break; v al or .
s e des ea r omper . case 'b': [ modi f i c ador de ac c es o] class
En una r ef er enc i a : El
Nombr eDeLaCl as e { obj et o s e puede c ambi ar
outer: for (int i = 0; i <= 10; i++) { /* / / At r i but os per o no s e puede apunt ar a
for (int j = 0; j <= 10; j++) { * sentencias en caso de que e sea / / Cons t r uc t or es ot r o.
if (i == 5) { igual a 'b' / / Mét odos
}
break outer;
*/
} Ej empl o
} break;
} default: public class Perro {
private String nombre;
/*
public Perro() {
For each loop * sentencias en caso de que e no }
sea ninguna de las anteriores public void ladrar() {
for (int temp : array) { System.out.print("WOW");
*/
// Sentencias a repetir }
break; }
}
}

www. t wi t t er . com/ devs4j www. f acebook. com/ devs4j www. devs4j . com
 Programación orientada a objetos
Nombre de la Figura
clase
+ color:String Atributos
Persona

Modificador de acceso: + nombre:String

Métodos + calcularArea() : double + fechaDeNacimiento:String
- calcularPerimetro() : double + Public
+ dormir() : void
- Private + respirar() : void
+ comer() : void
# Protected

Circulo Cuadrado
Estudiante Empleado
+ radio:double + lado:double
+ numeroDeCuenta:int + sueldo:float
+ calcularArea() : double + calcularArea() : double
- calcularPerimetro() : double - calcularPerimetro() : double + aprobar() : void + trabajar() : void
+ reprobar() : void + cobrar() : void
+presentarExamen
(ExamenNormal e) : float
Herencia
+presentarExamen
Circulo c=new Circulo(); (ExamenExtraordinario e) : float
double area=c.calcularArea();

Cada clase que herede de Figura puede crear

Coche Motor
su propia implementación de los métodos Examen
calcularArea() y calcularPerimetro().
- motor:Motor
- calificacion:float
Estudiante e=new Estudiante();
+avanzar():void +encender():void - numeroDePreguntas: int
e.dormir();
e.respirar();
e.aprobar();
+ getCalificacion() : float
Estudiante hereda de Persona, por esto es Encapsulamiento + setCalificacion(float calif) :
posible invocar a los métodos definidos en ella float
sin tener que re escribirlos. El encapsulamiento permite ocultar parte de nuestro
código y exponer solo lo que deseamos, en la clase - float sumaAciertos() : float
Examen podemos acceder al valor de la calificación,
Polimorfismo pero solo a través de métodos getter y setter.
- float generaPromedio() :
Figura c=new Circulo(); float
double area=c.calcularArea(); Examen e=new Examen();
float calificacion = e.getCalificacion();
Es posible asignar un objeto de tipo Circulo a
una referencia de tipo Figura gracias al Si se quiere acceder directamente a la calificación Sobrecarga
polimorfismo. sin utilizar el método getCalificación del siguiente
modo: La sobrecarga de métodos permite tener 2 métodos
Persona e=new Estudiante(); con el mismo nombre, la única regla es que deben
e.dormir(); Examen e=new Examen(); recibir parámetros diferentes, un ejemplo de esto son
e.respirar(); e.calificacion; los métodos :

Es posible asignar un objeto de tipo Obtenremos el siguiente error de compilcación: public float presentarExamen(ExamenNormal e )
Estuidiante a una referencia de tipo Persona The field Examen.calificacion is not visible
gracias al polimorfismo. De igual modo el encapsulamiento nos permite public float presentarExamen(ExamenExtraordinario
ocultar métodos que son utilizados internamente por e)
IS A nuestra clase para no exponerlos a otras clases, un
ejemplo de esto son los métodos: Los dos métodos se encuentran en la clase
Para poder determinar si una clase hereda de Estudiante y ambos reciben parámetros distintos.
otra debe pasar el test IS A (ES UN), veamos
private float sumarAciertos()
algunos ejemplos: La sobrecarga se puede aplicar también a
private float generarPromedio()
constructores, permitiendo crear nuestros objetos
Perro is an Animal -Cumple de diferentes formas de acuerdo al problema, a
Sobreescritura
continuación se presentan algunas reglas:
Libro is a Cuaderno -No cumple La sobreescritura de métodos permite cambiar el
comportamiento de un método heredado de una -Los métodos deben tener el mismo nombre
Coche is a Vehiculo -Cumple clase padre. -Los métodos deben recibir diferentes parámetros
-Los métodos pueden tener diferentes valores de
Si cumple la relación significa que podemos Como se puede ver la clase Figura define el método retorno
utilizar herencia entre las dos clases, en caso calcularArea() , pero una figura por si misma no -Los métodos pueden arrojar diferentes
contrario no podemos hacerlo. puede calcular un área, quien sabe como hacerlo excepciones
son las clases Circulo y Cuadrado, por esto
sobreescriben el método, a continuación algunas
reglas:
HAS A
-Los argumentos del método deben ser
HAS A (Tiene un ) es una relación también exactamente los mismos del que va a sobreescribir
conocida como composición e indica que una -El valor de retorno debe ser el mismo o un
clase tiene como atributo a un objeto de otra subtipo del que se desea sobreescribir
clase el cual puede utilizar para invocar a sus -El nivel de acceso no puede ser más restrictivo
métodos, por ejemplo la clase Coche tiene un que el que se va a sobreescribir
Motor y puede invocar a su método encender. -Los métodos final no se pueden sobreescribir

www. t wi t t er . com/ devs4j www. f acebook. com/ devs4j

 Constructores Constructores, static, interfaces, etc.
Los obj et os s e c r ean a t r av és de Static
c ons t r uc t or es , es t os t i enen l as
s i gui ent es c ar ac t er í s t i c as :
La pal abr a r es er v ada s t at i c s e ut i l i z a
- No t i enen v al or de r et or no par a c r ear v ar i abl es y mét odos que
- Su nombr e es el mi s mo de l a c l as e ex i s t i r án i ndependi ent ement e de s i ex i s t e
- Es pos i bl e t ener mul t i pl es c ons t r uc t or es o no una i ns t anc i a( obj et o) de una c l as e.
s i empr e y c uando es t én s obr ec ar gados . Ex i s t i r á s ol o una c opi a de un mét odo /
- Pueden t ener c ual qui er modi f i c ador de at r i but o s t at i c s i n i mpor t ar el númer o de Métodos static
ac c es o. obj et os que t enga l a c l as e.
- Si no s e dec l ar a un c ons t r uc t or J av a Es pos i bl e ej ec ut ar un mét odo s t at i c s i n
c r ear á uno por def ec t o Variables static nec es i dad de c r ear un obj et o, v eamos el
- El c ons t r uc t or por def ec t o no r ec i be s i gui ent e ej empl o:
par ámet r os Cuando s e t i ene una v ar i abl e s t at i c s e
- Si s e dec l ar a un c ons t r uc t or , s e t endr á s ol o una c opi a de es t a par a t odas public class Calculadora {
r enunc i ar á al c ons t r uc t or por def ec t o l as i ns t anc i as , v eamos el s i gui ent e
ej empl o:
Ej empl o: static int suma(int x, int y) {
public class Humano { return x + y;
public class Perro { static int numeroDeHumanos = 0; }
private String nombre; public Humano() {
private String raza; numeroDeHumanos++; static int resta(int x, int y) {
} return x - y;
public Perro() { public static void main(String[] args) { }
} new Humano();
new Humano(); public static void main(String[] args) {
public Perro(String n, String r) { new Humano(); System.out.println(suma(10, 20));
nombre = n; System.out.println(numeroDeHumanos); }
raza = r; } }
} } Podemos ver que desde el método main se invoca al
...... Sal i da : 3 método suma sin necesidad de crear un objeto de la
} Del c ódi go ant er i or podemos v er l o clase Calculadora,
s i gui ent e:
- La v ar i abl e numer oDeHumanos ex i s t e
La c l as e ant er i or t i ene 2 c ons t r uc t or es , s i n i mpor t ar s i hay obj et os o no c r eados , Interfaces
uno que no r ec i be par ámet r os y el ot r o i ni c i al ment e t i ene un v al or de c er o.
que r ec i be c omo par ámet r o el nombr e y l a - Cada que s e c r ea un obj et o Humano s e Cuando i mpl ement as una i nt er f az ac ept as
r az a del per r o. Las s i gui ent es s on f or mas aument a en uno el c ont r at o de i mpl ement ar s us mét odos .
v ál i das par a c r ear un obj et o de t i po - Es pos i bl e ac c eder a el l a s i n
Per r o: nec es i dad de c r ear un obj et o Una i nt er f az def i ne mét odos s i n
- Su v al or es c ompar t i do por t odos l os i mpl ement ac i ón , c ons t ant es y mét odos
Perro p=new Perro(); obj et os def aul t , v eamos el s i gui ent e ej empl o:
Perro p2=new Perro("Roscko","Terrier escocés"); - Puedes ac c eder a una v ar i abl e s t at i c
que s e enc uent r a en ot r a c l as e del public interface Dibujable {
s i gui ent e modo Nombr eCl as e. v ar i abl e. void dibujar();
Invocación de un }
constructor desde otro Uso de la palabra Las i nt er f ac es deben s er adj et i v os ,
Es pos i bl e i nv oc ar un c ons t r uc t or des de reservada this v eamos al gunas i mpl ement ac i ones de l a
ot r o, par a hac er l o, s e hac e us o de l a La pal abr a r es er v ada this s e ut i l i z a par a i nt er f az Di buj abl e:
pal abr a r es er v ada t hi s, v eamos l a c l as e
r ef er enc i ar al obj et o ac t ual , v eamos el
Per r o modi f i c ada: public class Rectangulo implements Dibujable{
s i gui ent e ej empl o :
@Override
public class Perro { public void dibujar() {
public class Perro {
private String nombre; System.out.println("Dibujando rectangulo");
private String nombre;
private String raza; }
private String raza;
}
public Perro() { public class Pared implements Dibujable {
public Perro(String nombre, String raza) {
this("NombrePorDefecto","RazaPorDefecto"); nombre = nombre; @Override
} raza = raza; public void dibujar() {
} System.out.println("Dibujando en la pared");
public Perro(String n, String r) { ...... }
nombre = n; } }
raza = r; Las c l as es Rec t angul o y Par ed i mpl ement an
} En es t e ej empl o l as as i gnac i ones no l a i nt er f az di buj abl e, por es t o deben
...... f unc i onan dado que l os par ámet r os s e s obr e es c r i bi r el mét odo di buj ar .
} as i gnan a s i mi s mos y no a l os at r i but os
de l a c l as e, par a i ndi c ar que s e des ea A par t i r de l a v er s i ón J av a 8 es pos i bl e
as i gnar a l os at r i but os de l a c l as e ut i l i z ar def aul t met hods , l os c ual es
En el ejemplo anterior el constructor que no recibe ut i l i z ar emos l a pal abr a r es er v ada t hi s per mi t en def i ni r una i mpl ement ac i ón en
parámetros invoca al que si recibe y asígna un nombre del s i gui ent e modo: i nt er f ac es , v eamos el s i gui ent e ej empl o:
y una raza por defecto, cuando se hace uso de la
public class Perro { interface A{
palabra reservada this para invocar a otro constructor,
private String nombre; default void foo(){
esta debe ser la primera línea de código.
private String raza; System.out.println("Método default");
}
Invocación a un constructor public Perro(String nombre, String raza) {
this.nombre = nombre; void bar();
de la clase padre }
this.raza = raza;
Todos l os c ons t r uc t or es ej ec ut an al
c ons t r uc t or de s u c l as e padr e ant es de }
...... En el ejemplo anterior tenemos 2 métodos, foo() es un
ej ec ut ar s e, i nc l us o s i nos ot r os no l o método default, por tanto la clase que implemente la
def i ni mos en el c ódi go t endr emos una }
l l amada c omo l a s i gui ent e: interfaz A no esta obligada a implementarlo, mientras
que bar() debe ser implementado.
Cohesión
public Perro() { Acoplamiento
super(); El t ér mi no c ohes i ón es ut i l i z ado par a
i ndi c ar el gr ado en el que una c l as e Ac opl ami ent o es el gr ado en el que una
}
t i ene un s ol o pr opos i t o bi en def i ni do. c l as e c onoc e s obr e ot r a. Una c l as e A que
depende de una c l as e B par a f unc i onar
super( ) al i gual que this( ) s e ut i l i z a par a Una c l as e bi en enf oc ada t endr á al t a t i ene un al t o ac opl ami ent o.
ej ec ut ar un c ons t r uc t or , l a di f er enc i a c ohes i ón, mi ent r as más c ohes i ón t engamos
ent r o uno y ot r o es que t hi s ej ec ut a uno nues t r as c l as es s er án más f ác i l es de El al t o ac opl ami ent o c ompl i c a el
en l a c l as e ac t ual y s uper uno en l a mant ener . mant eni mi ent o de l as apl i c ac i ones , por
c l as e padr e. es t o s i empr e bus c ar emos r educ i r l o

www. t wi t t er . com/ devs4j www. f acebook. com/ devs4j www. devs4j . com
 Ar r egl os, cl ases abst r act as y enumer aci ones
Clases abstractas Arreglos
La def i ni c i ón de un mét odo s i n En J av a l os ar r egl os s on obj et os que
i mpl ement ac i ón s e c onoc e c omo mét odo al mac enan mul t i pl es v al or es del mi s mo
abs t r ac t o. Una c l as e abs t r ac t a es una t i po, una v ez def i ni do el t amaño es t e no
c l as e que puede c ont ener mét odos puede c ambi ar , v eamos al gunos punt os a
abs t r ac t os y mét odos c onc r et os : c ons i der ar :

public abstract class Figura { - Pueden al mac enar pr i mi t i v os y

private String material; obj et os .
- Ex i s t en ar r egl os uni di mens i onal es y
mul t i di mens i onal es
public String getMaterial() {
return material; Iterando sobre un arreglo
} Declaración de arreglos
public void setMaterial(String material) { Es pos i bl e i t er ar a c ada el ement o de un
this.material = material; ar r egl o c on el s i gui ent e c ódi go: Es pos i bl e dec l ar ar una r ef er nc i a a un ar r ay de
c ual qui er a de l as s i gui ent es f or mas :
} Ar r egl os de pr i mi t i v os
public abstract double calcularArea(); int numeros[] = { 10, 11, 2, 12, 3, 34, 2, 12 };
for (int i = 0; i < numeros.length; i++) { - int arr [];
} - int [] arr;
public class Circulo extends Figura { System.out.println(numeros[i]);
} Ar r egl os de obj et os
private double radio; - String arr[];
@Override Es pos i bl e hac er l o de l a mi s ma f or ma c on
un c i c l o whi l e y do whi l e per o ex i s t e un - String []arr;
public double calcularArea() { t i po de c i l o f or es pec i al l l amado
return Math.PI * Math.pow(radio, 2); f or Eac h, a c ont i nuac i ón un ej empl o: Inicialización de arreglos
}
//Getters y setters de radio int numeros[] = { 10, 11, 2, 12, 3, 34, 2, 12 }; Ex i s t en di f er ent es f or mas de c r ear l os ar r egl os ,
for (int numero : numeros) { v eamos l as s i gui ent es :
}
public class Cuadro extends Figura { System.out.println(numero); - For ma i mpl í c i t a
private double lado; } String nombres[] = { "Alex", "Pedro", "Juan" }
@Override Es t e t i po de c i c l o f unc i ona a t r av és de
public double calcularArea() { una v ar i abl e t empor al que v a t omando el - For ma ex pl í c i t a
return lado*lado; v al or de c ada el ement o del ar r egl o, String nombres[] =new String [3];
f or Eac h es una opc i ón c uando: nombres[0]="Alex";
} - No nec es i t amos modi f i c ar el ar r egl o
//Getters y setters de lado - No nec es i t amos i ndi c es nombres[1]="Pedro";
} nombres[2]="Juan";
Dado que l a f i gur a por s i s ol a no s abe Arreglos de objetos
c omo r eal i z ar un c ál c ul o de ár ea el - For ma anóni ma
mét odo c al c ul ar Ar ea es def i ni do c omo Es pos i bl e t ener t ant o ar r egl os de t i pos String nombres[] = new String[] { "Alex", "Pedro", "Juan" };
abs t r ac t o, l a i mpl ement ac i ón debe pr i mi t i v os c omo de obj et os , a
i mpl ement ar es e mét odo. c ont i nuac i ón un ej empl o: Acceso a arreglos
Regl as i mpor t ant es : public class Taco { Par a ac c eder a l os el ement os de un ar r agl o l o
- Una c l as e abs t r ac t a no puede s er private String sabor; har emos a t r av és de s u i ndi c e, v eamos el s i gui ent e
f i nal . private float precio; ej empl o:
- Los mét odos abs t r ac t os deben s er
i mpl ement ados por l as s ubc l as es private boolean cebolla;
String nombres[] = { "Alex", "Pedro", "Juan" }
- No s e pueden c r ear obj et os de una private boolean cilantro;
System.out.println(nombres[0]);
c l as e abs t r ac t a
- Es pos i bl e def i ni r c ons t r uc t or es y public Taco(String sabor, float precio, boolean
mét odos s t at i c en l a c l as e abs t r ac t a. Imprimirá : Alex
cebolla, boolean cilantro) {
- Puede t ener mét odos f i nal par a
ev i t ar que l as i mpl ement ac i ones l os this.sabor = sabor;
c ambi en. this.precio = precio; Enumeraciones
- Un mét odo abs t r ac t o no puede s er this.cebolla = cebolla;
def i ni do c omo f i nal . this.cilantro = cilantro; Una enumer ac i ón es un t i po es pec i al de c l as e que
- Si una c l as e abs t r ac t a i mpl ement a } r epr es ent a un gr upo de c ons t ant es , es t as
una i nt er f az , puede no i mpl ement ar s us c ons t ant es deber án es t ar en may ús c ul as :
mét odos , per o l a c l as e que her ede de el l a //Getters y setters
debe i mpl ement ar l os . }
- Los mét odos abs t r ac t os no pueden s er public enum SaborPalomitas {
public class Taqueria {
s t at i c . CHILE, MANTEQUILLA, QUESO, CARAMELO;
public static void main(String[] args) {
- Una i nt er f az es una c l as e 100% }
Taco orden1[] = new Taco[3];
abs t r ac t a.
orden1[0] = new Taco("Pastor", 10.5f, true,
Par a ac c eder al v al or de l a enumer ac i ón s e
Identificadores true); r eal i z ar á del s i gui ent e modo:
orden1[1] = new Taco("Suadero", 20.5f, false,
Un i dent i f i c ador es el nombr e que true); SaborPalomitas.CARAMELO
as i gnamos a l as c os as en J av a, es t os orden1[2] = new Taco("Bistec", 30.0f, true,
deben s egui r l as s i gui ent es r egl as :
true); Es pos i bl e as i gnar l e v al or es a l as enumer ac i ones ,
- Pueden i ni c i ar c on una l et r a, gui ón
float precioTotal = 0.0f; v eamos el s i gui ent e
baj o o s í mbol o de moneda.
- Des pués del pr i mer c ar ac t er s e for (Taco taco : orden1) {
pueden i nc l ui r númer os. precioTotal += taco.getPrecio(); public enum TamanioDePalomitas {
- Pueden t ener c ual qui er l ongi t ud. } CHICA(20.5f), MEDIANA(30.1f), GRANDE(50.0f);
- No s e pueden ut i l i z ar pal abr as System.out.println("El precio de la orden es private float precio;
r es er v adas c omo i dent i f i c ador es . private TamanioDePalomitas(float precio) {
- Los i dent i f i c ador es s on c as e de : " + precioTotal);
s ens i t i v e, FOO y f oo s on 2 } this.precio = precio;
i dent i f i c ador es di f er ent es . } }
public float getPrecio() {
Java beans standards Arreglos multidimensionales return precio;
}
- Si s e des ea obt ener un v al or el mét odo Los ar r egl os pueden t ener mul t i pl es
debe t ener el pr ef i j o get , por ej empl o di mens i ones a c ont i nuac i ón un ej empl o: }
get Name( ) ;
public static void main(String[] args) { Par a ac c eder a un v al or de l a enumer ac i ón s e
- Si s e des ea obt ener un v al or bool ean int arrays[][] = { { 2, 2 }, { 4, 4 }, { 5, 5 } }; r eal i z ar á del s i gui ent e modo:
t ambi én es v ál i do ut i l i z ar el pr ef i j o i s ,
por ej empl o i s Al i v e( ) ; for (int[] array : arrays) {
TamanioDePalomitas tamanioMediano =
for (int value : array) {
TamanioDePalomitas.MEDIANA;
- Si s e des ea as i gnar un v al or s e debe System.out.print("\t " + value);
ut i l i z ar el pr ef i j o s et , por ej empl o System.out.println(tamanioMediano.getPrecio());
}
s et Name( St r i ng name) ; System.out.println();
Al ej ec ut ar l o ant er i or t endr emos l a s i gui ent e
- Los mét odos get t er / s et t er deben s er } s al i da: 30. 1
públ i c os }

www. t wi t t er . com/ devs4j www. f acebook. com/ devs4j www. devs4j . com
 Wrapper classes Java - Colecciones Col l ec t i ons

Las wr apper c l as es en J av a t i enen 2

pr i nc i pal es pr opós i t os : <<i nt er f ac e>> <<i nt er f ac e>> <<i nt er f ac e>>
Col l ec t i on Compar abl e Compar at or
- Pr ov eer un mec aní s mo par a env ol v er
v al or es pr i mi t i v os en obj et os y as í s er
i nc l ui dos en ac t i v i dades ex c l us i v as par a
obj et os .

- Pr ov eer una gr an v ar i edad de <<i nt er f ac e>> <<i nt er f ac e>> <<i nt er f ac e>> <<i nt er f ac e>>
ut i l i dades , muc has de el l as es t án Li s t Queue Set Map
r el ac i onadas c on l a c onv er s i ón.

Equivalencias de wrapper classes Ar r ay Li s t Pr i or i t y Queue Has hSet Has hMap

con primitivos
Ex i s t e una wr apper c l as s par a c ada uno de
l os t i pos pr i mi t i v os : Li nk edLi s t Tr eeSet Tr eeMap
- bool ean- Bool ean
- by t e - By t e
- c har - Char ac t er Vec t or
- doubl e - Doubl e
- f l oat - Fl oat Colecciones en Java
- i nt - I nt eger
- l ong - Long
- s hor t - Shor t Las c ol ec c i ones en J av a s on un f r amewor k que
per mi t e al mac enar un gr upo de obj et os , a
Todas l as wr apper c l as s es ex c ept o di f er enc i a de l os ar r egl os l as c ol ec c i ones
Char ac t er pr ov een 2 c ons t r uc t or es , uno pueden c r ec er , v eamos un r es umen de l as
que t oma el v al or pr i mi t i v o y ot r o que i nt er f ac es pr i nc i pal es :
t oma l a r epr es ent ac i ón en St r i ng.
- Col l ec t i on : Todas l as c ol ec c i ones a
ex c epc i ón de l as que pr ov i enen de l a i nt er f az
Map pr ov i nen de l a i nt er f az Col l ec t i on.
Métodos de conversión
- Li s t : Per mi t e gener ar l i s t as s i mpl es de
Ex i s t en di f er ent es mét odos que nos obj et os
per mi t en r eal i z ar ac t i v i dades de
c onv er s i ón, a c ont i nuac i ón s e mues t r an - Set : Per mi t e al mac enar obj et os úni c os
al gunos de l os más ut i l i z ados :
- Map : Per mi t en al mac enar obj et os en par es
- x x x Val ue( ) : Se ut i l i z a c uando l l av e y v al or , l as l l av es deben de s er úni c as HashSet
nec es i t as obt ener el v al or pr i mi t i v o par a
un v al or dado: - Queue : Per mi t en al mac enar obj et os de Col ec c i ón ut i l i z ada c uando nec es i t as un
ac uer do al or den de i ns er c i ón o a r egl as c onj unt o de dat os s i n el ement os
Integer val=new Integer(11); def i ni das dupl i c ados y no t e i mpor t e el or den de
double doubleValue = val.doubleValue(); l os dat os .
System.out.println(doubleValue);
HashSet<String> set = new HashSet<>();
- par s eXXX( ) : Conv i er t e un St r i ng a
un t i po pr i mi t i v o: ArrayList
TreeSet
int intValue = Integer.parseInt("11"); Col ec c i ón bas ada en ar r egl os que puede c r ec er ,
System.out.println(intValue); c uando es i ns t anc i ada t i ene una c apac i dad Tr eeSet es una de l as c ol ec c i ones
def aul t de 10 el ement os , c onf or me s e v an or denadas e i mpl ement a una es t r uc t ur a de
agr egando v al or es l a c apac i dad s e v a t i po ár bol r oj o- negr o y gar ant i z a que l os
-valueOf() : Recibe un String y devuelve un el ement os s er án úni c os y es t ar án
i nc r ement ando.
Wrapper del tipo invocado: or denados de f or ma as c endent e de ac uer do
Ar r ay Li s t t i ene una v el oc i dad c ons t ant e al a un or den nat ur al .
Double doubleValue2 = Double.valueOf("3.14"); agr egar y al obt ener el ement os .
System.out.println(doubleValue2); TreeSet<String> set = new TreeSet<>();
Ar r ay Li s t no es muy ef i c i ent e c uando s e t i ene
que agr egar en una pos i c i ón es pec í f i c a o r emov er HashMap
Autoboxing y Auto-unboxing un el ement o.
Ut i l i z a Has hMap c uando r equi er as una
A par t i r de l a v er s i ón 5 de J av a ex i s t en c ol ec c i ón que c ont enga par es ,
l as s i gui ent es c ar ac t er í s t i c as : ArrayList<String> lista = new ArrayList<>();
l l av e- v al or , l as l l av es pueden c ont ener
nul l per o s ol o un el ement o. Has hMap no
- Aut obox i ng : Es l a c onv er s i ón que LinkedList per mi t e l l av es dupl i c adas .
hac e el c ompi l ador de J av a de el t i po
pr i mi t i v o o a s u c or r es pondi ent e wr apper Li nk edLi s t es una i mpl ement ac i ón de una l i s t a El ac c es o a l os dat os s e bas a en el
c l as s : dobl ement e l i gada, s u per f or manc e es mej or a un has hCode, ent r e mej or s ea l a
Ar r ay Li s t c uando s e t i ene que agr egar o r emov er i mpl ement ac i ón de has hCode, mej or s er á el
Integer x=10; un el ement o, per o es peor c uando s e qui er e per f or manc e.
obt ener o modi f i c ar un el ement o.
- Aut o- unbox i ng : Es l a c onv er s i ón que
hac e el c ompi l ador de J av a de l a wr apper Li nk edLi s t i mpl ement a t ambi én l a i nt er f az Queue HashMap<Integer,String> map = new HashMap<>();
c l as s al t i po de dat o pr i mi t i v o: as í que s e puede ut i l i z ar al mi s mo t i empo c omo
una es t r uc t ur a de t i po FI FO. TreeMap
Integer x=10;
int y=x; LinkedList<String> lista = new LinkedList<>(); Tr eeMap es una de l as c ol ec c i ones
or denadas al i gual que Tr eeSet , s ol o que
== , equals() Vector el or den l o def i ni r án l as l l av es y no l os
v al or es .
if (i1 != i2) { Vec t or j unt o c on Has hTabl e s on l as c ol ec c i ones
i ni c i al es agr egadas en l a v er s i ón 1. 2, s u
System.out.println("Objetos diferentes"); TreeMap<Integer,String> map = new TreeMap<>();
c ompor t ami ent o es s i mi l ar al de un Ar r ay Li s t a
} di f er enc i a que Vec t or es t hr ead s af e.
if (i1.equals(i2)) { Comparable /
System.out.println("Objetos equivalentes"); Comparator
} Vector<String> lista = new Vector<>();
Se ut i l i z a Compar abl e y c ompar at or par a
def i ni r el or den en c ol ec c i ones c omo
Produce la salida: PriorityQueue Tr eeSet y Tr eeMap.
Es t a c l as e f ue agr egada en J av a 5, c omo
Objetos diferentes Li nk edLi s t s opor t a el c ompor t ami ent o def aul t de
Objetos equivalentes una es t r uc t ur a FI FO, Pr i or i t y Queue or dena l os Collections
el ement os de ac uer do a una pr i or i dad, de es t e
Recordemos que == validan si ambas referencias modo podemos ac c eder pr i mer o a l os el ement os que La c l as e j av a. ut i l . Col l ec t i ons c ont i ene
apuntan al mismo objeto, mientras que equals verifica si t i enen una may or pr i or i dad. un c onj unt o de mét odos s t at i c út i l es par a
t r abaj ar c on c ol ec c i ones .
los objetos son equivalentes.
PriorityQueue<String> queue = new PriorityQueue<>();

www. t wi t t er . com/ devs4j www. f acebook. com/ devs4j www. devs4j . com
 Creación de tu propio
Java - Manejo de Errores Autoclosable
Par a c ons t r ui r t u pr opi o r ec ur s o que puede s er
manej ado por t r y - wi t h- r es our c es debes c r ear
c hec k ed una c l as e que i mpl ement e Cl os abl e o
Throwable Aut oc l os abl e y s obr e es c r i bi r s u mét odo c l os e
c omo s e mues t r a:
public class MiRecurso implements AutoCloseable {
public void imprimirMensaje() {
System.out.println("Esta es una acción");
Error unc hec k ed c hec k ed Exception }
@Override
public void close() throws Exception {
ExceptionInitializerError System.out.println("Se esta cerrando mi recurso");
}
IOException RuntimeException unc hec k ed }
Una vez hecho esto podrás utilizarlo del siguiente modo:
StackOverflowError try(MiRecurso recurso=new MiRecurso()){
recurso.imprimirMensaje();
FileNotFoundException NullPointerException
} catch (Exception e) {
//Manejo de la excepción
OutOfMemoryError }
FileSystemException IllegalStateException
Creación de tu propia
Excepción
SecurityException Si l as ex c epc i ones que pr opor c i ona J av a no
r epr es ent an el er r or que nec es i t as , es pos i bl e
El di agr ama ant er i or mues t r a al gunas de l as c l as es más i mpor t ant es al moment o de manej ar c r ear t u pr opi a Ex c epc i ón, par a es t o deber ás
er r or es : de c r ear una c l as e que her ede de Ex c ept i on o
de Runt i meEx c ept i on dependi endo s i qui er es que
- Thr owabl e : Es l a c l as e padr e de t odos l os pr obl emas que enc ont r ar emos al des ar r ol l ar t u ex c epc i ón s ea c hec k ed o unc hec k ed:
apl i c ac i ones J av a.
class MiExcepcionNoChecada extends RuntimeException {
- Er r or : Se ut i l i z a par a r epr es ent ar s i t uac i ones i nus ual es de l as que l as apl i c ac i ones }
no s e pueden r ec uper ar . class MiExcepcionChecada extends Exception {
}
- Ex c ept i on : Son er r or es en t i empo de ej ec uc i ón de nues t r os pr ogr amas y s e pueden
c l as i f i c ar de ac uer do a l o s i gui ent e:
- Chec k ed : Son ex c epc i ones que el c ompi l ador r equi er e que manej emos , l as ut i l i z amos Lanzamiento de excepciones
c uando qui en l l ama a nues t r o mét odo s e puede r ec uper ar de es a s i t uac i ón.
- Unc hec k ed : Son ex c epc i ones que el c ompi l ador no r equi er e que manej emos , t odas l as
ex c epc i ones que her eden de Runt i meEx c ept i on s er án c ons i der adas c omo unc hec k ed. Las Si ex i s t e una par t e en t u c ódi go donde des eas
ut i l i z ar emos par a r epr es ent ar pr obl emas que r es ul t an de er r or es de pr ogr amac i ón. l anz ar una ex c epc i ón s e ut i l i z ar á l a pal abr a
r es er v ada t r ow c omo s e mues t r a a c ont i nuac i ón:
try - catch -finally Reglas al utilizar try-catch-finally
class MenorDeEdadException extends Exception{
A c ont i nuac i ón s e mues t r a un ej empl o s obr e A c ont i nuac i ón s e mues t r an al gunas r egl as }
el us o de t r y - c at c h- f i nal l y : al ut i l i z ar t r y - c at c h- f i nal l y : public void validarEdad(int edad) throws
MenorDeEdadException {
try { - Sol o el bl oque t r y es obl i gat or i o. if (edad < 18) {
/** - Es pos i bl e def i ni r un bl oque c on s ol o throw new MenorDeEdadException();
* Código que puede generar excepciones un t r y y un c at c h del s i gui ent e modo:
try{ }
*/ }
} catch (Exception e) { Uso de la palabra reservada
}catch(Exception e){
/** throws
* Código a ejecutar en caso de que
} Se ut i l i z a l a pal abr a r es er v ada t hr ows par a
se genere una excepción
- Es pos i bl e def i ni r un bl oque c on s ol o i ndi c ar que en c as o de que s e gener e una
*/ un t r y y un f i nal l y del s i gui ent e modo: ex c epc i ón es t a no s er á manej ada por el mét odo
} finally { ac t ual s i no por el que l o mando l l amar :
/** try{
* Código a ejecutar sin importar si se public void readFile() throws FileNotFoundException {
* generó o no una excepción }finally{ File file = new File("archivo_que_no_existe.txt");
*/ FileInputStream stream = new FileInputStream(file);
} } /**
- Un t r y puede t ener muc hos c at c h per o * código que utiliza stream
Union catch block s ol o uno s e ej ec ut ar á. */
- Se deben c ol oc ar l os c at c h de l a }
Per mi t e t ener un s ol o c at c h par a múl t i pl es ex c epc i ón más es pec í f i c a a l a más gener al .
ex c epc i ones : - El bl oque f i nal l y s e ej ec ut ar á
i nc l us o s i en el c at c h s e t i ene una Como s e puede v er , a pes ar de que
s ent enc i a r et ur n. Fi l eNot FoundEx c ept i on es una ex c epc i ón de t i po
try { c hec k ed, no es nec es ar i o c ol oc ar el c ódi go
- La úni c a f or ma de ev i t ar que s e
/** ej ec ut e un bl oque f i nal l y es dec l ar ando un dent r o de un t r y c at c h y a que qui en s er á
* Código que puede generar una excepción Sy s t em. ex i t ( . . ) ; r es pons abl e de c ac har l a ex c epc i ón es el
*/ mét odo que i nv oque al mét odo r eadFi l e( ) .
} catch (FileNotFoundException | Ut i l i z ar emos es t e mét odo par a del egar el
FileAlreadyExistsException e) { manej o del er r or a qui en t i ene l a c apac i dad de
Uso de try-with-resources
/** manej ar l o, por ej empl o s i hay un c omponent e
* Código que se ejecuta en caso de que se genere una que s ol o ac c ede a dat os puede pr opagar el
La c l as e Pr i nt Wr i t er s e ut i l i z a par a
* FileNotFoundException o FileAlreadyExistsException es c r i bi r en un ar c hi v o, v eamos el er r or has t a el c omponent e que manej a l a
pr es ent ac i ón par a que l e mues t r e un mens aj e
*/ s i gui ent e ej empl o:
adec uado al us uar i o.
}catch (IOException e){
try (PrintWriter writer = new PrintWriter(new
/**
File("test.txt"))) { Reglas al utilizar throws / throw
* Código que se ejecuta en caso de que se genere una
* IOException - Thr ows es nec es ar i o s ol o par a ex c epc i ones
writer.println("Hello World");
*/ de t i po c hec k ed
} - Cuando s e s obr es c r i be un mét odo no es
} catch (FileNotFoundException e) { pos i bl e agr egar t hr ows c on una ex c epc i ón nuev a
//Manejo de la excepción de t i po c hec k ed
try with resources
} - Cuando s e l l ega a una l í nea c on t hr ow l a
ej ec uc i ón s e det i ene y s e c omi enz a a pr opagar
Tr y wi t h r es our c es s e i nc l uy ó en J av a 7 y l a ex c epc i ón
nos per mi t en dec l ar ar r ec ur s os que s e En el c ódi go ant er i or s i n i mpor t ar s i - Si l a ex c epc i ón no es manej ada por ni ngún
ut i l i z ar án en un bl oque t r y c on l a ex i s t e o no una ex c epc i ón al es c r i bi r en mét odo, s er á manej ada por l a J VM
s egur i dad de que s er án c er r ados des pués de el ar c hi v o s e ej ec ut ar á el mét odo c l os e - Un mét odo puede dec l ar ar más de una
l a ej ec uc i ón del bl oque, Los r ec ur s os def i ni do en l a i nt er f az Aut oc l os abl e e ex c epc i ón c on l a pal abr a r es er v ada t hr ows
dec l ar ados deben i mpl ment ar l a i nt er f az i mpl ement ado por Pr i nt Wr i t er . - Se puede ut i l i z ar t hr ow s ol o c on obj et os
Aut oCl os abl e. de t i po Thr owabl e

www. t wi t t er . com/ devs4j www. f acebook. com/ devs4j www. devs4j . com
 Inner classes Java - clases internas Ejecución de un Thread

Las c l as es i nt er nas s e pueden c l as i f i c ar El s i gui ent e ej empl o mues t r a c omo

del s i gui ent e modo: Clases anónimas con interfaces ej ec ut ar hi l os :

- Cl as es i nt er nas r egul ar es Son c l as es s i n nombr e que t ambi én pueden public class Counters {
- Cl as es i nt er nas a ni v el de mét odo i mpl ement ar una i nt er f az public static void main(String[] args) {
- Cl as es anóni mas DescendingCounter descending = new
- Cl as es i nt er nas es t át i c as interface Foo {
void foo(); DescendingCounter(10);
Clases internas regulares }
public class InterfaceExample { Thread ascending = new Thread(new
Las c l as es i nt er nas r epr es ent an c l as es public static void main(String[] args) { AscendingCounter(10));
que no s on anóni mas , s t at i c o a ni v el de Foo f = new Foo() { descending.start();
mét odo. A c ont i nuac i ón s e pr es ent a un ascending.start();
ej empl o: @Override
public void foo() { lkvc mclkvm
public class External { System.out.println("Foo"); }
void foo() { } }
System.out.println("Foo"); }; Del c ódi go ant er i or podemos v er l os
} s i gui ent es punt os :
f.foo();
class Internal { } - Par a ej ec ut ar un hi l o NO
void bar() { } ej ec ut ar emos s u mét odo r un( ) .
System.out.println("Bar");
} Threads - Par a ej ec ut ar un hi l o ej ec ut ar emos
} s u mét odo s t ar t ( ) .
} Un hi l o es un obj et o en j av a que t i ene
v ar i abl es y mét odos . Lo es pec i al de es t a - Si ej ec ut amos el mét odo r un( )
Es pos i bl e c r ear i ns t anc i as de c l as es c l as e es que per mi t e ej ec ut ar t ar eas de ej ec ut ar á el c ódi go, per o no de f or ma
i nt er nas del s i gui ent e modo: f or ma c onc ur r ent e. c onc ur r ent e, s i no c omo un mét odo c omún.

External external = new External(); Ex i s t en 2 f or mas de def i ni r un hi l o: - El mét odo void sleep(long millis) per mi t e
External.Internal internal = external.new Internal(); dor mi r el hi l o l a c ant i dad de
external.foo(); - Cr eando un obj et o de l a c l as e Thr ead mi l i s egundos es pec i f i c ada.
internal.bar(); y s obr ees c r i bi endo el mét odo r un( )
- Si s e c r ea un hi l o a t r av és de una
- Cr eando un obj et o que i mpl ement e l a c l as e que her eda de Thr ead s ol o s e debe
Clases internas estáticas i nt er f az Runnabl e e i mpl ement ando el ej ec ut ar s u mét odo s t ar t ( ) .
mét odo r un( )
A c ont i nuac i ón s e pr es ent a un ej empl o de - Si s e c r ea un hi l o a t r av és de una
una c l as e es t át i c a i nt er na: Definición de Threads a c l as e que i mpl ement a Runnabl e el obj et o
través de herencia s e debe pas ar c omo par ámet r o a un obj et o
public class StaticExternal { de l a c l as e Thr ead.
static class Interna { A c ont i nuac i ón s e mues t r a un ej empl o de
void foo() { l a def i ni c i ón de un hi l o ut i l i z ando - " End of cr eat i on" s e i mpr i mi r á ant es
her enc i a: de que s e t er mi nen de ej ec ut ar l os dos
System.out.println("Foo"); pr oc es os c onc ur r ent es .
} class DescendingCounter extends Thread {
} private int maxNumber; Ciclo de vida de los hilos
public static void main(String[] args) { public DescendingCounter(int maxNumber) {
Interna internal = new Interna(); this.maxNumber = maxNumber; Los hi l os s e pueden enc ont r ar en l os
internal.foo(); } s i gui ent es es t ados :
}
} - New: El hi l o s e ha c r eado per o no s e
@Override ha ej ec ut ado el mét odo s t ar t ( )
No es nec es ar i o c r ear obj et os de l a c l as e public void run() {
ex t er na par a i ns t anc i ar obj et os de l a
for (int i = maxNumber; i >= 0; i--) { - Runnabl e: Se ej ec ut ó el mét odo
c l as e i nt er na.
try { s t ar t ( ) y el hi l o es t á l i s t o par a s er
Thread.sleep(1000); ej ec ut ado.
Clases a nivel de método
System.out.println("Desc:" + i); - Runni ng: El hi l o s e enc uent r a en
Tambi én es pos i bl e dec l ar ar c l as es a } catch (InterruptedException e) { ej ec uc i ón.
ni v el de mét odo: System.err.println(e);
} - Wai t i ng/ bl oc k i ng: El hi l o no es
public class MethodLevelClasses { el egi bl e par a s er ej ec ut ado. El hi l o es t a
}
static void print() { v i v o per o no es el egi bl e.
}
class InnerMethodClass {
} - Dead: El hi l o s e c ons i der a muer t o
void foo() {
c uando t er mi na l a ej ec uc i ón del mét odo
System.out.println("test");
El c ódi go ant er i or mues t r a c omo hac er un r un. No es pos i bl e i ni c i ar de nuev o un
} c ont ador de f or ma des c endent e. hi l o que s e enc uent r a en es t ado dead.
}
InnerMethodClass innerClass = new Definición de Threads a través de implementación
InnerMethodClass(); Thread scheduler
innerClass.foo(); A c ont i nuac i ón s e mues t r a un ej empl o de
l a def i ni c i ón de un hi l o i mpl ement ando l a Es l a par t e de l a maqui na v i r t ual de J av a
} i nt er f az Runnabl e: que dec i de l os hi l os que s e v an a
public static void main(String[] args) { ej ec ut ar de ac uer do a s us pr i or i dades .
print(); class AscendingCounter implements Runnable {
}
private int maxNumber;
Clases anónimas
public AscendingCounter(int maxNumber) {
Son c l as es s i n nombr e que her edan de l a this.maxNumber = maxNumber;
c l as e es pec i f i c ada: }
abstract class Test {
@Override
abstract void foo();
public void run() {
}
for (int i = maxNumber; i >= 0; i--) {
public class AnonymousClass {
try {
public static void main(String[] args) {
Thread.sleep(800);
Test object = new Test() {
System.out.println("Asc : " + i);
@Override
} catch (InterruptedException e) {
void foo() {
System.err.println(e);
System.out.println("Foo");
}
}
}
};
}
object.foo();
}
}
El c ódi go ant er i or mues t r a c omo hac er un
} c ont ador as c endent e.

www. t wi t t er . com/ devs4j www. f acebook. com/ devs4j www. devs4j . com
 Hilos parte 2, Lambdas,
Optional, Streams y Sockets
Creación de hilos con
Ciclo de vida de los hilos
lambdas
Los hi l os s e pueden enc ont r ar en l os Un ej empl o de una i nt er f az f unc i onal es
s i gui ent es es t ados : l a i nt er f az Runnabl e l a c uál s ol o def i ne Java 8 Streams
el mét odo r un( ) . A c ont i nuac i ón un
- New: El hi l o s e ha c r eado per o no s e ej empl o: Un st r eam es una pi ez a de c ódi go que s e
ha ej ec ut ado el mét odo s t ar t ( ) . enf oc a en c onj unt os y no en pi ez as
Runnable counter = () -> { i ndi v i dual es . Supongamos el s i gui ent e
- Runnabl e: Se ej ec ut ó el mét odo for (int i = 0; i <= 100; i++) { pr obl ema:
s t ar t ( ) y el hi l o es t á l i s t o par a s er try {
ej ec ut ado. Se des ean obt ener l as 3 pr i mer as per s onas
Thread.sleep(800); may or es de 18 años que s e enc uent r an en
- Runni ng: El hi l o s e enc uent r a en System.out.println("Asc : " + i); una l i s t a:
ej ec uc i ón. } catch (InterruptedException e) {
System.err.println(e); int count = 0;
- Wai t i ng/ bl oc k i ng: El hi l o no es } List<Persona> resultado = new ArrayList<>();
el egi bl e par a s er ej ec ut ado. El hi l o es t a for (Persona persona : personas) {
v i v o per o no es el egi bl e. }
}; if (persona.getEdad() >= 18) {
- Dead: El hi l o s e c ons i der a muer t o resultado.add(persona);
c uando t er mi na l a ej ec uc i ón del mét odo El c ódi go ant er i or r epr es ent a l a c r eac i ón count++;
r un( ) . Un hi l o en es t ado dead no s e puede de un obj et o que i mpl ement a l a i nt er f az if(count==3){
v ol v er a i ni c i ar . Runnabl e. break;
Implementación de una interfaz propias }
Métodos últiles
}
A c ont i nuac i ón s e mues t r a un ej empl o de }
- s t ar t ( ) : I ni c i a l a ej ec uc i ón de un l a i mpl ement ac i ón de una i nt er f az En el c ódi go ant er i or s e da una s ol uc i ón
hi l o hac i endo us o de l ambdas : al pr obl ema de f or ma i mper at i v a. A
c ont i nuac i ón s e pr es ent a una s ol uc i ón de
- j oi n( ) : Hac e que un hi l o es per e l a interface Calculable { f or ma f unc i onal a t r av és de s t r eams :
ej ec uc i ón de ot r o has t a que es t a t er mi ne. double avg(double... numbers);
} List<Persona> primerosMayores =
- s l eep( l ong mi l i s ) : Mét odo es t át i c o personas.stream().filter(p -> p.getEdad() >= 18).limit(3)
que puedes ut i l i z ar par a al ent ar l a public class InterfaceImplementation { .collect(Collectors.toList());
ej ec uc i ón de un hi l o.
public static void main(String[] args) {
- y i el d( ) : Puede c aus ar que s e mande Calculable calc = (numbers) -> { ¿Cómo utilizar streams?
al hi l o a es t ado r unnabl e, dependi endo de double sum = 0.0;
s u pr i or i dad. Par a ut i l i z ar s t r eams s egui r emos l os
for (int i = 0; i < numbers.length; i++) { s i gui ent es pas os :
sum += numbers[i];
- wai t ( ) : Env í a al hi l o a es per ar en
es t ado wai t i ng. } 1: I ni c i ar c on una i mpl ement ac i ón
return sum / numbers.length; c onc r et a : Ar r ay s, Set , Li s t , Map, et c .
- not i f y( ) : Not i f i c a par a que un hi l o };
en es t ado wai t i ng pas e a es t ado r unnabl e. 2: Ej ec ut ar el mét odo s t r eam( ) , es
System.out.println(calc.avg(1, 2, 3, 4, 5, 6, 7, pos i bl e c onc at enar múl t i pl es s t r eams .
8, 9, 10));
- not i f y Al l ( ) : Not i f i c a a t odos l os
hi l os en es t ado wai t i ng par a que v uel v an } 3: Ut i l i z ar oper ac i ones ent r e s t r eams
a es t ado r unnabl e. } ent r e l as que t enemos : f i l t er , map,
r educ e, et c .
- s et Name( St r i ng name) : As i gna un
nombr e al hi l o. Clase Optional 4: Vol v er al c as o c onc r et o, es t e
puede s er : I nt eger , Li s t , Map, Set ,
- s et Pr i or i t y( i nt pr i or i t y ) : Def i ne Es t a c l as e nos per mi t e r epr es ent ar Opt i onal , et c .
l a pr i or i dad de un hi l o v al or es opc i onal es en l ugar de v al or es
nul os . Veamos el s i gui ent e ej empl o: 5: Par a v ol v er al c as o c onc r et o
Lambdas podr emos ut i l i z ar al gunas de l as
public Integer findValue(Integer value, Integer[] array) { s i gui ent es oper ac i ones : s um( ) ,
Las ex pr es i ones l ambda s on una de l as for (int i = 0; i < array.length; i++) { c ol l ec t ( Col l ec t or s . t oLi s t ( ) ) , av er age( ) ,
adi c i ones más i mpor t ant es que s e hi c i er on if (array[i] == value) { c ol l ec t ( Col l ec t or s . gr oupBy ( ) ) , et c .
a l a v er s i ón 8 de J av a y pr ov een una
f or ma s i mpl e de r epr es ent ar un mét odo a return i; Sockets
t r av és de una ex pr es i ón. }
} Los s oc k et s per mi t en es c r i bi r pr ogr amas
Las ex pr es i ones l ambda s on return null; que s e ej ec ut an en di f er ent es
i mpl ement ac i ones de i nt er f ac es } c omput ador as que es t an c onec t adas a
f unc i onal es. Una i nt er f az f unc i onal es t r av és de l a r ed.
bás i c ament e una i nt er f az c on un s ol o El mét odo ant er i or bus c a un v al or en un
mét odo abs t r ac t o. ar r egl o y dev uel v e s u pos i c i ón, en c as o
de que no s e enc uent r e dev uel v e nul l . A Un s oc k et es t a c onf or mado por :
Sintaxis c ont i nuac i ón s e pr es ent a un ej empl o
ut i l i z ando Opt i onal : - Un pr ot oc ol o : Puede s er UDP o TCP
Una ex pr es i ón l ambda es t á c ompues t a por
l as s i gui ent es 3 par t es : public static Optional<Integer> findValue(Integer value, - Una I P : El l ugar de or i gen o
des t i no al que s e env i ar á l a i nf or mac i ón
Integer[] array) {
l i s t a de ar gument os : ( i nt x , i nt y )
for (int i = 0; i < array.length; i++) { - Un puer t o: Son ut i l i z ados par a
Tok en : - > if (array[i] == value) { det er mi nar a donde di r i gi r el t r áf i c o del
return Optional.of(i); 0 al 1023 s on puer t os dedi c ados del
Cuer po : x + y } s i s t ema.
}
Creación de un Comparator a
return Optional.empty(); ServerSocket
través de lambdas }
A c ont i nuac i ón s e mues t r a un ej empl o de Es t o hac e una s ol uc i ón más l i mpi a y menos Nos per mi t e def i ni r a nues t r o s oc k et
un Compar at or hac i endo us o de l ambdas : pr opens a a bugs . El s i gui ent e ej empl o s er v i dor . A c ont i nuac i ón s e pr es ent a un
mues t r a c omo manej ar una r es pues t a ej empl o:
List<Persona> personas = new ArrayList<>(); opc i onal :
personas.add(new Persona("Juan", "López")); ServerSocket server = new ServerSocket(8080);
personas.add(new Persona("Arturo", "Sánchez")); Optional<Integer> result = findValue(5, new Integer[] {
10, 33, 23, 57, 88 });
Socket
Comparator<Persona> comparator = (Persona p, if(result.isPresent()){
Persona p2) -> System.out.println(result.get()); Nos per mi t e def i ni r a l os c l i ent es que s e
p.getNombre().compareTo(p2.getNombre()); }else{ c onec t ar an al s er v i dor . A c ont i nuac i ón s e
System.out.println("No se encontro el resultado"); pr es ent a un ej empl o:
Collections.sort(personas, comparator); }
Socket socket = new Socket("localhost", 8080);

www. t wi t t er . com/ devs4j www. f acebook. com/ devs4j www. devs4j . com
 Productor consumidor

Thread Thread

Recurso
Productor compartido Consumidor

LinkedList

Notas
- Los pr oduc t or es deben pr oduc i r mens aj es
en el Li nk edLi s t .

- El obj et o que c ont i ene al Li nk edLi s t

s er á un r ec ur s o c ompar t i do ent r e el
pr oduc er y el c ons umer .
- Si no hay mens aj es a c ons umi r el
c ons umi dor debe es per ar has t a que s ea
not i f i c ado que hay un mens aj e nuev o.

- Si el pr oduc t or gener a un mens aj e debe

not i f i c ar a l os c ons umi dor es par a que
v ay an a c ons umi r l o.

Todo es t o s e debe hac er de f or ma

s i nc r oni z ada par a que l os hi l os s e
ej ec ut en de f or ma i nf i ni t a.

Pueden ex i s t i r N pr oduc t or es y N
c ons umi dor es .

www. t wi t t er . com/ devs4j www. f acebook. com/ devs4j www. devs4j . com
 Uso de streams
XXStream (range y Transformaciones utilizando
rangeClosed) map
Puedes ut i l i z ar I nt St r eam, Doubl eSt r eam, Puedes ut i l i z ar map c uando des ees Method reference por
LongSt r eam, et c , par a gener ar un f l uj o de t r ans f or mar de un obj et o a ot r o, por
dat os pr i mi t i v os a c ont i nuac i ón s e ej empl o, s i obt i enes de una bas e de dat os méodo de instancia
pr es ent a un ej empl o de f or ma i mper at i v a y un obj et o l l amado Per s ona y l o qui er es En es t e ej empl o s e ex pl i c ar á c omo
ut i l i z ando pr ogr amac i ón f unc i onal : t r ans f or mar a uno de t i po St r i ng puedes ut i l i z ar met hod r ef er enc e c on un mét odo
hac er l o s i gui ent e: de i ns t anc i a:
I mper at i v a
public static void main(String []args) {
for(inti= 0;i< 10;i++) { public static void main(String []args) { List<String>names=
System.out.print(i); List<Persona>personas= Arrays.asList("Alex","Juan","Pedro","raidentrance");
} Arrays.asList(new Persona("Alex","Lopex"));
names.stream().forEach(System.out::println);
List<String>nombres=personas.stream(). }
Func i onal
map(p->p.getNombre()).
IntStream.range(0, 10).forEach(System.out::print); collect(Collectors.toList());
for(String nombre:nombres) {
System.out.println(nombre); Method reference static
}
Máximos y mínimos } En es t e ej empl o s e ex pl i c ar á c omo
ut i l i z ar met hod r ef er enc e c on un mét odo
A c ont i nuac i ón s e pr es ent a una s ol uc i ón s t at i c :
c omún par a obt ener el v al or mí ni mo de una Uso de métodos static en
l i s t a ut i l i z ando pr ogr amac i ón i mper at i v a: interfaces class StringUtils{
A par t i r de l a v er s i ón 8 de J av a puedes static boolean isUpperCase(Stringcad) {
public static void main(String []args) {
c ol oc ar mét odos s t at i c en l as i nt er f ac es return cad.toUpperCase().equals(cad);
List<Integer>numbers= Arrays.asList(7, 2, 3, c omo s e mues t r a a c ont i nuac i ón: }
100, 200, 300, 400, 5, 1);
interface Follower{ }
int min=numbers.get(0);
for(Integer value:numbers) { static String getName() {
Ut i l i z ando pr ogr amac i ón i mper at i v a:
if(value<min) { return "raidentrance";
min=value; } public static void main(String []args) {
} } List<String>names=
} Arrays.asList
System.out.println(min); Los mét odos s t at i c def i ni dos en l as ("Alex","Juan","Pedro","raidentrance","PANCHO");
i nt er f ac es no pueden s er s obr ees c r i t os .
}
names.stream().
A c ont i nuac i ón s e pr es ent a l a s ol uc i ón Métodos default en las filter(cad->StringUtils.isUpperCase(cad))
equi v al ent e ut i l i z ando s t r eams : interfaces .forEach(System.out::println);
public static void main(String[]args) { Ot r o c ambi o i mpor t ant e al t r abaj ar c on }
i nt er f ac es es que ahor a puedes i nc l ui r
List<Integer>numbers= Arrays.asList(7, 2, 3, mét odos c on c uer po, a es t os l os
100, 200, 300, 400, 5, 1); l l amar emos mét odos def aul t , a Ut i l i z ando s t at i c met hod r ef er enc e:
c ont i nuac i ón un ej empl o:
Integer minValue= numbers.stream(). public static void main(String[]args) {
min(Comparator.naturalOrder()).get(); interface Follower{ List<String>names= Arrays.asList
System.out.println(minValue); static String getName() { ("Alex","Juan","Pedro","raidentrance","PANCHO");
} return"raidentrance";
} names.stream().
Par a c al c ul ar el v al or mí ni mo s ol o s e filter(StringUtils::isUpperCase)
r eempl az ar á mi n por max en l a l í nea
ant er i or . default void follow() { .forEach(System.out::println);
System.out.println("Default follow impl");
Remover datos } }
duplicados }
Remov er dat os dupl i c ados de una l i st a
puede s er una t ar ea c ompl i c ada, per o El mét odo f ol l ow es un mét odo c on una Method reference con
hac er l o c on s t r eams es muy s i mpl e, a i mpl ement ac i ón por def aul t , a di f er enc i a constructores
c ont i nuac i ón dos f or mas s i mpl es de del mét od get Name que es s t at i c , el
hac er l o: mét odo f ol l ow puede s er s obr ees c r i t o s i n Es pos i bl e ut i l i z ar c ons t r uc t or es c on
met hod r ef er enc e c omo s e mues t r a a
nungún pr obl ema, c ons ul t a l a i nt er f ac e
1. Ut i l i z ando di s t i nc t c ont i nuac i ón:
Compar at or par a v er una i nt er f az que hac e
us o de mét odos def aul t .
public static void main(String[] args) { class Person {
List<Integer> numbers= Arrays.asList(7, 7, 7, 7, 2, private String name;
2, 2, 3, 3, 3, 3, 100, 100, 200, 200);
Method reference
numbers=numbers.stream().distinct(). public Person(String name) {
collect(Collectors.toList()); Una f unc i onal i dad i mpor t ant e que s e this.name=name;
agr egó en J av a 8 es met hod r ef er enc e y es
ut i l i z ada par a s i mpl i f i c ar l a ej ec uc i ón }
System.out.println(numbers);
} de un mét odo dent r o de un l ambda, es t o
puede s er de l os s i gui ent es modos :
2. Ut i l i z ando un s et @Override
- Ref er enc i as a mét odos s t at i c
public static void main(String []args) { - Ref er enc i as a mét odos de i ns t anc i a public String toString() {
List<Integer> numbers= Arrays.asList(7, 7, 7, 7, 2, - Ref er enc i as a mét odos de una c l as e return "Person [name="+name+"]";
- Ref er enc i as a un c ons t r uc t or }
2, 2, 3, 3, 3, 3, 100, 100, 200, 200);
Set<Integer>nums= A c ont i nuac i ón s e pr es ent an al gunos }
numbers.stream().collect(Collectors.toSet()); ej empl os .
System.out.println(nums); names.stream().filter(StringUtils::isUpperCase).
}
map(Person::new).forEach(System.out::println);

www. t wi t t er . com/ devs4j www. f acebook. com/ devs4j www. devs4j . com
 Ejercicios

Sección 5 Programación
Sección 3 Primeros pasos
orientada a objetos
1. Real i z a un pr ogr ama c apaz de 1. Real i z a un di agr ama de c l as es Programación con Hilos
c al c ul ar el ár ea de un c uadr ado, que r epr es ent e mas c ot as .
c í r c ul o, r ec t angul o y t r i angul o.
2. Cr ea l as c l as es def i ni das en el 1. Cr ea un pr ogr ama donde un hi l o haga una c uent a
ej er c i c i o ant er i or , c ada una deber á r egr es i v a dado un númer o, el t i empo que debe es per ar
2. Toma el ej er c i c i o ant er i or y t ener más de un c ons t r uc t or y el el hi l o debe s er al eat or i o. I ni c i a 10 hi l os y r ev i s a
c ombi er t el o en un pr ogr ama c ódi go que s e ut i l i z a par a que hi l o t er mi no pr i mer o, as egur at e de c ol oc ar l e un
of us c ado, un pr ogr ama of us c ado es i ni c i al i z ar no s e deber á r epet i r . nombr e a c ada uno de el l os .
un pr ogr ama del c ual no s e ent i ende
s u f unc i onal i dad a s i mpl e v i s t a, 3. Haz debuggi ng s obr e l as c l as es 2. Modi f i c a el pr ogr ama ant er i or par a que t odos l os
haz us o de l os c onoc i mi ent os que del ej er c i c i o ant er i or par a que hi l os es per en el mi s mo t i empo as i gnal e di f er ent es
t i enes de i dent i f i c ador es par a que anal i c es el pas o a pas o de l a pr i or i dades a c ada uno de el l os y l anz a 30 hi l os ,
s ea al go di f í c i l de ent ender . ej ec uc i ón. r ev i s a s i el c ambi o de pr i or i dad gener ó al gún c ambi o.

3. Si mul a un pr ogr ama que haga t r ans ac c i ones banc ar i as

donde s e t engan que l l ev ar a c abo l as s i gui ent es
Sección 6 Herencia oper ac i ones al r et i r ar di ner o:

1. Pl ant ea 5 es c enar i os que hagan - Val i dar el mont o r ec i bi do

Sección 4 Control de flujo - Cons ul t ar s al do en l a c uent a y v al i dar s i es
us o de her enc i a, r ec uer da que deben
pas ar l a r egl a I S- A o ES- UN. s uf i c i ent e par a r et i r ar el mont o
1. Real i z a un pr ogr ama que i mpr i ma - Res t ar el mont o al s al do
l as t abl as de mul t i pl i c ar del 1 al 2. Ut i l i z a el di agr ama ant er i or y - dev ol v er el mont o a qui en i nv oc o el mét odo
20, debe ex i s t i r un es pac i o ent r e haz un pr ogr ama que l o r epr es ent e. - I mpr i mi r que s e r eal i z ó el r et i r o c on ex i t o
una y ot r a par a i dent i f i c ar l as . Cada c l as e debe t ener más de un
c ons t r uc t or y t odo debe f unc i onar Ej ec ut a l as oper ac i ones s obr e l a c uent a c on v ar i os
2. Modi f i c a el pr ogr ama ant er i or c or r ec t ament e, haz us o de l a hi l os s i n ut i l i z ar s i nc r oni z ac i ón t e r ec omendamos
par a que s ol o s e i mpr i man l as pal abr a r es er v ada s uper . hac er v ar i os r et i r os , des pués haz l o de nuev o c on
t abl as de mul t i pl i c ar de númer os s i nc r oni z ac i ón.
par es , par a i dent i f i c ar s i l os 3. Sobr ees c r i be al menos uno de l os
númer os s on par es puedes ut i l i z ar mét odos del ej er c i c i o ant er i or . 4. Pr ogr ama el al gor i t mo de l os hi l os f umador es , debes
el oper ador módul o c on 2 c omo s e de t ener 3 hi l os que s on l os f umador es el l os nec es i t an
mues t r a a c ont i nuac i ón: 3 c os as par a f umar , papel , t abac o y c er i l l os . A demás
debes t ener 3 hi l os pr oduc t or es c ada uno pr oduc i r á un
int x= 2; mat er i al di f er ent e una v ez que s e enc uent r en l os 3
Sección 8 Encapsulamiento y mat er i al es not i f i c a a l os hi l os que pueden i r por s us
mat er i al es par a f umar , s i no hay mat er i al es l os hi l os
polimorfismo f umandor es s e deben i r a un es t ado wai t i ng
if ( x % 2 == 0) {
1. Cr ea l as c l as es nec es ar i as par a
System.out.println("Es par"); r epr es ent ar a un aut omov i l ,
} r ec uer da que debes apl i c ar l os
c onc ept os de pol i mor f i s mo y Manejo de archivos y flujos
enc aps ul ami ent o.
3. Crea un programa utilizando ciclos que 1. Pr ogr ama el c omando di r par a l i s t ar l os ar c hi v os en
un di r ec t or i o es pec i f i c ado
imprima el factorial de un número, se calcula
multiplicando todos los números a partir del 2. Pr ogr ama el c omando c p par a c opi ar un ar c hi v o de un
número indicado hasta 1 y se representa con el Sección 9 y 10 Temas generales l ugar a ot r o
simbolo !, a continuación un ejemplo:
1. Cr ear un ar r egl o de c ada t i po de 3. Pr ogr ama el c omando mv par a mov er un ar c hi v o de un
dat o bool ean, by t e, s hor t , i nt , l ugar a ot r o.
4! = 4 x 3 x 2 x 1 = 24
c har , f l oat , l ong y doubl e.
7! = 7 × 6 × 5 × 4 × 3 × 2 × 1 = 5040 2. Cr ear un ar r egl o i r r egul ar en
f or ma de t r i angul o.
1! = 1 Sockets
3. Cr ear un ar r egl o de t i po Mas c ot a 1. Cr ea un pr ogr ama que a t r av és de un s oc k et env í e un
El factorial de 0 es 1. mens aj e depende del mens aj e el s er v i dor i mpr i mi r á
y l l enar l o c on obj et os de
di f er ent es s ubt i pos i ni c i ando, r ei ni c i ando o apagando.
4. Crea un progama que imprima las siguientes
figuras en la pantalla: 4. Real i z ar 2 ar r egl os 2. Cr ea un pr ogr ama donde el c l i ent e pueda env i ar un
bi di mens i onal es de l as mi s mas ar c hi v o al s er v i dor
di mens i ones y s umar l os .
3. Cr ea un pr ogr ama donde el c l i ent e pueda env i ar un
********** obj et o l l amado HTTPReques t que c ont enga l os s i gui ent es
at r i but os :
**********
Sección 11 Colecciones
********** - Body St r i ng
- Header s Map<St r i ng, St r i ng>
1. Cr ea una l i s t a de mas c ot as
********** modi f i c ando el ej empl o r eal i z ado en El s er v i dor deber á r es ponder un mens aj e c on l os
l a s es i ón ant er i or . s i gui ent es at r i but os :
* 2. Cr ea una i mpl ement ac i ón pr opi a de
- Body St r i ng
- Header s Map<St r i ng, St r i ng>
una l i s t a l i gada, t e r ec omendamos
** c r ear una c l as e Nodo que t enga c omo
- Ht t pSt at us I nt eger
*** at r i but os una r ef er enc i a al nodo
s i gui ent e y al ant er i or , debes
Puedes s el ec c i onar l a ac c i ón a r eal i z ar t e
r ec omendamos que s ea al go s i mpl e c omo l a s uma de dos
**** s opor t ar l as oper ac i ones agr egar númer os .
el ement o, bor r ar y bus c ar .
*****
3. Cr ea una c l as e que admi ni s t r e
l os el ement os de una l i s t a y t e Generales
per mi t a agr egar , bor r ar y bus c ar un 1. Cr ea un pr ogr ama que c or r a en un s er v i dor que t enga
el ement o. El úni c o r equi s i t o es que una l i s t a de per s onas , el c l i ent e debe s er c apaz de
* l a l i s t a no per mi t a dat os l eer l as per s onas , env i ar una per s ona nuev a y
dupl i c ados . modi f i c ar s us dat os .
**
4. Cr ea una i mpl ement ac i ón de al guna
*** de l as c ol ec c i ones par a es t o debes
Todo s e debe
s oc k et s , s i l
hac er de f or ma r emot a a t r av és de
o des eas puedes es c r i bi r un c omando s al i r
**** c r ear una c l as e que i mpl ement
de l as i nt er f ac es Li s t , Set ,
e una
Map,
que al ej ec ut ar l o s e t er mi ne el pr oc es o del l ado del
c l i ent e y del s er v i dor .
***** Queue, et c .
Al t er mi nar el pr oc es o del l ado del s er v i dor l a l i s t a
s e debe guar dar en un ar c hi v o c omo obj et os .

www. t wi t t er . com/ devs4j www. f acebook. com/ devs4j www. devs4j . com
 Java 9 - Modularidad
Java modular (Jigsaw) Uso de módulos
El J SR( J av a Spec i f i c at i on Reques t ) 376 - Una v ez que s e def i ni ó un módul o el
J av a pl at f or m modul e s y s t em pr ov ee: s i gui ent e pas o es ut i l i z ar l o, par a es t o Declaración de módulos
c r ear emos un nuev o módul o c on l a s i gui ent e
- Si mpl i f i c a l a c ons t r uc c i ón y el c l as e: Ant es de dec l ar ar l os módul os del s i s t ema
mant eni mi ent o de apl i c ac i ones gr andes y ut i l i z ando j av a - - l i s t - modul es , la
c ompl ej as package com.devs4j.calculator; dec l ar ac i ón de un módul o s e hac e c r eando
- Mej or a l a s egur i dad y el mant eni mi ent o del un ar c hi v o l l amado modul e- i nf o. j av an
J DK ( Modul ar i z andol o) i nc l uy endo el nombr e del módul o c omo s e
- Mej or a el per f or manc e de l as apl i c ac i ones import java.util.ArrayList; mues t r a a c ont i nuac i ón:
- Real i z a un enc aps ul ami ent o más f uer t e import java.util.List;
- Si mpl i f i c a s u es c al ami ent o hac i a abaj o par a module com.devs4j.calculation {
s er ut i l i z ado en di s pos i t i v i os más pequeños ...
import com.devs4j.math.calculation.CientificCalculator; }
Con es t o t endr emos una pl at af or ma más
es c al abl e c on un mej or per f or manc e. Requires
public class Devs4jTestCalculator {
Más i nf or mac i ón en public static void main(String []args) { Se ut i l i z a par a def i ni r l as dependenc i as
ht t ps : / / openj dk . j av a. net / pr oj ec t s / j i gs aw/ . CientificCalculator calc=new CientificCalculator(); de nues t r o módul o a c ont i nuac i ón un
ej empl o:
System.out.println(calc.sum(10, 20));
List<String>names=newArrayList<>(); module com.devs4j.calculation {
JEP's System.out.println(names); requires com.devs4j.math;
} }
Par a c ons egui r el pr oy ec t o J i gs aw s e c r ear on }
l os s i gui ent es J EP' s ( J DK Enhanc ement
pr opos al ) : Todos l os paquet es ex por t ados por el
Par a que el c ódi go ant er i or f unc i one s i n módul o def i ni do es t ar án di s poni bl es par a
- 200 - J av a modul ar J DK ni ngún pr obl ema s e deber á def i ni r l o s u us o.
- 201 - Modul ar Sour c e c ode s i gui ent e en el ar c hi v o modul e- i nf o. j av a:
- 220 - Modul ar r unt i me i mages
- 260 - Enc aps ul at e mos t of t he i nt er nal api s module com.devs4j.calculation { Requires static
- 261 - Modul e s y s t em requires java.base;
- 282 - J l i nk : The j av a l i nk er requires com.devs4j.math; Def i ne una dependenc i a que es opc i onal en
t i empo de ej ec uc i ón per o que es nec es ar i a
} en t i empo de c ompi l ac i ón.
Crear módulos El ar c hi v o ant er i or def i ne que nues t r o module com.devs4j.calculation {
pr oy ec t o r equi er e del paquet e requires static com.devs4j.math;
Un módul o es bás i c ament e un paquet e de c om. dev s 4j . mat h par a f unc i onar , l a }
paquet es or gani z ado por un ar c hi v o dec l ar ac i ón r equi r es j av a. bas e; no es
des c r i pt or , a c ont i nuac i ón s e pr es ent a un nec es ar i a dado que s e hac e de maner a
ej empl o donde s e ut i l i z a modul ar i dad: i mpl í c i t a per o es l a que per mi t e que
ut i l i c emos c l as es c omo Ar r ay Li s t . Requires transitive
package com.devs4j.math.calculation;
Cuando dependemos de un modul o que a s u
Archivo module-info.java v ez t i ene dependenc i as ut i l i z ar emos
import com.devs4j.math.operations.CalculatorProcessor; r equi r es t r ans i t i v e c omo s e mues t r a a
Cuando s e c r ea un nuev o módul o s e debe c r ear c ont i nuac i ón:
public class ScientificCalculator{ un ar c hi v o des c r i pt or l l amado
private CalculatorProcessor processor=new modul e- i nf o. j av a el c ual puede def i ni r l o module com.devs4j.calculation {
CalculatorProcessor(); s i gui ent e: requires transitive com.devs4j.math;
- Nombr e : Nombr e del módul o }
public int sum(int x,int y) { - Dependenc i es : Li s t a de dependenc i as del
return processor.sum(x,y); módul o
} - Paquet es publ i c os : Li s t a de paquet es Exports
} ac c es i bl es f uer a del módul o
- Ser v i c i os of r ec i dos: Li s t a de s er v i c i os que Por def aul t un módul o no ex pone ni nguno
pueden c ons umi r ot r os módul os de l os paquet es , por mot i v os de
Ci ent i f i c Cal c ul ar or ut i l i z a l a c l as e enc aps ul ami ent o f uer t e( St r ong
- Ser v i c i os a c ons umi r : Li s t a de s er v i c i os a
Cal c ul ar or Pr oc es s or que s e mues t r a a c ons umi r de ot r os módul os enc aps ul at i on) debemos def i ni r de f or ma
c ont i nuac i ón: ex pl í c i t a l os paquet es que s er án
- Ref l ec t i on per mi s s i ons: Per mi t e def i ni r de
f or ma ex pl í c i t a el ni v el de ac c es o que s e ac c es i bl es c omo s e mues t r a a
package com.devs4j.math.operations; c ont i nuac i ón:
t endr á al ut i l i z ar r ef l ec t i on.
public class CalculatorProcessor { La c onv enc i ón de nombr es de l os módul os es module com.devs4j.math {
public int sum(int x,int y) { s i mi l ar a l a de l os paquet es . exports com.devs4j.math.calculation;
return x+y; }
Por def aul t t odos l os paquet es de un módul o
} s on pr i v ados .
} Puedes ut i l i z ar ex por t s . . . t o . . . par a
r es t r i ngi r l os módul os que pueden
Se puede obs er v ar que s e t i enen l os i mpor t ar el paquet e es pec i f i c ado.
Tipos de módulos
s i gui ent es 2 paquet es :
A c ont i nuac i ón s e l i s t an l os t i pos de
package com.devs4j.math.calculation; módul os di s poni bl es :
package com.devs4j.math.operations;
- Sy s t em modul es: Li s t a de módul os que
Cal c ul at i on def i ne l a i nt er f az a c ompar t i r c ont i enen l os módul os del J DK puedes
c on ot r os pr oy ec t os y oper at i ons c ont i ene ac c eder a el l os ut i l i z ando el c omando l i s t
l os det al l es de i mpl ement ac i ón, por es t o modul es .
s ol o deber í amos ex poner el paquet e - Appl i c at i on modul es: Módul os que c r ear emos
c al c ul at i on dado que oper at i ons s ol o s e y nombr ar emos dur ant e l a c ons t r uc c i ón de
ut i l i z a i nt er nament e, par a hac er l o c r ear emos nues t r as apl i c ac i ones .
un ar c hi v o l l amado modul e- i nf o. j av a c on l a - Aut omat i c modul es: Módul os que es t ar án
s i gui ent e i nf or mac i ón: di s poni bl es al i nc l ui r un ar c hi v o j ar . Por
def aul t t endr an c ompl et o ac c es o de l ec t ur a
module com.devs4j.math { a t odos l os módul os agr egados al pat h.
- Unnamed modul es : Son ut i l i z ados par a t ener
exports com.devs4j.math.calculation;
c ompat i bi l i dad c on v er s i ones ant er i or es de
} j av a s e ut i l i z an c uando no s e i nc l uy e
ni ngún t i po de módul o.
El ar c hi vo modul e i nf o def i ne que s ol o el
paquet e c al c ul at i on s e ex podr á y al no Los módul os pueden s er di s t r i bui dos a t r av és
i nc l ui r el paquet e oper at i ons s e mant endr á de ar c hi v os j ar ( Sol o podemos t ener un módul o
c omo un det al l e de i mpl ement ac i ón. por j ar ) .

www. t wi t t er . com/ devs4j www. f acebook. com/ devs4j www. devs4j . com
 Java 9 - Modularidad
Produce / Consume
Reflection
services
Los módul os pueden pr oduc i r y c ons umi r Ref l ec t i on es un api que t e per mi t e Probando reflection con
s er v i c i os , más que s ol o paquet es , un s er v i c i o t r abaj ar c on c l as es , obj et os , mét odos y
es una i nt er f az que puede t ener múl t i pl es ot r os c omponent es del l enguaj e c omo módulos
i mpl ement ac i ones , a c ont i nuac i ón al gunos punt os c l as es que podemos mani pul ar a Es t i empo de c ombi nar l os dos ej empl os
i mpor t ant es : c ont i nuac i ón un ej empl o: ant er i or es par a ent ender el
f unc i onami ent o de opens , par a es t o s e
- pr ov i des <s er v i c e i nt er f ac e> wi t h <c l as s es > package com.devs4j.reflection.service; modi f i c ar án l os s i gui ent es c omponent es :
es pec i f i c a que el módul o pr ov ee una o más
i mpl ement ac i ones que pueden s er des c ubi er t as class ApplicationService { Ser v i c e
de f or ma di námi c a por el c ons umer .
- us es <s er v i c e i nt er f ac e> es pec i f i c a una void sayHello() { package com.devs4j.reflection.app;
i nt er f az o c l as e abs t r ac t a que s e des ea System.out.println("Hello");
c ons umi r . }
} class ApplicationService {
A c ont i nuac i ón un ej empl o:
void sayHello() {
package com.devs4j.reflection.user;
Ser v i c e System.out.println("Hello");
}
package com.devs4j.service.auth; }
import java.lang.reflect.Constructor;
import java.lang.reflect.Method;
module com.devs4j.service {
public interface UserAuthentication { exports com.devs4j.service.auth;
public boolean authenticate(String username, String exports com.devs4j.reflection.app;
password); public class TestApplicationService {
}
} public static void main(String []args)throws Exception
module com.devs4j.service { { Se puede obs er v ar que s e ui l i z a ex por t s
exports com.devs4j.service.auth; Class<?>classObject= Class.forName por l o que el ac c es o a t r av és de
} ("com.devs4j.reflection.service.ApplicationService"); r ef l ec t i on s er á r es t r i ngi do.

Pr ov i der Constructor<?>constructor= Appl i c at i on

classObject.getDeclaredConstructor(); public class TestAuthenticationApplication {
module com.devs4j.provider {
requires com.devs4j.service; public static void main(String []args) {
constructor.setAccessible(true); ServiceLoader<UserAuthentication>service=
provides com.devs4j.service.auth.UserAuthentication Object instance=constructor.newInstance();
with UserDatabaseAuthenticator; ServiceLoader.load(UserAuthentication.class);
} Method[]methods=classObject.getDeclaredMethods(); UserAuthenticationuserAuthentication=
for(Methodmethod:methods) { service.findFirst().get();
Appl i c at i on
System.out.printf("Method %s, is accessible
public class TestAuthenticationApplication { \n",method.getName(),method.canAccess(instance)); boolean authenticated= userAuthentication.
public static void main(String[] args) { authenticate("raidentrance","udemy");
ServiceLoader<UserAuthentication> service = if(method.getName().equals("sayHello")) {
ServiceLoader.load(UserAuthentication.class); method.setAccessible(true); System.out.println(authenticated);
method.invoke(instance); }
UserAuthentication userAuthentication = } }
service.findFirst().get(); }
} Se puede obs er v ar que s e ui l i z a ex por t s
boolean authenticated = } por l o que el ac c es o a t r av és de
userAuthentication.authenticate("raidentrance","udemy"); r ef l ec t i on s er á r es t r i ngi do.
Como s e puede v er Appl i c at i onSer v i c e
t i ene un ni v el de ac c es o def aul t , es t o Al ej ec ut ar el c ódi go ant er i or
System.out.println(authenticated); obt endr emos l a s i gui ent e ex c epc i ón:
ev i t a que puedas ut i l i z ar l a f uer a del
} paquet e com.devs4j.reflection.service s i n
} embar go hac i endo us o de r ef l ec t i on Ex c ept i on i n t hr ead " mai n"
j av a. l ang. r ef l ec t . I nac c es s i bl eObj ec t Ex c ept i on:
podemos t ener ac c es o s i n i mpor t ar s i l a Unabl e t o mak e
module com.devs4j.application { c l as e s e enc uent r a f uer a del paquet e. c om. dev s 4j . r ef l ec t i on. app. Appl i c at i onSer v i c e( )
requires com.devs4j.service; ac c es s i bl e: modul e c om. dev s 4j . s er v i c e does not
uses UserAuthentication; " opens c om. dev s 4j . r ef l ec t i on. app" t o modul e
c om. dev s 4j . appl i c at i on
}
Open Par a per mi t i r el ac c es o a t r av és de
r ef l ec t i on debemos modi f i c ar l a
Los módul os pueden per mi t i r ac c es o a def i ni c i ón del módul o en s er v i c e c omo s e
t r av és de r ef l ec t i on ut i l i z ando open. mues t r a a c ont i nuac i ón:

- opens <paquet e> i ndi c a que s e per mi t i r á module com.devs4j.service {

uses ac c es o a t r av és de r ef l ec t i on exports com.devs4j.service.auth;
require - opens <paquet e> t o <modul e> r es t r i nge l a opens com.devs4j.reflection.app;
Application Service aper t ur a de l os paquet es a al gún modul o }
en es pec í f i c o.
Opens f unc i ona i gual que ex por t c on l a Una v ez r eal i z ado el c ambi o l a ej ec uc i ón
di f er enc i a que per mi t e ac c es o a l os t i pos del mét odo debe s er c or r ec t a
no públ i c os a t r av és de r ef l ec t i on.
requires
provides

Provider

www. t wi t t er . com/ devs4j www. f acebook. com/ devs4j www. devs4j . com
 Java 9
Try with resources Cuando utilizar JShell
Tr y wi t h r es our c es apar ec i ó en l a v er s i ón 7 Puedes ut i l i z ar J Shel l par a es c r i bi r
de j av a c on l a s i gui ent e es t r uc t ur a: el ement os una v ez e i nmedi at ament e obt ener Commands
r es ul t ados .
try(InputStreamReader isr=new InputStreamReader(System.in);){ Puedes ut i l i z ar c omandos par a c ont r ol ar
el ambi ent e y mos t r ar i nf or mac i ón a
} c ont i nuac i ón al gunos ej empl os :

A par t i r de l a v er s i ón 9 de J av a podr emos Configuración jshell> /vars

r eal i z ar l as dec l ar ac i ones f uer a del t r y
c omo s e mues t r a a c ont i nuac i ón: Par a poder ej ec ut ar el c omando j s hel l y | int x = 45
ut i l i z ar l o debes i ns t al ar el J DK de j av a y
agr egar a l as v ar i abl es de ent or no | int $3 = 4
InputStreamReader isr = new InputStreamReader(System.in); j av a- home/ j dk - 9/ bi n.
try(isr) {
| String $5 = "OceanOcean"
Una v ez que s e c onf i gur a l a v ar i abl e de
ent or no puedes ej ec ut ar el c omando j s hel l
} c omo s e mues t r a a c ont i nuac i ón: jshell> /methods
% jshell | twice (String)String
Extensión al operador
diamante | Welcome to JShell -- Version 9
En J av a 7 s e agr egó el s opor t e par a ut i l i z ar | For an introduction type: /help intro jshell> /list
el oper ador di amant e c omo s e mues t r a a
c ont i nuac i ón: jshell> 1 : System.out.println("Hi");
2 : int x = 45; 3:2+2
List<Integer>list=new ArrayList<>();
Para salir de jshell utiliza el comando /exit como se 4 : String twice(String s) {return s + s;}
Una de l as r es t r i c c i ones que s e t ení a es que
el oper ador di amant e no s e podí a apl i c ar a muestra a continuación: 5 : twice("Ocean")
c l as es anóni mas y s e debí a hac er del
s i gui ent e modo:
jshell> /exit Puedes escribir / y utilizar tab para obtener los
interface Foo<T>{}
| Goodbye comandos disponibles.
public static void main(String []args) {
Foo<Integer>foo=new Foo<Integer>() {
};
Snippets Puedes utilizar abreviaciones como /l, /se fe v (set
}
J s hel l ac ept a s ent enc i as j av a; v ar i abl es , feedback verbose)
A par t i r de J av a 9 y a puedes ut i l i z ar el mét odos , c l as es , i mpor t s y ex pr es i ones .
oper ador di amant e c on c l as es abs t r ac t as c omo Es t as pi ez as de c ódi go s on c onoc i das c omo
s e mues t r a a c ot i nuac i ón: s ni ppet s . Feedback
interface Foo<T> {
Dec l ar ac i ón de v ar i abl es Puedes ut i l i z ar el f eedbac k mode par a
}
det er mi nar l as r es pues t as y ot r as
public static void main(String []args) {
jshell> int x = 45 i nt er ac c i ones c on j s hel l .
Foo<Integer> foo=new Foo<>() { x ==> 45
};
Los f eedbac k s di s poni bl es s on:
} | created variable x : int - v er bos e
- nor mal
- c onc i s e
Métodos privados en Evaluación de expresiones - s i l ent
interfaces
jshell> 2 + 2 Par a c ambi ar el t i po de f eedbac k ut i l i z a
A par t i r de l a v er s i ón J av a 9 puedes def i ni r el s i gui ent e c omando:
mét odos pr i v ados c on el f i n de que s ean $3 ==> 4
ut i l i z ados por l os mét odos def aul t , c omo s e / s et f eedbac k v er bos e
mues t r a a c ont i nuac i ón: | created scratch variable $3 : int
jshell> String twice(String s) { Pr ueba l os di f er ent es t i pos de f eedbac k
interface Bar { par a v er l os di f er ent es t i pos de
private void foo() { ...> return s + s; i nt er ac c i ón que puedes t ener .
}
...> } Scripting
private static void foo2() { | created method twice(String) Puedes es c r i bi r s c r i pt s en ar c hi v os c on
} jshell> twice("Ocean") ex t ens i ón . j s h, pueden s er gener ados c omo
s al i das de l as ent r adas del s hel l c omo s e
$5 ==> "OceanOcean" mues t r a a c ont i nuac i ón:
default void foo3() {
| created scratch variable $5 : String jshell> /save mysnippets.jsh
foo();
foo2(); jshell> /save -history myhistory.jsh
}
Cambiando la definición jshell> /save -start mystartup.jsh
}
jshell> String twice(String s) {
Es i mpor t ant e menc i onar que l os mét odos
abs t r ac t os deben s egui r s i endo publ i c . ...> return "Twice:" + s; Puedes ejecutarlos como se muestra a
...> } continuación:
JShell | modified method twice(String) % jshell mysnippets.jsh
J Shel l ( J av a Shel l ) es una her r ami ent a jshell> twice("thing") Para cargar un script puedes utilizar /open como
i nt er ac t i v a par a el apr endi z aj e del l enguaj e
j av a, s e ut i l i z a par a ev al uar dec l ar ac i ones , $7 ==> "Twice:thing" se muestra a continuación:
s ent enc i as y ex pr es i ones , es t as | created scratch variable $7 : String
i nmedi at ament e mos t r ar án l os r es ul t ados .
jshell> /open PRINTING

www. t wi t t er . com/ devs4j www. f acebook. com/ devs4j www. devs4j . com