Material+del+curso+de+Java

Conceptos básicos
Compilación y ejecución
Tipos de datos
Compi l ac i ón
Ti po
Tamaño
javac Nombr eDel Ar c hi v o. j av a
boolean
byte
short
char
int
float
long
double
no det er mi nado
1 by t e
2 by t es
2 by t es
4 by t es
4 by t es
8 by t es
8 by t es
Ej ec uc i ón
java Nombr eDel Ar c hi v o
Pas o de par ámet r os
java Nombr eDel Ar c hi v o ar g1 ar g2
Sentencia if
if (ex pr es i ón bool eana) {
//Acción en caso verdadero
} else {
//Acción en caso falso
}
if (ex pr es i ón bool eana) {
//Acción en caso verdadero
} else if (ex pr es i ón bool eana) {
/**
* Acción en caso de que la segunda
condición sea verdadera
**/
} else {
/**
* Acción en caso de que ninguna
condición se cumpla
**/
}
Loop while
while (ex pr es i ón bool eana ) {
//Sentencias a repetir
At aj os
a + b
a - b
a * b
a / b
a %b
a ++
a -++ a
-- a
/*
* Sentencias a repetir, se ejecuta al
menos una vez
*/
} while (true);
For loop
for (i ni c i al i z ac i ón;
ev al uac i ón;i nc r ement o / dec r ement o
/ ac c i ón) {
// Sentencias a repetir
}
for (int i = 0; i < 10; i++) {
// Sentencias a repetir
}
c ont i nue: Dej a de ej ec ut ar l a
i t er ac i ón ac t ual y s al t a a l a
s i gui ent e.
a - =1 Dec r ement a a en 1
Operadores de comparación
private
Mi s ma c l as e
default
Mi s mo paquet e
protected
Di f er ent e paquet e a
t r av és de her enc i a
public
Des de c ual qui er
l ugar
a = t r ue
AND
OR
NOT
a
a
a
a
a
a
<
>
<=
>=
==
!=
b
b
b
b
b
b
t i po de dat o nombr e = v al or
a && b = f al s e
a | | b = t r ue
a ! = f al s e
En c as o de que no s e des ee es e
c ompor t ami ent o y s e qui er an
ej ec ut ar ambos , es pos i bl e
ut i l i z ar & y | .
Sentencia switch
switch (e) {
Perro roscko=new Perro();
Operador ternario
( ex pr es i ón bool eana ) ?
v al or s i es v er dader o :
v al or s i es f al s o
Ej empl o
int x = 0 ;
boolean permitirPaso = (edad > 18)
? true : false;
[ modi f i c ador de ac c es o] [ t i po de
dat o] [ nombr e de v ar i abl e] = v al or ;
Definición de métodos
[ modi f i c ador de ac c es o] v al or de
r et or no nombr e del mét odo
( par ámet r os ) {
/ / Sent enc i as
}
Ej empl o
public String getName(){
return "Alex";
}
/*
* sentencias en caso de que e sea
igual a 'a'
nombr e de
*/
default:
/*
* sentencias en caso de que e no
sea ninguna de las anteriores
*/
Oper ador OR
public Perro(String name) {
System.out.print("Se creó " + name);
}
[ modi f i c ador de ac c es o] class
Nombr eDeLaCl as e {
/ / At r i but os
/ / Cons t r uc t or es
/ / Mét odos
}
En una c l as e : Hac e que no
s e pueda her edar de el l a.
En un mét odo : Hac e que no
s e pueda s obr ees c r i bi r .
En una v ar i abl e pr i mi t i v a:
No s e puede c ambi ar s u
v al or .
En una r ef er enc i a : El
obj et o s e puede c ambi ar
per o no s e puede apunt ar a
ot r o.
public class Perro {
private String nombre;
public Perro() {
}
public void ladrar() {
System.out.print("WOW");
}
}
}
www. t wi t t er . com/ devs4j
www. f acebook. com/ devs4j
|
Oper ador XOR ^
Ej empl o
break;
break;
Cor r i mi ent o a l a i z qui er da
<<
Palabra reservada
final
Definición de una clase
/*
* sentencias en caso de que e sea
igual a 'b'
Operadores a nivel
de bits
Oper ador AND &
break;
case 'b':
boolean res=a instanceof Perro;
Cor r i mi ent o a l a der ec ha
>>
Definición de constructores
[ modi f i c ador de ac c es o]
l a c l as e ( par ámet r os ) {
/ / Sent enc i as
}
Operador instanceof
Dev uel v e v er dader o s i a es
una i ns t anc i a c r eada a
par t i r de l a c l as e Per r o
ej empl o
public int edad=18;
Ej empl o
case 'a':
for (int temp : array) {
}
Ej empl o
Ej empl o
b=f al s e
Not a: && y | | s e l es c onoc e
c omo de cor t o ci r cui t o de t al
modo que, s i c on ev al uar el
pr i mer el ement o es s uf i c i ent e
par a det er mi nar el r es ul t ado,
el s egundo el ement o no s e
ev al úa.
For each loop
// Sentencias a repetir
[ Ref er enc i a] nombr e=new
Cons t r uc t or ( par ámet r os ) ;
Definición de variables
*/
outer: for (int i = 0; i <= 10; i++) {
for (int j = 0; j <= 10; j++) {
if (i == 5) {
break outer;
}
}
}
Comentarios de una
sola línea
// Comentario
Comentarios de multiples
líneas
/*
Comentario
de múltiples
líneas
*/
Creación de objetos
Definición de atributos
menor que
may or que
menor o i gual
may or o i gual
I gual
Di f er ent e
br eak : Rompe el c i c l o ac t ual .
Es pos i bl e ut i l i z ar t ags par a
det er mi nar c ual de l os dos c i c l os
s e des ea r omper .
0
0
0
' \ u0000'
0
0. 0f
0
0. 0d
Niveles de acceso
de as i gnac i ón
Operadores lógicos
do {
Def aul t
a +=1; I nc r ement a a en 1
}
Loop do while
Ej empl o
t r ue / f al s e
128
32, 767
' a'
212, 345
1234. 12F
123948573L
1247593. 1739
Operadores aritméticos
Suma
Res t a
Mul t i pl i c ac i ón
Di v i s i ón
Módul o
I nc r ement o
Dec r ement o
Pr e i nc r ement o
Pr e dec r ement o
Comentarios
www. devs4j . com
Programación orientada a objetos
Nombre de la
clase
Figura
+ color:String
Atributos
Persona
Modificador de acceso:
+ calcularArea() : double
- calcularPerimetro() : double
Métodos
+ nombre:String
+ fechaDeNacimiento:String
+ Public
+ dormir() : void
+ respirar() : void
+ comer() : void
- Private
# Protected
Circulo
Cuadrado
Estudiante
+ radio:double
+ lado:double
+ calcularArea() : double
- calcularPerimetro() : double
+ calcularArea() : double
- calcularPerimetro() : double
Herencia
Circulo c=new Circulo();
double area=c.calcularArea();
Cada clase que herede de Figura puede crear
su propia implementación de los métodos
calcularArea() y calcularPerimetro().
Estudiante e=new Estudiante();
e.dormir();
e.respirar();
e.aprobar();
Es posible asignar un objeto de tipo Circulo a
una referencia de tipo Figura gracias al
polimorfismo.
Persona e=new Estudiante();
e.dormir();
e.respirar();
Es posible asignar un objeto de tipo
Estuidiante a una referencia de tipo Persona
gracias al polimorfismo.
IS A
Para poder determinar si una clase hereda de
otra debe pasar el test IS A (ES UN), veamos
algunos ejemplos:
Libro is a Cuaderno
-No cumple
Coche is a Vehiculo
-Cumple
+ aprobar() : void
+ reprobar() : void
+presentarExamen
(ExamenNormal e) : float
+presentarExamen
(ExamenExtraordinario e) : float
+ trabajar() : void
+ cobrar() : void
Motor
+avanzar():void
Figura c=new Circulo();
double area=c.calcularArea();
-Cumple
+ sueldo:float
- motor:Motor
Polimorfismo
Perro is an Animal
+ numeroDeCuenta:int
Coche
Estudiante hereda de Persona, por esto es
posible invocar a los métodos definidos en ella
sin tener que re escribirlos.
Si cumple la relación significa que podemos
utilizar herencia entre las dos clases, en caso
contrario no podemos hacerlo.
HAS A
HAS A (Tiene un ) es una relación también
conocida como composición e indica que una
clase tiene como atributo a un objeto de otra
clase el cual puede utilizar para invocar a sus
métodos, por ejemplo la clase Coche tiene un
Motor y puede invocar a su método encender.
www. t wi t t er . com/ devs4j
Empleado
+encender():void
Encapsulamiento
El encapsulamiento permite ocultar parte de nuestro
código y exponer solo lo que deseamos, en la clase
Examen podemos acceder al valor de la calificación,
pero solo a través de métodos getter y setter.
Examen
- calificacion:float
- numeroDePreguntas: int
+ getCalificacion() : float
+ setCalificacion(float calif) :
float
- float sumaAciertos() : float
- float generaPromedio() :
float
Examen e=new Examen();
float calificacion = e.getCalificacion();
Si se quiere acceder directamente a la calificación
sin utilizar el método getCalificación del siguiente
modo:
Examen e=new Examen();
e.calificacion;
Obtenremos el siguiente error de compilcación:
The field Examen.calificacion is not visible
De igual modo el encapsulamiento nos permite
ocultar métodos que son utilizados internamente por
nuestra clase para no exponerlos a otras clases, un
ejemplo de esto son los métodos:
private float sumarAciertos()
private float generarPromedio()
Sobreescritura
La sobreescritura de métodos permite cambiar el
comportamiento de un método heredado de una
clase padre.
Como se puede ver la clase Figura define el método
calcularArea() , pero una figura por si misma no
puede calcular un área, quien sabe como hacerlo
son las clases Circulo y Cuadrado, por esto
sobreescriben el método, a continuación algunas
reglas:
-Los argumentos del método deben ser
exactamente los mismos del que va a sobreescribir
-El valor de retorno debe ser el mismo o un
subtipo del que se desea sobreescribir
-El nivel de acceso no puede ser más restrictivo
que el que se va a sobreescribir
-Los métodos final no se pueden sobreescribir
www. f acebook. com/ devs4j
Sobrecarga
La sobrecarga de métodos permite tener 2 métodos
con el mismo nombre, la única regla es que deben
recibir parámetros diferentes, un ejemplo de esto son
los métodos :
public float presentarExamen(ExamenNormal e )
public float presentarExamen(ExamenExtraordinario
e)
Los dos métodos se encuentran en la clase
Estudiante y ambos reciben parámetros distintos.
La sobrecarga se puede aplicar también a
constructores, permitiendo crear nuestros objetos
de diferentes formas de acuerdo al problema, a
continuación se presentan algunas reglas:
-Los métodos deben tener el mismo nombre
-Los métodos deben recibir diferentes parámetros
-Los métodos pueden tener diferentes valores de
retorno
-Los métodos pueden arrojar diferentes
excepciones
Constructores
Constructores, static, interfaces, etc.
Los obj et os s e c r ean a t r av és de
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 :
- No t i enen v al or de r et or no
- Su nombr e es el mi s mo de l a c l as e
- Es pos i bl e t ener mul t i pl es c ons t r uc t or es
s i empr e y c uando es t én s obr ec ar gados .
- Pueden t ener c ual qui er modi f i c ador de
ac c es o.
- Si no s e dec l ar a un c ons t r uc t or J av a
c r ear á uno por def ec t o
- El c ons t r uc t or por def ec t o no r ec i be
par ámet r os
- Si s e dec l ar a un c ons t r uc t or , s e
r enunc i ar á al c ons t r uc t or por def ec t o
Static
La pal abr a r es er v ada s t at i c s e ut i l i z a
par a c r ear v ar i abl es y mét odos que
ex i s t i r án i ndependi ent ement e de s i ex i s t e
o no una i ns t anc i a( obj et o) de una c l as e.
Ex i s t i r á s ol o una c opi a de un mét odo /
at r i but o s t at i c s i n i mpor t ar el númer o de
obj et os que t enga l a c l as e.
Variables static
Cuando s e t i ene una v ar i abl e s t at i c s e
t endr á s ol o una c opi a de es t a par a t odas
l as i ns t anc i as , v eamos el s i gui ent e
ej empl o:
Métodos static
Es pos i bl e ej ec ut ar un mét odo s t at i c s i n
nec es i dad de c r ear un obj et o, v eamos el
s i gui ent e ej empl o:
public class Calculadora {
static int suma(int x, int y) {
return x + y;
}
Ej empl o:
public class Perro {
private String nombre;
private String raza;
public Perro() {
}
public Perro(String n, String r) {
nombre = n;
raza = r;
}
......
}
La c l as e ant er i or t i ene 2 c ons t r uc t or es ,
uno que no r ec i be par ámet r os y el ot r o
que r ec i be c omo par ámet r o el nombr e y l a
r az a del per r o. Las s i gui ent es s on f or mas
v ál i das par a c r ear un obj et o de t i po
Per r o:
Perro p=new Perro();
Perro p2=new Perro("Roscko","Terrier escocés");
Invocación de un
constructor desde otro
Es pos i bl e i nv oc ar un c ons t r uc t or des de
ot r o, par a hac er l o, s e hac e us o de l a
pal abr a r es er v ada t hi s, v eamos l a c l as e
Per r o modi f i c ada:
public class Perro {
private String nombre;
private String raza;
public class Humano {
static int numeroDeHumanos = 0;
public Humano() {
numeroDeHumanos++;
}
public static void main(String[] args) {
new Humano();
new Humano();
new Humano();
System.out.println(numeroDeHumanos);
}
}
Sal i da : 3
Del c ódi go ant er i or podemos v er l o
s i gui ent e:
- La v ar i abl e numer oDeHumanos ex i s t e
s i n i mpor t ar s i hay obj et os o no c r eados ,
i ni c i al ment e t i ene un v al or de c er o.
- Cada que s e c r ea un obj et o Humano s e
aument a en uno
- Es pos i bl e ac c eder a el l a s i n
nec es i dad de c r ear un obj et o
- Su v al or es c ompar t i do por t odos l os
obj et os
- 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
s i gui ent e modo Nombr eCl as e. v ar i abl e.
Uso de la palabra
reservada this
La pal abr a r es er v ada this s e ut i l i z a par a
r ef er enc i ar al obj et o ac t ual , v eamos el
s i gui ent e ej empl o :
public class Perro {
private String nombre;
private String raza;
public Perro() {
public Perro(String nombre, String raza) {
nombre = nombre;
raza = raza;
}
......
this("NombrePorDefecto","RazaPorDefecto");
}
public Perro(String n, String r) {
nombre = n;
raza = r;
}
......
}
En el ejemplo anterior el constructor que no recibe
parámetros invoca al que si recibe y asígna un nombre
y una raza por defecto, cuando se hace uso de la
palabra reservada this para invocar a otro constructor,
esta debe ser la primera línea de código.
}
En es t e ej empl o l as as i gnac i ones no
f unc i onan dado que l os par ámet r os s e
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
as i gnar a l os at r i but os de l a c l as e
ut i l i z ar emos l a pal abr a r es er v ada t hi s
del s i gui ent e modo:
public class Perro {
private String nombre;
private String raza;
public Perro(String nombre, String raza) {
this.nombre = nombre;
this.raza = raza;
}
Invocación a un constructor
de la clase padre
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
ej ec ut ar s e, i nc l us o s i nos ot r os no l o
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:
......
}
Cohesión
public Perro() {
super();
}
super( ) al i gual que this( ) s e ut i l i z a par a
ej ec ut ar un c ons t r uc t or , l a di f er enc i a
ent r o uno y ot r o es que t hi s ej ec ut a uno
en l a c l as e ac t ual y s uper uno en l a
c l as e padr e.
www. t wi t t er . com/ devs4j
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
t i ene un s ol o pr opos i t o bi en def i ni do.
Una c l as e bi en enf oc ada t endr á al t a
c ohes i ón, mi ent r as más c ohes i ón t engamos
nues t r as c l as es s er án más f ác i l es de
mant ener .
www. f acebook. com/ devs4j
static int resta(int x, int y) {
return x - y;
}
public static void main(String[] args) {
System.out.println(suma(10, 20));
}
}
Podemos ver que desde el método main se invoca al
método suma sin necesidad de crear un objeto de la
clase Calculadora,
Interfaces
Cuando i mpl ement as una i nt er f az ac ept as
el c ont r at o de i mpl ement ar s us mét odos .
Una i nt er f az def i ne mét odos s i n
i mpl ement ac i ón , c ons t ant es y mét odos
def aul t , v eamos el s i gui ent e ej empl o:
public interface Dibujable {
void dibujar();
}
Las i nt er f ac es deben s er adj et i v os ,
v eamos al gunas i mpl ement ac i ones de l a
i nt er f az Di buj abl e:
public class Rectangulo implements Dibujable{
@Override
public void dibujar() {
System.out.println("Dibujando rectangulo");
}
}
public class Pared implements Dibujable {
@Override
public void dibujar() {
System.out.println("Dibujando en la pared");
}
}
Las c l as es Rec t angul o y Par ed i mpl ement an
l a i nt er f az di buj abl e, por es t o deben
s obr e es c r i bi r el mét odo di buj ar .
A par t i r de
ut i l i z ar def
per mi t en def
i nt er f ac es ,
l a v er s i ón J av a 8
aul t met hods , l os
i ni r una i mpl ement
v eamos el s i gui ent
es pos i bl e
c ual es
ac i ón en
e ej empl o:
interface A{
default void foo(){
System.out.println("Método default");
}
void bar();
}
En el ejemplo anterior tenemos 2 métodos, foo() es un
método default, por tanto la clase que implemente la
interfaz A no esta obligada a implementarlo, mientras
que bar() debe ser implementado.
Acoplamiento
Ac opl ami ent o es el gr ado en el que una
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
t i ene un al t o ac opl ami ent o.
El al t o ac opl ami ent o c ompl i c a el
mant eni mi ent o de l as apl i c ac i ones , por
es t o s i empr e bus c ar emos r educ i r l o
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
i mpl ement ac i ón s e c onoc e c omo mét odo
abs t r ac t o. Una c l as e abs t r ac t a es una
c l as e que puede c ont ener mét odos
abs t r ac t os y mét odos c onc r et os :
En J av a l os ar r egl os s on obj et os que
al mac enan mul t i pl es v al or es del mi s mo
t i po, una v ez def i ni do el t amaño es t e no
puede c ambi ar , v eamos al gunos punt os a
c ons i der ar :
public abstract class Figura {
private String material;
- Pueden al mac enar pr i mi t i v os y
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;
}
public void setMaterial(String material) {
this.material = material;
}
public abstract double calcularArea();
}
public class Circulo extends Figura {
private double radio;
@Override
public double calcularArea() {
return Math.PI * Math.pow(radio, 2);
}
//Getters y setters de radio
}
public class Cuadro extends Figura {
private double lado;
@Override
public double calcularArea() {
return lado*lado;
}
//Getters y setters de lado
}
Dado que l a f i gur a por s i s ol a no s abe
c omo r eal i z ar un c ál c ul o de ár ea el
mét odo c al c ul ar Ar ea es def i ni do c omo
abs t r ac t o, l a i mpl ement ac i ón debe
i mpl ement ar es e mét odo.
Regl as i mpor t ant es :
- Una c l as e abs t r ac t a no puede s er
f i nal .
- 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
- No s e pueden c r ear obj et os de una
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
mét odos s t at i c en l a c l as e abs t r ac t a.
- 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
c ambi en.
- Un mét odo abs t r ac t o no puede s er
def i ni do c omo f i nal .
- Si una c l as e abs t r ac t a i mpl ement a
una i nt er f az , puede no i mpl ement ar s us
mét odos , per o l a c l as e que her ede de el l a
debe i mpl ement ar l os .
- Los mét odos abs t r ac t os no pueden s er
s t at i c .
- Una i nt er f az es una c l as e 100%
abs t r ac t a.
Identificadores
Un i dent i f i c ador es el nombr e que
as i gnamos a l as c os as en J av a, es t os
deben s egui r l as s i gui ent es r egl as :
- Pueden i ni c i ar c on una l et r a, gui ón
baj o o s í mbol o de moneda.
- Des pués del pr i mer c ar ac t er s e
pueden i nc l ui r númer os.
- Pueden t ener c ual qui er l ongi t ud.
- No s e pueden ut i l i z ar pal abr as
r es er v adas c omo i dent i f i c ador es .
- Los i dent i f i c ador es s on c as e
s ens i t i v e, FOO y f oo s on 2
i dent i f i c ador es di f er ent es .
Java beans standards
- Si s e des ea obt ener un v al or el mét odo
debe t ener el pr ef i j o get , por ej empl o
get Name( ) ;
- Si s e des ea obt ener un v al or bool ean
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( ) ;
- Si s e des ea as i gnar un v al or s e debe
ut i l i z ar el pr ef i j o s et , por ej empl o
s et Name( St r i ng name) ;
- Los mét odos get t er / s et t er deben s er
públ i c os
www. t wi t t er . com/ devs4j
Iterando sobre un arreglo
Es pos i bl e i t er ar a c ada el ement o de un
ar r egl o c on el s i gui ent e c ódi go:
int numeros[] = { 10, 11, 2, 12, 3, 34, 2, 12 };
for (int i = 0; i < numeros.length; i++) {
System.out.println(numeros[i]);
}
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
t i po de c i l o f or es pec i al l l amado
f or Eac h, a c ont i nuac i ón un ej empl o:
int numeros[] = { 10, 11, 2, 12, 3, 34, 2, 12 };
for (int numero : numeros) {
System.out.println(numero);
}
Es t e t i po de c i c l o f unc i ona a t r av és de
una v ar i abl e t empor al que v a t omando el
v al or de c ada el ement o del ar r egl o,
f or Eac h es una opc i ón c uando:
- No nec es i t amos modi f i c ar el ar r egl o
- No nec es i t amos i ndi c es
Arreglos de objetos
Es pos i bl e t ener t ant o ar r egl os de t i pos
pr i mi t i v os c omo de obj et os , a
c ont i nuac i ón un ej empl o:
public class Taco {
private String sabor;
private float precio;
private boolean cebolla;
private boolean cilantro;
public Taco(String sabor, float precio, boolean
cebolla, boolean cilantro) {
this.sabor = sabor;
this.precio = precio;
this.cebolla = cebolla;
this.cilantro = cilantro;
}
//Getters y setters
}
public class Taqueria {
public static void main(String[] args) {
Taco orden1[] = new Taco[3];
orden1[0] = new Taco("Pastor", 10.5f, true,
true);
orden1[1] = new Taco("Suadero", 20.5f, false,
true);
orden1[2] = new Taco("Bistec", 30.0f, true,
true);
float precioTotal = 0.0f;
for (Taco taco : orden1) {
precioTotal += taco.getPrecio();
}
System.out.println("El precio de la orden es
de : " + precioTotal);
}
}
Arreglos multidimensionales
Los ar r egl os pueden t ener mul t i pl es
di mens i ones a c ont i nuac i ón un ej empl o:
public static void main(String[] args) {
int arrays[][] = { { 2, 2 }, { 4, 4 }, { 5, 5 } };
for (int[] array : arrays) {
for (int value : array) {
System.out.print("\t " + value);
}
System.out.println();
}
}
www. f acebook. com/ devs4j
Declaración de arreglos
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
- int arr [];
- int [] arr;
Ar r egl os de obj et os
- String arr[];
- String []arr;
Inicialización de arreglos
Ex i s t en di f er ent es f or mas de c r ear l os ar r egl os ,
v eamos l as s i gui ent es :
- For ma i mpl í c i t a
String nombres[] = { "Alex", "Pedro", "Juan" }
- For ma ex pl í c i t a
String nombres[] =new String [3];
nombres[0]="Alex";
nombres[1]="Pedro";
nombres[2]="Juan";
- For ma anóni ma
String nombres[] = new String[] { "Alex", "Pedro", "Juan" };
Acceso a arreglos
Par a ac c eder a l os el ement os de un ar r agl o l o
har emos a t r av és de s u i ndi c e, v eamos el s i gui ent e
ej empl o:
String nombres[] = { "Alex", "Pedro", "Juan" }
System.out.println(nombres[0]);
Imprimirá : Alex
Enumeraciones
Una enumer ac i ón es un t i po es pec i al de c l as e que
r epr es ent a un gr upo de c ons t ant es , es t as
c ons t ant es deber án es t ar en may ús c ul as :
public enum SaborPalomitas {
CHILE, MANTEQUILLA, QUESO, CARAMELO;
}
Par a ac c eder al v al or de l a enumer ac i ón s e
r eal i z ar á del s i gui ent e modo:
SaborPalomitas.CARAMELO
Es pos i bl e as i gnar l e v al or es a l as enumer ac i ones ,
v eamos el s i gui ent e
public enum TamanioDePalomitas {
CHICA(20.5f), MEDIANA(30.1f), GRANDE(50.0f);
private float precio;
private TamanioDePalomitas(float precio) {
this.precio = precio;
}
public float getPrecio() {
return precio;
}
}
Par a ac c eder a un v al or de l a enumer ac i ón s e
r eal i z ar á del s i gui ent e modo:
TamanioDePalomitas tamanioMediano =
TamanioDePalomitas.MEDIANA;
System.out.println(tamanioMediano.getPrecio());
Al ej ec ut ar l o ant er i or t endr emos l a s i gui ent e
s al i da: 30. 1
www. devs4j . com
Wrapper classes
Java - Colecciones
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 :
- 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
ut i l i dades , muc has de el l as es t án
r el ac i onadas c on l a c onv er s i ón.
Equivalencias de wrapper classes
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 :
- bool ean- by t e
- c har
- doubl e - f l oat
- i nt
- l ong
- s hor t
-
Bool ean
By t e
Char ac t er
Doubl e
Fl oat
I nt eger
Long
Shor t
Todas l as wr apper c l as s es ex c ept o
Char ac t er pr ov een 2 c ons t r uc t or es , uno
que t oma el v al or pr i mi t i v o y ot r o que
t oma l a r epr es ent ac i ón en St r i ng.
Métodos de conversión
Ex i s t en di f er ent es mét odos que nos
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
al gunos de l os más ut i l i z ados :
- x x x Val ue( ) : Se ut i l i z a c uando
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:
Integer val=new Integer(11);
double doubleValue = val.doubleValue();
System.out.println(doubleValue);
<<i nt er f ac e>>
Li s t
Ar r ay Li s t
Col l ec t i ons
<<i nt er f ac e>>
Col l ec t i on
<<i nt er f ac e>>
Compar abl e
<<i nt er f ac e>>
Compar at or
<<i nt er f ac e>>
Queue
<<i nt er f ac e>>
Set
<<i nt er f ac e>>
Map
Pr i or i t y Queue
Li nk edLi s t
Has hSet
Has hMap
Tr eeSet
Tr eeMap
Vec t or
Colecciones en Java
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
di f er enc i a de l os ar r egl os l as c ol ec c i ones
pueden c r ec er , v eamos un r es umen de l as
i nt er f ac es pr i nc i pal es :
- 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.
- Li s t : Per mi t e gener ar l i s t as s i mpl es de
obj et os
- Set : Per mi t e al mac enar obj et os úni c os
- Map : Per mi t en al mac enar obj et os en par es
l l av e y v al or , l as l l av es deben de s er úni c as
- Queue : Per mi t en al mac enar obj et os de
ac uer do al or den de i ns er c i ón o a r egl as
def i ni das
HashSet
Col ec c i ón ut i l i z ada c uando nec es i t as un
c onj unt o de dat os s i n el ement os
dupl i c ados y no t e i mpor t e el or den de
l os dat os .
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:
int intValue = Integer.parseInt("11");
System.out.println(intValue);
-valueOf() : Recibe un String y devuelve un
Wrapper del tipo invocado:
Double doubleValue2 = Double.valueOf("3.14");
System.out.println(doubleValue2);
Autoboxing y Auto-unboxing
A par t i r de l a v er s i ón 5 de J av a ex i s t en
l as s i gui ent es c ar ac t er í s t i c as :
- Aut obox i ng : Es l a c onv er s i ón que
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
c l as s :
Integer x=10;
- 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
c l as s al t i po de dat o pr i mi t i v o:
Integer x=10;
int y=x;
== , equals()
if (i1 != i2) {
System.out.println("Objetos diferentes");
}
if (i1.equals(i2)) {
System.out.println("Objetos equivalentes");
}
Produce la salida:
Objetos diferentes
Objetos equivalentes
Recordemos que == validan si ambas referencias
apuntan al mismo objeto, mientras que equals verifica si
los objetos son equivalentes.
www. t wi t t er . com/ devs4j
ArrayList
Col ec c i ón bas ada en ar r egl os que puede c r ec er ,
c uando es i ns t anc i ada t i ene una c apac i dad
def aul t de 10 el ement os , c onf or me s e v an
agr egando v al or es l a c apac i dad s e v a
i nc r ement ando.
Ar r ay Li s t t i ene una v el oc i dad c ons t ant e al
agr egar y al obt ener el ement os .
TreeSet
Tr eeSet es una de l as c ol ec c i ones
or denadas e i mpl ement a una es t r uc t ur a de
t i po ár bol r oj o- negr o y gar ant i z a que l os
el ement os s er án úni c os y es t ar án
or denados de f or ma as c endent e de ac uer do
a un or den nat ur al .
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
un el ement o.
ArrayList<String> lista = new ArrayList<>();
LinkedList
HashMap
Ut i l i z a Has hMap c uando r equi er as una
c ol ec c i ón que c ont enga par es ,
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
per mi t e l l av es dupl i c adas .
Li nk edLi s t es una i mpl ement ac i ón de una l i s t a
dobl ement e l i gada, s u per f or manc e es mej or a un
Ar r ay Li s t c uando s e t i ene que agr egar o r emov er
un el ement o, per o es peor c uando s e qui er e
obt ener o modi f i c ar un el ement o.
El ac c es o a l os dat os s e bas a en el
has hCode, ent r e mej or s ea l a
i mpl ement ac i ón de has hCode, mej or s er á el
per f or manc e.
Li nk edLi s t i mpl ement a t ambi én l a i nt er f az Queue
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.
HashMap<Integer,String> map = new HashMap<>();
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
el or den l o def i ni r án l as l l av es y no l os
v al or es .
Vector
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
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.
Vector<String> lista = new Vector<>();
PriorityQueue
Es t a c l as e f ue agr egada en J av a 5, c omo
Li nk edLi s t s opor t a el c ompor t ami ent o def aul t de
una es t r uc t ur a FI FO, Pr i or i t y Queue or dena l os
el ement os de ac uer do a una pr i or i dad, de es t e
modo podemos ac c eder pr i mer o a l os el ement os que
t i enen una may or pr i or i dad.
TreeMap
TreeMap<Integer,String> map = new TreeMap<>();
Comparable /
Comparator
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
Tr eeSet y Tr eeMap.
Collections
La c l as e j av a. ut i l . Col l ec t i ons c ont i ene
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 .
PriorityQueue<String> queue = new PriorityQueue<>();
www. f acebook. com/ devs4j
www. devs4j . com
Java - Manejo de Errores
c hec k ed
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
una c l as e que i mpl ement e Cl os abl e o
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:
Throwable
unc hec k ed
Error
Creación de tu propio
Autoclosable
c hec k ed
Exception
ExceptionInitializerError
IOException
RuntimeException
unc hec k ed
StackOverflowError
FileNotFoundException
NullPointerException
FileSystemException
IllegalStateException
OutOfMemoryError
public class MiRecurso implements AutoCloseable {
public void imprimirMensaje() {
System.out.println("Esta es una acción");
}
@Override
public void close() throws Exception {
System.out.println("Se esta cerrando mi recurso");
}
}
Una vez hecho esto podrás utilizarlo del siguiente modo:
try(MiRecurso recurso=new MiRecurso()){
recurso.imprimirMensaje();
} catch (Exception e) {
//Manejo de la excepción
}
Creación de tu propia
Excepción
SecurityException
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
er r or es :
- 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
apl i c ac i ones J av a.
- 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 .
- 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
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
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.
try - catch -finally
Reglas al utilizar try-catch-finally
A c ont i nuac i ón s e mues t r a un ej empl o s obr e
el us o de t r y - c at c h- f i nal l y :
A c ont i nuac i ón s e mues t r an al gunas r egl as
al ut i l i z ar t r y - c at c h- f i nal l y :
try {
/**
* Código que puede generar excepciones
*/
} catch (Exception e) {
/**
* Código a ejecutar en caso de que
se genere una excepción
*/
} finally {
/**
* Código a ejecutar sin importar si se
* generó o no una excepción
*/
}
- Sol o el bl oque t r y es obl i gat or i o.
- Es pos i bl e def i ni r un bl oque c on s ol o
un t r y y un c at c h del s i gui ent e modo:
try{
Union catch block
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 ones :
try {
/**
* Código que puede generar una excepción
*/
} catch (FileNotFoundException |
FileAlreadyExistsException e) {
/**
* Código que se ejecuta en caso de que se genere una
* FileNotFoundException o FileAlreadyExistsException
*/
}catch (IOException e){
/**
* Código que se ejecuta en caso de que se genere una
* IOException
*/
}
try with resources
Tr y wi t h r es our c es s e i nc l uy ó en J av a 7 y
nos per mi t en dec l ar ar r ec ur s os que s e
ut i l i z ar án en un bl oque t r y c on l a
s egur i dad de que s er án c er r ados des pués de
l a ej ec uc i ón del bl oque, Los r ec ur s os
dec l ar ados deben i mpl ment ar l a i nt er f az
Aut oCl os abl e.
www. t wi t t er . com/ devs4j
}catch(Exception e){
}
- Es pos i bl e def i ni r un bl oque c on s ol o
un t r y y un f i nal l y del s i gui ent e modo:
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
c r ear t u pr opi a Ex c epc i ón, par a es t o deber ás
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
t u ex c epc i ón s ea c hec k ed o unc hec k ed:
class MiExcepcionNoChecada extends RuntimeException {
}
class MiExcepcionChecada extends Exception {
}
Lanzamiento de excepciones
Si ex i s t e una par t e en t u c ódi go donde des eas
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:
class MenorDeEdadException extends Exception{
}
public void validarEdad(int edad) throws
MenorDeEdadException {
if (edad < 18) {
throw new MenorDeEdadException();
}
}
Uso de la palabra reservada
throws
Se ut i l i z a l a pal abr a r es er v ada t hr ows par a
i ndi c ar que en c as o de que s e gener e una
ex c epc i ón es t a no s er á manej ada por el mét odo
ac t ual s i no por el que l o mando l l amar :
try{
}finally{
}
- Un t r y puede t ener muc hos c at c h per o
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
ex c epc i ón más es pec í f i c a a l a más gener al .
- 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
s ent enc i a r et ur n.
- 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
Sy s t em. ex i t ( . . ) ;
Uso de try-with-resources
La c l as e Pr i nt Wr i t er s e ut i l i z a par a
es c r i bi r en un ar c hi v o, v eamos el
s i gui ent e ej empl o:
try (PrintWriter writer = new PrintWriter(new
File("test.txt"))) {
writer.println("Hello World");
} catch (FileNotFoundException e) {
//Manejo de la excepción
}
En el c ódi go ant er i or s i n i mpor t ar s i
ex i s t e o no una ex c epc i ón al es c r i bi r en
el ar c hi v o s e ej ec ut ar á el mét odo c l os e
def i ni do en l a i nt er f az Aut oc l os abl e e
i mpl ement ado por Pr i nt Wr i t er .
www. f acebook. com/ devs4j
public void readFile() throws FileNotFoundException {
File file = new File("archivo_que_no_existe.txt");
FileInputStream stream = new FileInputStream(file);
/**
* código que utiliza stream
*/
}
Como s e puede v er , a pes ar de que
Fi l eNot FoundEx c ept i on es una ex c epc i ón de t i po
c hec k ed, no es nec es ar i o c ol oc ar el c ódi go
dent r o de un t r y c at c h y a que qui en s er á
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( ) .
Ut i l i z ar emos es t e mét odo par a del egar el
manej o del er r or a qui en t i ene l a c apac i dad de
manej ar l o, por ej empl o s i hay un c omponent e
que s ol o ac c ede a dat os puede pr opagar 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
adec uado al us uar i o.
Reglas al utilizar throws / throw
- Thr ows es nec es ar i o s ol o par a ex c epc i ones
de t i po c hec k ed
- Cuando s e s obr es c r i be un mét odo no es
pos i bl e agr egar t hr ows c on una ex c epc i ón nuev a
de t i po c hec k ed
- 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
l a ex c epc i ón
- Si l a ex c epc i ón no es manej ada por ni ngún
mét odo, s er á manej ada por l a J VM
- Un mét odo puede dec l ar ar más de una
ex c epc i ón c on l a pal abr a r es er v ada t hr ows
- Se puede ut i l i z ar t hr ow s ol o c on obj et os
de t i po Thr owabl e
www. devs4j . com
Inner classes
Java - clases internas
Las c l as es i nt er nas s e pueden c l as i f i c ar
del s i gui ent e modo:
- Cl
- Cl
- Cl
- Cl
as es
as es
as es
as es
i nt er nas r egul ar es
i nt er nas a ni v el de mét odo
anóni mas
i nt er nas es t át i c as
Clases internas regulares
Las c l as es i nt er nas r epr es ent an c l as es
que no s on anóni mas , s t at i c o a ni v el de
mét odo. A c ont i nuac i ón s e pr es ent a un
ej empl o:
public class External {
void foo() {
System.out.println("Foo");
}
class Internal {
void bar() {
System.out.println("Bar");
}
}
}
Es pos i bl e c r ear i ns t anc i as de c l as es
i nt er nas del s i gui ent e modo:
External external = new External();
External.Internal internal = external.new Internal();
external.foo();
internal.bar();
Clases internas estáticas
A c ont i nuac i ón s e pr es ent a un ej empl o de
una c l as e es t át i c a i nt er na:
public class StaticExternal {
static class Interna {
void foo() {
System.out.println("Foo");
}
}
public static void main(String[] args) {
Interna internal = new Interna();
internal.foo();
}
}
No es nec es ar i o c r ear obj et os de l a c l as e
ex t er na par a i ns t anc i ar obj et os de l a
c l as e i nt er na.
Clases anónimas con interfaces
Son c l as es s i n nombr e que t ambi én pueden
i mpl ement ar una i nt er f az
interface Foo {
void foo();
}
public class InterfaceExample {
public static void main(String[] args) {
Foo f = new Foo() {
@Override
public void foo() {
System.out.println("Foo");
}
};
f.foo();
}
}
Threads
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
c l as e es que per mi t e ej ec ut ar t ar eas de
f or ma c onc ur r ent e.
Ex i s t en 2 f or mas de def i ni r un hi l o:
- Cr eando un obj et o de l a c l as e Thr ead
y s obr ees c r i bi endo el mét odo r un( )
- Cr eando un obj et o que i mpl ement e l a
i nt er f az Runnabl e e i mpl ement ando el
mét odo r un( )
Definición de Threads a
través de herencia
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 ut i l i z ando
her enc i a:
class DescendingCounter extends Thread {
private int maxNumber;
public DescendingCounter(int maxNumber) {
this.maxNumber = maxNumber;
}
@Override
public void run() {
for (int i = maxNumber; i >= 0; i--) {
try {
Thread.sleep(1000);
System.out.println("Desc:" + i);
} catch (InterruptedException e) {
System.err.println(e);
}
}
}
Clases a nivel de método
Tambi én es pos i bl e dec l ar ar c l as es a
ni v el de mét odo:
public class MethodLevelClasses {
static void print() {
class InnerMethodClass {
void foo() {
System.out.println("test");
}
}
InnerMethodClass innerClass = new
InnerMethodClass();
innerClass.foo();
}
public static void main(String[] args) {
print();
}
}
El c ódi go ant er i or mues t r a c omo hac er un
c ont ador de f or ma des c endent e.
Ejecución de un Thread
El s i gui ent e ej empl o mues t r a c omo
ej ec ut ar hi l os :
public class Counters {
public static void main(String[] args) {
DescendingCounter descending = new
DescendingCounter(10);
Thread ascending = new Thread(new
AscendingCounter(10));
descending.start();
ascending.start();
lkvc mclkvm
}
}
Del c ódi go ant er i or podemos v er l os
s i gui ent es punt os :
- Par a ej ec ut ar un hi l o NO
ej ec ut ar emos s u mét odo r un( ) .
- Par a ej ec ut ar un hi l o ej ec ut ar emos
s u mét odo s t ar t ( ) .
- Si ej ec ut amos el mét odo r un( )
ej ec ut ar á el c ódi go, per o no de f or ma
c onc ur r ent e, s i no c omo un mét odo c omún.
- El mét odo void sleep(long millis) per mi t e
dor mi r el hi l o l a c ant i dad de
mi l i s egundos es pec i f i c ada.
- Si s e c r ea un hi l o a t r av és de una
c l as e que her eda de Thr ead s ol o s e debe
ej ec ut ar s u mét odo s t ar t ( ) .
- Si s e c r ea un hi l o a t r av és de una
c l as e que i mpl ement a Runnabl e el obj et o
s e debe pas ar c omo par ámet r o a un obj et o
de l a c l as e Thr ead.
- " End of cr eat i on" s e i mpr i mi r á ant es
de que s e t er mi nen de ej ec ut ar l os dos
pr oc es os c onc ur r ent es .
Ciclo de vida de los hilos
Los hi l os s e pueden enc ont r ar en l os
s i gui ent es es t ados :
- New: El hi l o s e ha c r eado per o no s e
ha ej ec ut ado el mét odo s t ar t ( )
- Runnabl e: Se ej ec ut ó el mét odo
s t ar t ( ) y el hi l o es t á l i s t o par a s er
ej ec ut ado.
- Runni ng: El hi l o s e enc uent r a en
ej ec uc i ón.
- Wai t i ng/ bl oc k i ng: El hi l o no es
el egi bl e par a s er ej ec ut ado. El hi l o es t a
v i v o per o no es el egi bl e.
- Dead: El hi l o s e c ons i der a muer t o
c uando t er mi na l a ej ec uc i ón del mét odo
r un. No es pos i bl e i ni c i ar de nuev o un
hi l o que s e enc uent r a en es t ado dead.
Definición de Threads a través de implementación
Thread scheduler
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
i nt er f az Runnabl e:
Es l a par t e de l a maqui na v i r t ual de J av a
que dec i de l os hi l os que s e v an a
ej ec ut ar de ac uer do a s us pr i or i dades .
class AscendingCounter implements Runnable {
private int maxNumber;
Clases anónimas
Son c l as es s i n nombr e que her edan de l a
c l as e es pec i f i c ada:
abstract class Test {
abstract void foo();
}
public class AnonymousClass {
public static void main(String[] args) {
Test object = new Test() {
@Override
void foo() {
System.out.println("Foo");
}
};
object.foo();
}
}
www. t wi t t er . com/ devs4j
public AscendingCounter(int maxNumber) {
this.maxNumber = maxNumber;
}
@Override
public void run() {
for (int i = maxNumber; i >= 0; i--) {
try {
Thread.sleep(800);
System.out.println("Asc : " + i);
} catch (InterruptedException e) {
System.err.println(e);
}
}
}
}
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. f acebook. com/ devs4j
www. devs4j . com
Hilos parte 2, Lambdas,
Optional, Streams y Sockets
Ciclo de vida de los hilos
Los hi l os s e pueden enc ont r ar en l os
s i gui ent es es t ados :
- New: El hi l o s e ha c r eado per o no s e
ha ej ec ut ado el mét odo s t ar t ( ) .
- Runnabl e: Se ej ec ut ó el mét odo
s t ar t ( ) y el hi l o es t á l i s t o par a s er
ej ec ut ado.
- Runni ng: El hi l o s e enc uent r a en
ej ec uc i ón.
- Wai t i ng/ bl oc k i ng: El hi l o no es
el egi bl e par a s er ej ec ut ado. El hi l o es t a
v i v o per o no es el egi bl e.
Creación de hilos con
lambdas
Un ej empl o de una i nt er f az f unc i onal es
l a i nt er f az Runnabl e l a c uál s ol o def i ne
el mét odo r un( ) . A c ont i nuac i ón un
ej empl o:
Runnable counter = () -> {
for (int i = 0; i <= 100; i++) {
try {
Thread.sleep(800);
System.out.println("Asc : " + i);
} catch (InterruptedException e) {
System.err.println(e);
}
}
};
- Dead: El hi l o s e c ons i der a muer t o
c uando t er mi na l a ej ec uc i ón del mét odo
r un( ) . Un hi l o en es t ado dead no s e puede
v ol v er a i ni c i ar .
El c ódi go ant er i or r epr es ent a l a c r eac i ón
de un obj et o que i mpl ement a l a i nt er f az
Runnabl e.
Métodos últiles
Implementación de una interfaz propias
- s t ar t ( ) : I ni c i a l a ej ec uc i ón de un
hi l o
- j oi n( ) : Hac e que un hi l o es per e l a
ej ec uc i ón de ot r o has t a que es t a t er mi ne.
- s l eep( l ong mi l i s ) : Mét odo es t át i c o
que puedes ut i l i z ar par a al ent ar l a
ej ec uc i ón de un hi l o.
- y i el d( ) : Puede c aus ar que s e mande
al hi l o a es t ado r unnabl e, dependi endo de
s u pr i or i dad.
- wai t ( ) : Env í a al hi l o a es per ar en
es t ado wai t i ng.
- 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.
- 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
a es t ado r unnabl e.
- s et Name( St r i ng name) : As i gna un
nombr e al hi l o.
- s et Pr i or i t y( i nt pr i or i t y ) : Def i ne
l a pr i or i dad de un hi l o
Lambdas
Las ex pr es i ones l ambda s on una de l as
adi c i ones más i mpor t ant es que s e hi c i er on
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
t r av és de una ex pr es i ón.
Las ex pr es i ones l
i mpl ement ac i ones
f unc i onal es. Una
bás i c ament e una i
mét odo abs t r ac t o.
ambda s on
de i nt er f ac es
i nt er f az f unc i onal es
nt er f az c on un s ol o
Sintaxis
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 :
l i s t a de ar gument os : ( i nt x , i nt y )
Tok en : - >
Cuer po : x + y
Creación de un Comparator a
través de lambdas
A c ont i nuac i ón s e mues t r a un ej empl o de
un Compar at or hac i endo us o de l ambdas :
List<Persona> personas = new ArrayList<>();
personas.add(new Persona("Juan", "López"));
personas.add(new Persona("Arturo", "Sánchez"));
Comparator<Persona> comparator = (Persona p,
Persona p2) ->
p.getNombre().compareTo(p2.getNombre());
Collections.sort(personas, comparator);
www. t wi t t er . com/ devs4j
A c ont i nuac i ón s e mues t r a un ej empl o de
l a i mpl ement ac i ón de una i nt er f az
hac i endo us o de l ambdas :
interface Calculable {
double avg(double... numbers);
}
public class InterfaceImplementation {
public static void main(String[] args) {
Calculable calc = (numbers) -> {
double sum = 0.0;
for (int i = 0; i < numbers.length; i++) {
sum += numbers[i];
}
return sum / numbers.length;
};
System.out.println(calc.avg(1, 2, 3, 4, 5, 6, 7,
8, 9, 10));
}
}
Clase Optional
Es t a c l as e nos per mi t e r epr es ent ar
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:
public Integer findValue(Integer value, Integer[] array) {
for (int i = 0; i < array.length; i++) {
if (array[i] == value) {
return i;
}
}
return null;
}
El mét odo ant er i or bus c a un v al or en un
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
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 :
public static Optional<Integer> findValue(Integer value,
Integer[] array) {
for (int i = 0; i < array.length; i++) {
if (array[i] == value) {
return Optional.of(i);
}
}
return Optional.empty();
}
Es t o hac e una s ol uc i ón más l i mpi a y menos
pr opens a a bugs . El s i gui ent e ej empl o
mues t r a c omo manej ar una r es pues t a
opc i onal :
Java 8 Streams
Un st r eam es una pi ez a de c ódi go que s e
enf oc a en c onj unt os y no en pi ez as
i ndi v i dual es . Supongamos el s i gui ent e
pr obl ema:
Se des ean obt ener l as 3 pr i mer as per s onas
may or es de 18 años que s e enc uent r an en
una l i s t a:
int count = 0;
List<Persona> resultado = new ArrayList<>();
for (Persona persona : personas) {
if (persona.getEdad() >= 18) {
resultado.add(persona);
count++;
if(count==3){
break;
}
}
}
En el c ódi go ant er i or s e da una s ol uc i ón
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
f or ma f unc i onal a t r av és de s t r eams :
List<Persona> primerosMayores =
personas.stream().filter(p -> p.getEdad() >= 18).limit(3)
.collect(Collectors.toList());
¿Cómo utilizar streams?
Par a ut i l i z ar s t r eams s egui r emos l os
s i gui ent es pas os :
1: I ni c i ar c on una i mpl ement ac i ón
c onc r et a : Ar r ay s, Set , Li s t , Map, et c .
2: Ej ec ut ar el mét odo s t r eam( ) , es
pos i bl e c onc at enar múl t i pl es s t r eams .
3: Ut i l i z ar oper ac i ones ent r e s t r eams
ent r e l as que t enemos : f i l t er , map,
r educ e, et c .
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 ,
Opt i onal , et c .
5: Par a v ol v er al c as o c onc r et o
podr emos ut i l i z ar al gunas de l as
s i gui ent es oper ac i ones : s um( ) ,
c ol l ec t ( Col l ec t or s . t oLi s t ( ) ) , av er age( ) ,
c ol l ec t ( Col l ec t or s . gr oupBy ( ) ) , et c .
Sockets
Los s oc k et s per mi t en es c r i bi r pr ogr amas
que s e ej ec ut an en di f er ent es
c omput ador as que es t an c onec t adas a
t r av és de l a r ed.
Un s oc k et es t a c onf or mado por :
- Un pr ot oc ol o : Puede s er UDP o TCP
- 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
- Un puer t o: Son ut i l i z ados par a
det er mi nar a donde di r i gi r el t r áf i c o del
0 al 1023 s on puer t os dedi c ados del
s i s t ema.
ServerSocket
Nos per mi t e def i ni r a nues t r o s oc k et
s er v i dor . A c ont i nuac i ón s e pr es ent a un
ej empl o:
ServerSocket server = new ServerSocket(8080);
Optional<Integer> result = findValue(5, new Integer[] {
10, 33, 23, 57, 88 });
if(result.isPresent()){
System.out.println(result.get());
}else{
System.out.println("No se encontro el resultado");
}
www. f acebook. com/ devs4j
Socket
Nos per mi t e def i ni r a l os c l i ent es que s e
c onec t ar an al s er v i dor . A c ont i nuac i ón s e
pr es ent a un ej empl o:
Socket socket = new Socket("localhost", 8080);
www. devs4j . com
Productor consumidor
Thread
Thread
Productor
Recurso
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
rangeClosed)
Transformaciones utilizando
map
Puedes ut i l i z ar I nt St r eam, Doubl eSt r eam,
LongSt r eam, et c , par a gener ar un f l uj o de
dat os pr i mi t i v os a c ont i nuac i ón s e
pr es ent a un ej empl o de f or ma i mper at i v a y
ut i l i z ando pr ogr amac i ón f unc i onal :
Puedes ut i l i z ar map c uando des ees
t r ans f or mar de un obj et o a ot r o, por
ej empl o, s i obt i enes de una bas e de dat os
un obj et o l l amado Per s ona y l o qui er es
t r ans f or mar a uno de t i po St r i ng puedes
hac er l o s i gui ent e:
I mper at i v a
public static void main(String []args) {
List<Persona>personas=
Arrays.asList(new Persona("Alex","Lopex"));
for(inti= 0;i< 10;i++) {
System.out.print(i);
}
List<String>nombres=personas.stream().
map(p->p.getNombre()).
collect(Collectors.toList());
for(String nombre:nombres) {
System.out.println(nombre);
}
Func i onal
IntStream.range(0, 10).forEach(System.out::print);
Máximos y mínimos
A c ont i nuac i ón s e pr es ent a una s ol uc i ón
c omún par a obt ener el v al or mí ni mo de una
l i s t a ut i l i z ando pr ogr amac i ón i mper at i v a:
Uso de métodos static en
interfaces
A par t i r de l a v er s i ón 8 de J av a puedes
c ol oc ar mét odos s t at i c en l as i nt er f ac es
c omo s e mues t r a a c ont i nuac i ón:
interface Follower{
static String getName() {
return "raidentrance";
}
}
Los mét odos s t at i c def i ni dos en l as
i nt er f ac es no pueden s er s obr ees c r i t os .
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
mét odos c on c uer po, a es t os l os
l l amar emos mét odos def aul t , a
c ont i nuac i ón un ej empl o:
interface Follower{
static String getName() {
return"raidentrance";
}
Par a c al c ul ar el v al or mí ni mo s ol o s e
r eempl az ar á mi n por max en l a l í nea
ant er i or .
default void follow() {
System.out.println("Default follow impl");
}
}
Remover datos
duplicados
Remov er dat os dupl i c ados de una
puede s er una t ar ea c ompl i c ada,
hac er l o c on s t r eams es muy s i mpl
c ont i nuac i ón dos f or mas s i mpl es
hac er l o:
l i st a
per o
e, a
de
1. Ut i l i z ando di s t i nc t
public static void main(String[] args) {
List<Integer> numbers= Arrays.asList(7, 7, 7, 7, 2,
2, 2, 3, 3, 3, 3, 100, 100, 200, 200);
numbers=numbers.stream().distinct().
collect(Collectors.toList());
System.out.println(numbers);
}
2. Ut i l i z ando un s et
public static void main(String []args) {
List<Integer> numbers= Arrays.asList(7, 7, 7, 7, 2,
2, 2, 3, 3, 3, 3, 100, 100, 200, 200);
Set<Integer>nums=
numbers.stream().collect(Collectors.toSet());
System.out.println(nums);
}
www. t wi t t er . com/ devs4j
public static void main(String []args) {
List<String>names=
Arrays.asList("Alex","Juan","Pedro","raidentrance");
names.stream().forEach(System.out::println);
}
Method reference static
class StringUtils{
static boolean isUpperCase(Stringcad) {
return cad.toUpperCase().equals(cad);
}
}
Ut i l i z ando pr ogr amac i ón i mper at i v a:
public static void main(String []args) {
List<String>names=
Arrays.asList
("Alex","Juan","Pedro","raidentrance","PANCHO");
names.stream().
filter(cad->StringUtils.isUpperCase(cad))
.forEach(System.out::println);
Métodos default en las
interfaces
A c ont i nuac i ón s e pr es ent a l a s ol uc i ón
equi v al ent e ut i l i z ando s t r eams :
public static void main(String[]args) {
List<Integer>numbers= Arrays.asList(7, 2, 3,
100, 200, 300, 400, 5, 1);
Integer minValue= numbers.stream().
min(Comparator.naturalOrder()).get();
System.out.println(minValue);
}
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
de i ns t anc i a:
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
s t at i c :
}
public static void main(String []args) {
List<Integer>numbers= Arrays.asList(7, 2, 3,
100, 200, 300, 400, 5, 1);
int min=numbers.get(0);
for(Integer value:numbers) {
if(value<min) {
min=value;
}
}
System.out.println(min);
}
Method reference por
méodo de instancia
El mét odo f ol l ow es un mét odo c on una
i mpl ement ac i ón por def aul t , a di f er enc i a
del mét od get Name que es s t at i c , el
mét odo f ol l ow puede s er s obr ees c r i t o s i n
nungún pr obl ema, c ons ul t a l a i nt er f ac e
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 .
}
Ut i l i z ando s t at i c met hod r ef er enc e:
public static void main(String[]args) {
List<String>names= Arrays.asList
("Alex","Juan","Pedro","raidentrance","PANCHO");
names.stream().
filter(StringUtils::isUpperCase)
.forEach(System.out::println);
}
Method reference con
constructores
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
c ont i nuac i ón:
class Person {
private String name;
Method reference
public Person(String name) {
this.name=name;
}
Una f unc i onal i dad i mpor t ant e que s e
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
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 :
-
Ref
Ref
Ref
Ref
er enc i
er enc i
er enc i
er enc i
as
as
as
as
a
a
a
a
mét
mét
mét
un
odos
odos
odos
c ons t
@Override
public String toString() {
return "Person [name="+name+"]";
}
s t at i c
de i ns t anc i a
de una c l as e
r uc t or
A c ont i nuac i ón s e pr es ent an al gunos
ej empl os .
}
names.stream().filter(StringUtils::isUpperCase).
map(Person::new).forEach(System.out::println);
www. f acebook. com/ devs4j
www. devs4j . com
Ejercicios
Sección 3 Primeros pasos
1. Real i z a un pr ogr ama c apaz de
c al c ul ar el ár ea de un c uadr ado,
c í r c ul o, r ec t angul o y t r i angul o.
2. Toma el ej er c i c i o ant er i or y
c ombi er t el o en un pr ogr ama
of us c ado, un pr ogr ama of us c ado es
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,
haz us o de l os c onoc i mi ent os que
t i enes de i dent i f i c ador es par a que
s ea al go di f í c i l de ent ender .
Sección 5 Programación
orientada a objetos
1. Real i z a un di agr ama de c l as es
que r epr es ent e mas c ot as .
2. Cr ea l as c l as es def i ni das en el
ej er c i c i o ant er i or , c ada una deber á
t ener más de un c ons t r uc t or y el
c ódi go que s e ut i l i z a par a
i ni c i al i z ar no s e deber á r epet i r .
1. Cr ea un pr ogr ama donde un hi l o haga una c uent a
r egr es i v a dado un númer o, el t i empo que debe es per ar
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
que hi l o t er mi no pr i mer o, as egur at e de c ol oc ar l e un
nombr e a c ada uno de el l os .
3. Haz debuggi ng s obr e l as c l as es
del ej er c i c i o ant er i or par a que
anal i c es el pas o a pas o de l a
ej ec uc i ón.
2. Modi f i c a el pr ogr ama ant er i or par a que t odos l os
hi l os es per en el mi s mo t i empo as i gnal e di f er ent es
pr i or i dades a c ada uno de el l os y l anz a 30 hi l os ,
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
oper ac i ones al r et i r ar di ner o:
Sección 6 Herencia
Sección 4 Control de flujo
1. Real i z a un pr ogr ama que i mpr i ma
l as t abl as de mul t i pl i c ar del 1 al
20, debe ex i s t i r un es pac i o ent r e
una y ot r a par a i dent i f i c ar l as .
2. Modi f i c a el pr ogr ama ant er i or
par a que s ol o s e i mpr i man l as
t abl as de mul t i pl i c ar de númer os
par es , par a i dent i f i c ar s i l os
númer os s on par es puedes ut i l i z ar
el oper ador módul o c on 2 c omo s e
mues t r a a c ont i nuac i ón:
1. Pl ant ea 5 es c enar i os que hagan
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.
2. Ut i l i z a el di agr ama ant er i or y
haz un pr ogr ama que l o r epr es ent e.
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
c or r ec t ament e, haz us o de l a
pal abr a r es er v ada s uper .
3. Sobr ees c r i be al menos uno de l os
mét odos del ej er c i c i o ant er i or .
int x= 2;
if ( x % 2 == 0) {
System.out.println("Es par");
}
3. Crea un programa utilizando ciclos que
imprima el factorial de un número, se calcula
multiplicando todos los números a partir del
número indicado hasta 1 y se representa con el
simbolo !, a continuación un ejemplo:
4! = 4 x 3 x 2 x 1 = 24
7! = 7 × 6 × 5 × 4 × 3 × 2 × 1 = 5040
Programación con Hilos
Sección 8 Encapsulamiento y
polimorfismo
1. Cr ea l as c l as es nec es ar i as par a
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
enc aps ul ami ent o.
- Val i dar el mont o r ec i bi do
- Cons ul t ar s al do en l a c uent
s uf i c i ent e par a r et i r ar el
- Res t ar el mont o al s al do
- dev ol v er el mont o a qui en i
- I mpr i mi r que s e r eal i z ó el
4. Crea un progama que imprima las siguientes
figuras en la pantalla:
**********
**********
**********
**********
*
**
***
****
*****
4. Pr ogr ama el al gor i t mo de l os hi l os f umador es , debes
de t ener 3 hi l os que s on l os f umador es el l os nec es i t an
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
mat er i al di f er ent e una v ez que s e enc uent r en l os 3
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
f umandor es s e deben i r a un es t ado wai t i ng
Manejo de archivos y flujos
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
Sección 9 y 10 Temas generales
1. Cr ear un ar r egl o de c ada t i po de
dat o bool ean, by t e, s hor t , i nt ,
c har , f l oat , l ong y doubl e.
2. Pr ogr ama el c omando c p par a c opi ar un ar c hi v o de un
l ugar a ot r o
3. Pr ogr ama el c omando mv par a mov er un ar c hi v o de un
l ugar a ot r o.
2. Cr ear un ar r egl o i r r egul ar en
f or ma de t r i angul o.
Sockets
3. Cr ear un ar r egl o de t i po Mas c ot a
y l l enar l o c on obj et os de
di f er ent es s ubt i pos
1. Cr ea un pr ogr ama que a t r av és de un s oc k et env í e un
mens aj e depende del mens aj e el s er v i dor i mpr i mi r á
i ni c i ando, r ei ni c i ando o apagando.
4. Real i z ar 2 ar r egl os
bi di mens i onal es de l as mi s mas
di mens i ones y s umar l os .
2. Cr ea un pr ogr ama donde el c l i ent e pueda env i ar un
ar c hi v o al s er v i dor
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
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
l a s es i ón ant er i or .
2. Cr ea una i mpl ement ac i ón pr opi a de
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
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
s opor t ar l as oper ac i ones agr egar
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
per mi t a agr egar , bor r ar y bus c ar un
el ement o. El úni c o r equi s i t o es que
l a l i s t a no per mi t a dat os
dupl i c ados .
*
**
***
****
*****
nv oc o el mét odo
r et i r o c on ex i t o
Ej ec ut a l as oper ac i ones s obr e l a c uent a c on v ar i os
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
hac er v ar i os r et i r os , des pués haz l o de nuev o c on
s i nc r oni z ac i ón.
1! = 1
El factorial de 0 es 1.
a y v al i dar s i es
mont o
4. Cr ea una i mpl ement ac i ón de
de l as c ol ec c i ones par a es t o
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 ,
Queue, et c .
al guna
debes
e una
Map,
- Body St r i ng
- Header s Map<St r i ng, St r i ng>
El s er v i dor deber á r es ponder un mens aj e c on l os
s i gui ent es at r i but os :
- Body St r i ng
- Header s Map<St r i ng, St r i ng>
- Ht t pSt at us I nt eger
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
númer os .
Generales
1. Cr ea un pr ogr ama que c or r a en un s er v i dor que t enga
una l i s t a de per s onas , el c l i ent e debe s er c apaz de
l eer l as per s onas , env i ar una per s ona nuev a y
modi f i c ar s us dat os .
Todo s e debe
s oc k et s , s i l
que al ej ec ut
c l i ent e y del
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
ar l o s e t er mi ne el pr oc es o del l ado del
s er v i dor .
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)
El J SR( J av a Spec i f i c at i on Reques t ) 376 J av a pl at f or m modul e s y s t em pr ov ee:
- Si mpl i f i c a l a c ons t r uc c i ón y el
mant eni mi ent o de apl i c ac i ones gr andes y
c ompl ej as
- Mej or a l a s egur i dad y el mant eni mi ent o del
J DK ( Modul ar i z andol o)
- Mej or a el per f or manc e de l as apl i c ac i ones
- Real i z a un enc aps ul ami ent o más f uer t e
- Si mpl i f i c a s u es c al ami ent o hac i a abaj o par a
s er ut i l i z ado en di s pos i t i v i os más pequeños
Uso de módulos
Una v ez que s e def i ni ó un módul o el
s i gui ent e pas o es ut i l i z ar l o, par a es t o
c r ear emos un nuev o módul o c on l a s i gui ent e
c l as e:
package com.devs4j.calculator;
import java.util.ArrayList;
import java.util.List;
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.
Más i nf or mac i ón en
ht t ps : / / openj dk . j av a. net / pr oj ec t s / j i gs aw/ .
JEP's
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 ) :
-
200
201
220
260
261
282
-
J av a modul ar J DK
Modul ar Sour c e c ode
Modul ar r unt i me i mages
Enc aps ul at e mos t of t he i nt er nal api s
Modul e s y s t em
J l i nk : The j av a l i nk er
Crear módulos
Un módul o es bás i c ament e un paquet e de
paquet es or gani z ado por un ar c hi v o
des c r i pt or , a c ont i nuac i ón s e pr es ent a un
ej empl o donde s e ut i l i z a modul ar i dad:
package com.devs4j.math.calculation;
Par a que el c ódi go ant er i or f unc i one s i n
ni ngún pr obl ema s e deber á def i ni r l o
s i gui ent e en el ar c hi v o modul e- i nf o. j av a:
module com.devs4j.calculation {
requires java.base;
requires com.devs4j.math;
}
El ar c hi v o ant er i or def i ne que nues t r o
pr oy ec t o r equi er e del paquet e
c om. dev s 4j . mat h par a f unc i onar , l a
dec l ar ac i ón r equi r es j av a. bas e; no es
nec es ar i a dado que s e hac e de maner a
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 .
Archivo module-info.java
public int sum(int x,int y) {
return processor.sum(x,y);
}
}
Ci ent i f i c Cal c ul ar or ut i l i z a l a c l as e
Cal c ul ar or Pr oc es s or que s e mues t r a a
c ont i nuac i ón:
package com.devs4j.math.operations;
public class CalculatorProcessor {
public int sum(int x,int y) {
return x+y;
}
}
Se puede obs er v ar que s e t i enen l os
s i gui ent es 2 paquet es :
package com.devs4j.math.calculation;
package com.devs4j.math.operations;
Cal c ul at i on def i ne l a i nt er f az a c ompar t i r
c on ot r os pr oy ec t os y oper at i ons c ont i ene
l os det al l es de i mpl ement ac i ón, por es t o
s ol o deber í amos ex poner el paquet e
c al c ul at i on dado que oper at i ons s ol o s e
ut i l i z a i nt er nament e, par a hac er l o c r ear emos
un ar c hi v o l l amado modul e- i nf o. j av a c on l a
s i gui ent e i nf or mac i ón:
module com.devs4j.math {
exports com.devs4j.math.calculation;
}
El ar c hi
paquet e
i nc l ui r
c omo un
vo
c al
el
det
modul e i nf o def i ne que s ol o el
c ul at i on s e ex podr á y al no
paquet e oper at i ons s e mant endr á
al l e de i mpl ement ac i ón.
www. t wi t t er . com/ devs4j
Ant es de dec l ar ar l os módul os del s i s t ema
ut i l i z ando j av a - - l i s t - modul es ,
la
dec l ar ac i ón de un módul o s e hac e c r eando
un ar c hi v o l l amado modul e- i nf o. j av an
i nc l uy endo el nombr e del módul o c omo s e
mues t r a a c ont i nuac i ón:
module com.devs4j.calculation {
...
}
Requires
public class Devs4jTestCalculator {
public static void main(String []args) {
CientificCalculator calc=new CientificCalculator();
System.out.println(calc.sum(10, 20));
List<String>names=newArrayList<>();
System.out.println(names);
}
}
import com.devs4j.math.operations.CalculatorProcessor;
public class ScientificCalculator{
private CalculatorProcessor processor=new
CalculatorProcessor();
Declaración de módulos
Cuando s e c r ea un nuev o módul o s e debe c r ear
un ar c hi v o des c r i pt or l l amado
modul e- i nf o. j av a el c ual puede def i ni r l o
s i gui ent e:
- Nombr e : Nombr e del módul o
- Dependenc i es : Li s t a de dependenc i as del
módul o
- Paquet es publ i c os : Li s t a de paquet es
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
pueden c ons umi r ot r os módul os
- Ser v i c i os a c ons umi r : Li s t a de s er v i c i os a
c ons umi r de ot r os módul os
- 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
t endr á al ut i l i z ar r ef l ec t i on.
La c onv enc i ón de nombr es de l os módul os es
s i mi l ar a l a de l os paquet es .
Por def aul t t odos l os paquet es de un módul o
s on pr i v ados .
Tipos de módulos
Se ut i l i z a par a def i ni r l as dependenc i as
de nues t r o módul o a c ont i nuac i ón un
ej empl o:
module com.devs4j.calculation {
requires com.devs4j.math;
}
Todos l os paquet es ex por t ados por el
módul o def i ni do es t ar án di s poni bl es par a
s u us o.
Requires static
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.
module com.devs4j.calculation {
requires static com.devs4j.math;
}
Requires transitive
Cuando dependemos de un modul o que a s u
v ez t i ene dependenc i as ut i l i z ar emos
r equi r es t r ans i t i v e c omo s e mues t r a a
c ont i nuac i ón:
module com.devs4j.calculation {
requires transitive com.devs4j.math;
}
Exports
Por def aul t un módul o no ex pone ni nguno
de l os paquet es , por mot i v os de
enc aps ul ami ent o f uer t e( St r ong
enc aps ul at i on) debemos def i ni r de f or ma
ex pl í c i t a l os paquet es que s er án
ac c es i bl es c omo s e mues t r a a
c ont i nuac i ón:
module com.devs4j.math {
exports com.devs4j.math.calculation;
}
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
i mpor t ar el paquet e es pec i f i c ado.
A c ont i nuac i ón s e l i s t an l os t i pos de
módul os di s poni bl es :
- Sy s t em modul es: Li s t a de módul os que
c ont i enen l os módul os del J DK puedes
ac c eder a el l os ut i l i z ando el c omando l i s t
modul es .
- Appl i c at i on modul es: Módul os que c r ear emos
y nombr ar emos dur ant e l a c ons t r uc c i ón de
nues t r as apl i c ac i ones .
- Aut omat i c modul es: Módul os que es t ar á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
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
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.
Los módul os pueden s er di s t r i bui dos a t r av és
de ar c hi v os j ar ( Sol o podemos t ener un módul o
por j ar ) .
www. f acebook. com/ devs4j
www. devs4j . com
Java 9 - Modularidad
Produce / Consume
services
Reflection
Los módul os pueden pr oduc i r y c ons umi r
s er v i c i os , más que s ol o paquet es , un s er v i c i o
es una i nt er f az que puede t ener múl t i pl es
i mpl ement ac i ones , a c ont i nuac i ón al gunos punt os
i mpor t ant es :
Ref l ec t i on es un api que t e per mi t e
t r abaj ar c on c l as es , obj et os , mét odos y
ot r os c omponent es del l enguaj e c omo
c l as es que podemos mani pul ar a
c ont i nuac i ón un ej empl o:
- pr ov i des <s er v i c e i nt er f ac e> wi t h <c l as s 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
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
i nt er f az o c l as e abs t r ac t a que s e des ea
c ons umi r .
package com.devs4j.reflection.service;
A c ont i nuac i ón un ej empl o:
class ApplicationService {
void sayHello() {
System.out.println("Hello");
}
}
package com.devs4j.reflection.user;
Ser v i c e
package com.devs4j.service.auth;
import java.lang.reflect.Constructor;
import java.lang.reflect.Method;
public interface UserAuthentication {
public boolean authenticate(String username, String
password);
}
module com.devs4j.service {
exports com.devs4j.service.auth;
}
public class TestApplicationService {
public static void main(String []args)throws Exception
{
Class<?>classObject=
Class.forName
("com.devs4j.reflection.service.ApplicationService");
Pr ov i der
Constructor<?>constructor=
classObject.getDeclaredConstructor();
module com.devs4j.provider {
requires com.devs4j.service;
provides com.devs4j.service.auth.UserAuthentication
with UserDatabaseAuthenticator;
}
constructor.setAccessible(true);
Object instance=constructor.newInstance();
public class TestAuthenticationApplication {
public static void main(String[] args) {
ServiceLoader<UserAuthentication> service =
ServiceLoader.load(UserAuthentication.class);
if(method.getName().equals("sayHello")) {
method.setAccessible(true);
method.invoke(instance);
}
UserAuthentication userAuthentication =
service.findFirst().get();
}
}
}
}
}
module com.devs4j.application {
requires com.devs4j.service;
uses UserAuthentication;
}
Open
Los módul os pueden per mi t i r ac c es o a
t r av és de r ef l ec t i on ut i l i z ando open.
uses
require
Application
Service
requires
provides
Ser v i c e
package com.devs4j.reflection.app;
class ApplicationService {
void sayHello() {
System.out.println("Hello");
}
}
module com.devs4j.service {
exports com.devs4j.service.auth;
exports com.devs4j.reflection.app;
}
Se puede obs er v ar que s e ui l i z a ex por t s
por l o que el ac c es o a t r av és de
r ef l ec t i on s er á r es t r i ngi do.
Appl i c at i on
public class TestAuthenticationApplication {
public static void main(String []args) {
ServiceLoader<UserAuthentication>service=
ServiceLoader.load(UserAuthentication.class);
UserAuthenticationuserAuthentication=
service.findFirst().get();
boolean authenticated= userAuthentication.
authenticate("raidentrance","udemy");
System.out.println(authenticated);
}
}
Se puede obs er v ar que s e ui l i z a ex por t s
por l o que el ac c es o a t r av és de
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
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
podemos t ener ac c es o s i n i mpor t ar s i l a
c l as e s e enc uent r a f uer a del paquet e.
System.out.println(authenticated);
Es t i empo de c ombi nar l os dos ej empl os
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
modi f i c ar án l os s i gui ent es c omponent es :
Method[]methods=classObject.getDeclaredMethods();
for(Methodmethod:methods) {
System.out.printf("Method %s, is accessible
\n",method.getName(),method.canAccess(instance));
Appl i c at i on
boolean authenticated =
userAuthentication.authenticate("raidentrance","udemy");
Probando reflection con
módulos
- opens <paquet e>
ac c es o a t r av és
- opens <paquet e>
aper t ur a de l os
en es pec í f i c o.
i ndi c a que s e per mi t i r á
de r ef l ec t i on
t o <modul e> r es t r i nge l a
paquet es a al gún modul o
Opens f unc i ona i gual que ex por t c on l a
di f er enc i a que per mi t e ac c es o a l os t i pos
no públ i c os a t r av és de r ef l ec t i on.
Al ej ec ut ar el c ódi go ant er i or
obt endr emos l a s i gui ent e ex c epc i ón:
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:
Unabl e t o mak e
c om. dev s 4j . r ef l ec t i on. app. Appl i c at i onSer v i c e( )
ac c es s i bl e: modul e c om. dev s 4j . s er v i c e does not
" 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
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
def i ni c i ón del módul o en s er v i c e c omo s e
mues t r a a c ont i nuac i ón:
module com.devs4j.service {
exports com.devs4j.service.auth;
opens com.devs4j.reflection.app;
}
Una v ez r eal i z ado el c ambi o l a ej ec uc i ón
del mét odo debe s er c or r ec t a
Provider
www. t wi t t er . com/ devs4j
www. f acebook. com/ devs4j
www. devs4j . com
Java 9
Try with resources
Tr y wi t h r es our c es apar ec i ó en l a v er s i ón 7
de j av a c on l a s i gui ent e es t r uc t ur a:
Cuando utilizar JShell
Puedes ut i l i z ar J Shel l par a es c r i bi r
el ement os una v ez e i nmedi at ament e obt ener
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
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:
InputStreamReader isr = new InputStreamReader(System.in);
try(isr) {
}
Extensión al operador
diamante
En J av a 7 s e agr egó el s opor t e par a ut i l i z ar
el oper ador di amant e c omo s e mues t r a a
c ont i nuac i ón:
Configuración
Par a poder
ut i l i z ar l o
agr egar a l
j av a- home/ j
ej ec ut ar el c omando j s hel l y
debes i ns t al ar el J DK de j av a y
as v ar i abl es de ent or no
dk - 9/ bi n.
interface Foo<T>{}
jshell> /vars
|
int x = 45
|
int $3 = 4
|
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
| Welcome to JShell -- Version 9
| For an introduction type: /help intro
jshell> /list
jshell>
1 : System.out.println("Hi");
2 : int x = 45;
List<Integer>list=new ArrayList<>();
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
c l as es anóni mas y s e debí a hac er del
s i gui ent e modo:
Commands
3:2+2
Para salir de jshell utiliza el comando /exit como se
4 : String twice(String s) {return s + s;}
muestra a continuación:
5 : twice("Ocean")
jshell> /exit
Puedes escribir / y utilizar tab para obtener los
| 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
A par t i r de J av a 9 y a puedes ut i l i z ar el
oper ador di amant e c on c l as es abs t r ac t as c omo
s e mues t r a a c ot i nuac i ón:
J s hel l ac ept a s ent enc i as j av a; v ar i abl es ,
mét odos , c l as es , i mpor t s y ex pr es i ones .
Es t as pi ez as de c ódi go s on c onoc i das c omo
s ni ppet s .
feedback verbose)
interface Foo<T> {
}
Dec l ar ac i ón de v ar i abl es
jshell> int x = 45
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
i nt er ac c i ones c on j s hel l .
x ==> 45
Los f eedbac k s di s poni bl es s on:
public static void main(String []args) {
Foo<Integer> foo=new Foo<>() {
};
}
Métodos privados en
interfaces
A par t i r de l a v er s i ón J av a 9 puedes def i ni r
mét odos pr i v ados c on el f i n de que s ean
ut i l i z ados por l os mét odos def aul t , c omo s e
mues t r a a c ont i nuac i ón:
interface Bar {
private void foo() {
}
| created variable x : int
Evaluación de expresiones
jshell> 2 + 2
$3 ==> 4
Feedback
-
v er bos e
nor mal
c onc i s e
s i l ent
Par a c ambi ar el t i po de f eedbac k ut i l i z a
el s i gui ent e c omando:
| created scratch variable $3 : int
/ s et f eedbac k v er bos e
jshell> String twice(String s) {
Pr ueba l os di f er ent es t i pos de f eedbac k
par a v er l os di f er ent es t i pos de
i nt er ac c i ón que puedes t ener .
...>
return s + s;
...> }
private static void foo2() {
}
default void foo3() {
foo();
foo2();
}
Scripting
| created method twice(String)
$5 ==> "OceanOcean"
Puedes es c r i bi r s c r i pt s en ar c hi v os c on
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
mues t r a a c ont i nuac i ón:
| created scratch variable $5 : String
jshell> /save mysnippets.jsh
jshell> twice("Ocean")
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 .
JShell
J Shel l ( J av a Shel l ) es una her r ami ent a
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 ,
s ent enc i as y ex pr es i ones , es t as
i nmedi at ament e mos t r ar án l os r es ul t ados .
...> return "Twice:" + s;
Puedes ejecutarlos como se muestra a
...> }
continuación:
| modified method twice(String)
% jshell mysnippets.jsh
jshell> twice("thing")
Para cargar un script puedes utilizar /open como
$7 ==> "Twice:thing"
se muestra a continuación:
| created scratch variable $7 : String
jshell> /open PRINTING
www. t wi t t er . com/ devs4j
www. f acebook. com/ devs4j
www. devs4j . com