Taller Oca Jse8

Taller OCA JSE8
//79
public class Control{
public static void main(String[] args) {
//Esto no compila
//una clase abstract no puede ser instanciada
//Electrodomestico my_electro = new Electrodomestico();
Horno my_horno = new Horno();
//salida:
//objeto Electrodomestico creado
//objeto Horno creado
my_horno.encender();
my_horno.apagar();
abstract class Electrodomestico{
public Electrodomestico(){
System.out.println("objeto Electrodomestico creado");

}
public abstract void encender();
public abstract void apagar();
class Horno extends Electrodomestico{
public Horno(){
System.out.println("objeto Horno creado");
@Override
public void encender(){
System.out.println("Encendiendo...");
@Override
public void apagar(){
System.out.println("Apagando...");
}
//78
Ingeniero my_ingeniero = new Ingeniero();
//objeto Empleado creado
//objeto Ingeniero creado
System.out.println(my_ingeniero);//salario:0.0, hrs:0
my_ingeniero = new Ingeniero(12);
//objeto empleado creado
my_ingeniero = new Ingeniero(12,10000);
//Una clase final no permite extender de ella
final class NoExtendible{}
//Error de compilación, es imposible extender una clase final
//class Extendible extends NoExtendible{}
//Empleado is-a Empleado

class Empleado{
private double salario;
public Empleado(){
System.out.println("objeto Empleado creado");
public Empleado(double salario){
super();
this.salario=salario;
public double getSalario(){
return salario;
public void setSalario(double salario){
@Override
public String toString(){
return "salario:"+salario+", ";
}
//Ingeniero is-a Empleado
//Ingeniero is-a Ingeniero
class Ingeniero extends Empleado{
private int hrs;
public Ingeniero(){
System.out.println("objeto Ingeniero creado");
public Ingeniero(int hrs){
super();
this.hrs=hrs;
public Ingeniero(int hrs, double salario){
super(salario);
this.hrs=hrs;
public int getHrs(){
return hrs;
public void setHrs(int hrs){

this.hrs=hrs;
@Override
return super.toString()+" hrs:"+hrs;
//77
X my_x = new X();
my_x.msg();
//my_x.msg("Fernando");//Error de compilación es private, no se puede acceder
my_x = new X(5, 6);
System.out.println(my_x);//X{valor: 5}
System.out.println(my_x.getValor());//5
System.out.println(X.TAM); // 6
my_x.msg("Fernando",4);
}
}
class X{
//variable de instancia(atributo de la clase, un método también es un atributo de la clase)
private int valor;
//variable de clase
static int TAM =0;
public X(){
this.valor=0;
public X(int valor){
this.valor=valor;
public X(int valor, int TAM){
this(valor);
X.TAM=TAM;
public void msg(){
System.out.println("Metodo de instancia de X");

}
//Es un atributo private, no puede ser accesible desde una instancia
private void msg(String cad){
System.out.println("Hola "+cad+" desde metodo de instancia private de X");
public void msg(String cad, int a){
//aunque es un método private puede ser accesible desde cualquier otro método
public de la clase
msg(cad);
System.out.println("Tienes "+a+" segundos de haber iniciado");
public int getValor(){
return valor;
public void setValor(int valor){
this.valor=valor;
@Override
return "X{valor: "+valor+"}";
}
}
//76.
Calculator my_calculator= new Calculator(5);
System.out.println(my_calculator.j); // j = -100
my_calculator = new Calculator(0);
System.out.println(my_calculator.j); // j = 0
class Calculator{
int j = -100;
Calculator(int i){
if(i > 1)
return;// si i > 1 entonces j conserva su valor incial (j = -100)
j=i;
}
//75.
X my_x = new X();
System.out.println(my_x.x);
System.out.println(my_x.x());
class X {
String x;
X(){}
String x(){
return "X";
//74.

Z my_z = new Z();//objeto Z creado
System.out.println(my_z.MAX);//100
my_z.metodo();//metodo de Z
Y my_y = new Y();//40
System.out.println(my_y.MAX);//100
my_y.nada();//90
X my_x = new X();//objeto X creado
my_x.nada();//Hola
class X{
public X(){
//static in v=0; //Esto provoca un error
System.out.println("objeto X creado");
public void nada(){
//static int n=0;//Esto provoca un error
System.out.println("Hola");
}
class Y{
final int MAX = 100;//Correcto
public Y(){
final int TAM =40;//Correcto
System.out.println(TAM);
public void nada(){
final int G=90;//Correcto
System.out.println(G);
final class Z{
public static final int MAX = 100;
public Z(){
System.out.println("objeto Z creado");
final void metodo(){
//public static final int G =90;//Error
//static int TAM = 10;//Error
System.out.println("metodo de Z");
}
//73.
X my_x = new X();//objeto x creado
X.Y my_y = new X.Y(); // objeto Y creado
class X{
public X(){
System.out.println("objeto X creado");
static class Y{
public Y(){
System.out.println("objeto Y creado");
}
//72.
A my_a = new A();// objeto A creado
my_a.nada();// nada de A
A.B my_b = my_a.new B();// objeto B creado
my_b.nada();// nada de B
//Las clases C y D solo alcanzan el ambito de los metodos
class A{
public A(){
System.out.println("objeto A creado");
class B{
public B(){
System.out.println("objeto B creado");
public void nada(){
System.out.println("nada de B");
class D{
public D(){
System.out.println("objeto D creado");
public void nada(){
System.out.println("nada de D");
public void nada(){
System.out.println("nada de A");
class C{
public C(){
System.out.println("objeto C creado");
}
public void nada(){
System.out.println("nada de C");
//71.
public static final int TAM = 100;
for(int i = 0; i < TAM; i= i + 1){
if(i > 50){
break;// i = 50, no i = 51 porque 51 > 50 y se rompre ciclo
System.out.println("Hola "+i);//del 0 al 50
}
//70.
static int i = 4;
for(new Control().i = 10; new Control().i < 20 ; new Control().i++){
System.out.println("Hola "+i);// del 10 al 19
//69.
static int x =12;
int x = 20;
System.out.println("x = "+x); // x = 20
// El compilador toma la x de menor scope (alcance)
}
//68.
for (int i=0; i < 10 ; i++ ) {
System.out.println(i);// del 0 al 10
int i=12;
System.out.println("***************");
System.out.println(i);// i = 12
//El ambito de la variable i declarada en el for es distinta a la i declarada abajo
//67.
for (int i=0; i < 3 ; i++ )
System.out.println("Hola "+i);// del 0 al 2
//System.out.println("Hola "+i);//Error de compilación, se encuentra en otro

bloque
}
}
//66.
int i=0;
i++; // i= 0 + 1 = 1, pero i = 0 hasta que se invoque;
System.out.println("i = "+i);//i = 1
int j = 0;
++j;//j = 1 + 0; j ya es igual j = 1
System.out.println("j = "+j);// j = 1
//65.
for(int i=0; i < 20 ; i++){
System.out.println("Hola "+i);//del 0 al 19
//System.out.println("Adios "+i);//Error de compilación
System.out.println("-------------------------");
for(int j =20; j > 19; j--){
System.out.println("Hola "+j);// Hola 20 y termina ciclo
System.out.println("-------------------------");
for(int k = 10; k > 3; k--){
System.out.println("Hola "+k);//del 10 al 4, que son mayores a 3
//64. Shadowing
A my_a = new A();
my_a.metodo1();// a = 90
my_a.metodo2();// a = 32
class A{
int a = 32;
public void metodo1(){
int a =90;
System.out.println(a);// a = 90
public void metodo2(){
System.out.println(this.a); // a = 32
//63.
Empleado empleado = new Empleado();
empleado.setEdad(33);
empleado.setSalario(8700.00);
System.out.println("Edad: "+Empleado.edad);
System.out.println("Salario: "+empleado.getSalario());
class Empleado {
static int edad =0;
private double salario=0.0;

public static void setEdad(int edad){
Empleado.edad = edad;
public double getSalario(){
return salario;
public void setSalario(double salario){
//62.
Oficinista ofi = new Oficinista();
ofi.mostrarEdad();//El empleado tiene 0 años de edad
class Empleado {
private int edad;

public void mostrarEdad(){
System.out.println("El empleado tiene "+edad+" años de edad");
class Oficinista extends Empleado{
private int edad = 23;
//61.
Oficinista ofi = new Oficinista();
ofi.mostrarEdad();//"El oficinista tiene 23 años de edad"
class Empleado {
System.out.println("El empleado tiene "+edad+" años de edad");
}
class Oficinista extends Empleado{
System.out.println("El oficinista tiene "+edad+" años de edad");
//60. Shadowing
Cliente cliente = new Cliente();
cliente.mostrar();//Imprimirá: Daniel, ya que cliente delega a Persona mostrar el

nombre
//Necesito el método getNombre() de la instancia cliente
System.out.println(cliente.getNombre());//Imprimirá: Jose
class Persona {
private String nombre = "Daniel";

public void mostrar(){
System.out.println(nombre);
class Cliente extends Persona{
private String nombre = "Jose";
public String getNombre(){
return nombre;
//59. Variables sombra (Shadowing)
//Las variables sombra son aquellas que tienen el mismo nombre
// pero diferente ámbito
System.out.println(new Cliente().getNombre());
//Imprimoirá: Hola, buenos dias Fernando
}
class Cliente {
private String nombre = "Fernando";
String nombre = "Hola, buenos dias ";
nombre += this.nombre;
return nombre;
//58
System.out.println("a de X vale: "+X.a);// a=4;
System.out.println("a de Y vale: "+Y.a);// a = 9;
Y my_y = new Y(new X());
System.out.println("a de X desde Y vale: "
+my_y.getX().a); // a = 4;
class X {
static int a=4;

int x =0;
//x=9;//Esto provoca un error, no se reconoce el identificador
class Y {
static int a=9;
X x;
public Y(){}
public Y(X x){
this.x=x;
public X getX(){
return x;
//57
X my_x; // creo una referencia
my_x = new X();//creo un objeto tipo X
my_x.metodo(); // a = 200
my_x.otro(); // b = 9;
class X {
int a = 100;
int b= 9;
public void metodo(){
int a = 200;
System.out.println(a);// a= 200;
//cuando no se usa this o el nombre de la clase
// el compilador toma la variable de menor alcance (scope)
public void otro(){
int b= 10;
System.out.println(this.b); // b= 9
//56

Test my_test = new Test();
//Error de compilación
//una clase abstract no puede ser instanciada
//Abstracta abst = new Abstracta();
abstract class Abstracta {
private String valor;
public Abstracta(){}
public String getValor(){
return valor;
public void setValor(String valor){
this.valor=valor;
class Test extends Abstracta {}
//55
A my_a = new A();
my_a.A();
class A {
//Compila, no importa que se llame igual que la clase y el constructor
public void A(){
System.out.println("Un metodo de la clase A");
//54
//Esto compila
//En sobrecarga de métodos el tipo puede ser distinto pero

//debe cambiar el tipo y número de parametros
class A {
public void nada(){}
public void nada(String n){}
public String nada(String c, String d){ return "";}
public int nada(boolean b){ return 0;}
public void nada(int n){}
public int nada(double v){ return 0;}
public int nada(Boolean b, String c){return 0;}
public void nada(double v, int x){}
public boolean nada(double v,String x){return false;}
//53
new Control().display();
public void display(){
short Long = 9;
int String = 0;
//byte int = 127; // error, int es una palabra reservada y tipo primitivo
short Integer = 2;
short Float = 0;
short Double = 1;
int Date = 43;
//short boolean =0; // error, boolean es una palabra reservada y tipo primitivo
System.out.println("Hola, mundo");
//52
new Control().display();
public void display(){
int a, b, c;
a = 8;
b = 4;
c = 5;
a = -b; // a = -4;
b = +c; // b = 5;
c = ++a; //c = 1 + (-4) = -3; y a = -3

System.out.println("a = "+a);// a = -3;
System.out.println("b = "+b);// b = 5;
System.out.println("c = "+c);// c = -3;
//51
//el constructor A() es private, provoca error
//A my_a = new A();
A my_a; // creo la referencia
my_a = new A(6); // se crea la instancia de la clase (objeto)
System.out.println(my_a.valor);//6
class A {
public int valor=5;
//se puede tener constructor private

//pero no se puede crear una instancia
private A(){
valor=2;
public A(int valor){
this.valor=valor;
//50
X my_x = new X(); //numero = 5;
my_x.obtener();//numero = 9;
my_x.numero=4;//numero = 4;
my_x.obtener();//numero = 9;
class X {
public int numero;
public X(){
this.numero=5;
public void obtener(){
numero = 9;
System.out.println("Numero vale:"+numero);
//49
X my_x = new X();//numero = 7;
my_x.numero=6;
System.out.println("Numero vale:"+my_x.numero);//numero=6;
my_x.obtener();//numero=6
class X {
public int numero;
public X(){
this.numero=7;
public void obtener(){
System.out.println("Numero vale:"+numero);
//48
import java.util.Collections;
Nodo n1 = new Nodo();
n1.setValor("Primer valor");
//n1.setNodo(null);
Nodo n2 = new Nodo("Segundo valor", n1);
log("--Primer nodo:"+n1);
log("--Segundo nodo:"+n2);
static void log(String out){
System.out.println(out);
}
class Nodo implements Comparable<Nodo> {
private String valor;
private Nodo nodo;
public Nodo(){}
public Nodo(String valor, Nodo nodo){
this.valor=valor;
this.nodo=nodo;
public String getValor(){
return valor;
public void setValor(String valor){
this.valor=valor;
public Nodo getNodo(){
return nodo;
}
public void setNodo(Nodo nodo){
this.nodo=nodo;
@Override
String nodoStr= "";
if(nodo != null){
nodoStr="Nodo{valor:"+valor+", nodo:"+ nodo+"}";
}else{
nodoStr= "Nodo{valor:"+valor+"}";
return nodoStr;
@Override
public int compareTo(Nodo my_nodo){
return nodo.compareTo(my_nodo);
//47
String mostrar="Resultado:\n";
for(int i=0 ; i < "a..z".length() ; i++){
mostrar+=i+",";
log(mostrar);
String existe = (4==5)? "Existe" : "Era obvio que no existe";
log("--Booleano:\n"+existe);
existe = (6>8)? "Existe" : (5==6)? "Existe" : "No existe, no insistas";
log("--Booleano:\n"+existe);
byte b=0;
b=0011;
b=1 - 0;//1
log(b+"");
javax.swing.JOptionPane.showMessageDialog(null,out);
}
//46
import java.util.Arrays;
import java.util.List;
import com.codemonkey.clases.Empleado;
List<Empleado> listaEmp = new Control().getEmpleados();
if(!listaEmp.isEmpty()){
listaEmp.stream()
.map(e -> "\n\tNombre: "+e.getNombre()
+"\n\tApellidos:"+e.getApellidos()
+"\n\tEdad:"+e.getEdad())
.forEach(System.out::println);
public List<Empleado> getEmpleados(){
Empleado e1 = new Empleado();

e1.setNombre("Armand");
e1.setApellidos("Hallager");
e1.setEdad(19);
e2.setNombre("Jerry");
e2.setApellidos("McCarter");
e2.setEdad(21);
e3.setNombre("Jenny");
e3.setApellidos("Smith");
e3.setEdad(29);
List<Empleado> listaEmpleados = Arrays.asList(e1, e2,e3);
return listaEmpleados;
//45
import com.codemonkey.clases.Empleado;

Empleado pers = new Empleado();
pers.setNombre("Fernando");
pers.setApellidos("Carraro Aguirre");
pers.setEdad(36);
log("\tNombre: "+pers.getNombre()+"\n"
+"\tApellidos: "+pers.getApellidos()+"\n"
+"\tEdad: "+pers.getEdad());
//44
byte b=0;
char c='A';
int entero=0;
boolean bool=false;;
double doub=0.00;
String total= new String("");

float num = 123.0f;
Integer e= new Integer("2");
Long numx = new Long(12l);
long numy = 100l;
log("\tDatos:\nByte:"+b
+"\nCaracter:"+c
+"\nBooleano:"+bool
+"\nDouble:"+doub
+"\nString:" +total
+"\nEntero:"+entero
+"\nNumero:"+num
+"\nEntero clase:"+e
+"\nNumero long:"+numy
+"\nNumero long clase:"+numx);
//43
import java.util.ArrayList;
import java.io.File;
List<String> listaArchivos =
Arrays.asList("datos.xml","docum.docx","fichero.dat","respaldo.xml");
List<File> listaXML = new ArrayList<File>();
//for(String arch : listaArchivos){
// if(arch.endsWith(".xml")){
// listaXML.add(new File(arch));
// }
//}
listaArchivos.stream()
.filter(arch -> arch.endsWith(".xml"))
.map(arch -> listaXML.add(new File(arch)))
log("\tArchivos xml:"+listaXML);
listaXML.stream().forEach(System.out::println);
}
//42
List<String> listaString =
Arrays.asList("DOMINGO","LUNES","MARTES","MIERCOLES","JUEVES","VIERNES","SABADO");
log("\t Lista original: "+listaString);
log("\t Usando Lambdas:");
listaString.stream().map((s) -> s.toLowerCase()).forEach((s) ->

System.out.println(s));
log("\t Usando referencia metodos:");
listaString.stream().map(String::toLowerCase).forEach(System.out::println);
}
//41
import com.codemonkey.clases.Checador;
List<Integer> numeros = Arrays.asList(1,2,3,4,5,6,7,8,9,10);
numeros.stream().map(n -> Checador.checado(n)).forEach((n) ->

System.out.println(n));
log("-------------------");
numeros.stream().map(Checador::checado).forEach(System.out::println);
}
}
//40
import com.codemonkey.clases.Checador;
Predicate predicado1 = (n) -> Checador.checado(n);
List<Integer> numeros = Arrays.asList(1,2,3,4,5,6,7,8,9,10);
numeros.stream().map(n -> predicado1.test(n)).forEach(System.out::println);
log("----------------------------");
Predicate predicado2 = Checador::checado;
numeros.stream().map(n -> predicado2.test(n)).forEach(System.out::println);
}
}
interface Predicate {
boolean test(int n);
//39
import java.time.LocalDate;
import java.time.LocalTime;
import java.time.LocalDateTime;
import java.time.Month;
log(getTiempo());
static String getTiempo() {
String total="\n";
LocalDateTime currentTime = LocalDateTime.now();
total+="\tTiempo actual: " + currentTime+"\n";
LocalDate date1 = currentTime.toLocalDate();
total+="\tFecha:" + date1+"\n";
Month month = currentTime.getMonth();
int day = currentTime.getDayOfMonth();
int seconds = currentTime.getSecond();
total+="\tMes: " + month +" , dia: " + day +" ,segundos: " + seconds+"\n";
LocalDateTime date2 = currentTime.withDayOfMonth(10).withYear(2017);
total+="\tFecha: " + date2+"\n";
LocalDate date3 = LocalDate.of(2017, Month.NOVEMBER, 12);
LocalTime date4 = LocalTime.of(22, 15);
LocalTime date5 = LocalTime.parse("20:15:30");
return total;
}
}
//38
import javax.swing.JOptionPane;
Operaciones opera= (k) -> 1.8 * (k-Operaciones.MAX) + 32;//getFahrenheit
log("Kelvin (-23.99) a Fahrenheit:"+new Control().fahrenheit(-23.99,opera));
log("Kelvin (8.909) a Celsius:"+opera.getCelsius(8.909));
OperacionesImpl opImpl = new OperacionesImpl();
log("Kelvin (8.909) a Celsius:"+opImpl.obtenerCelsius(8.909, opera));
log("Kelvin (-23.99) a Fahrenheit:"+opImpl.obtenerFahrenheit(-23.99, opera));
JOptionPane.showMessageDialog(null,out);
}
public double fahrenheit(double kelvin, Operaciones op){
return op.getFahrenheit(kelvin);
class OperacionesImpl{
public double obtenerCelsius(double kelvin, Operaciones op){
return op.getCelsius(kelvin);
public double obtenerFahrenheit(double kelvin, Operaciones op){
return op.getFahrenheit(kelvin);
interface Operaciones{
public static final double MAX = 273.15;
double getFahrenheit(double kelvin);
default double getCelsius(double kelvin){
return kelvin - MAX;
}
//37
import java.io.FileReader;
import java.io.BufferedReader;
public final static String PATH ="C:\\Users\\Uriel

Carraro\\Documents\\programacion\\testJava";
File f = new File(PATH+"\\resultados.txt");
String contenido=null;
String linea=null;
int tam=0;
List<String> listaContenido = new ArrayList<String>();
List<Control.Libro> listaLibros = new ArrayList<Control.Libro>();
try{
FileReader fr = new FileReader(f.getName());

BufferedReader br = new BufferedReader(fr);
if(f.exists() == true && f.isFile() == true){
log("El archivo \""+f.getName()+"\" existe");
log("Ruta completa:"+f.getAbsolutePath());
if(f.canRead() == true)
log("Se puede leer");
if(f.canWrite() == true)
log("Se puede escribir");
log("\tContenido del archivo:");
while((contenido=br.readLine())!=null){
log(contenido);
listaContenido.add(contenido);
log("--------------------------------");
log("--Tam:"+listaContenido.size());
tam= listaContenido.size();
for(int i=0; i < tam; i++){
linea = listaContenido.get(i);
String[] seccion = linea.split(",");
listaLibros.add(new Control.Libro(seccion[0],seccion[1]));
}
log("--\tTitulos:");
listaLibros.stream().map(libro ->
libro.getTitulo()).forEach(System.out::println);
log("--\tFechas:");
listaLibros.stream().map(libro ->
libro.getFecha()).forEach(System.out::println);
}catch(Exception e){
log("Ha ocurrido un error");
static class Libro {
private String titulo;
private String fecha;
public Libro(String titulo, String fecha){
this.titulo=titulo;
this.fecha=fecha;
}
public String getFecha(){
return fecha;
public String getTitulo(){
return titulo;
@Override
return "Libro{titulo:"+titulo+", fecha:"+fecha+"}";
//36
List<String> lineaString = Arrays.asList("A,5","B,3");
List<Control.Libro> listaLibro = new ArrayList<Control.Libro>();
String linea=null;
for(int i=0; i < lineaString.size(); i++){
linea = lineaString.get(i); // 0 = "A,5"
String[] seccion = linea.split(",");
//seccion[0] = "A"
//seccion[1] = "5"
listaLibro.add(new Libro(seccion[0],seccion[1]));
//Titulos
listaLibro.stream().map(libro -> libro.getTitulo()).forEach(System.out::println);
//Fechas
listaLibro.stream().map(libro -> libro.getFecha()).forEach(System.out::println);

this.titulo=titulo;
this.fecha=fecha;
return fecha;
return titulo;
@Override
//35
List<String> listaString = Arrays.asList("El asesinato del Dr. Monroe, 12/04/1990");
log("Lista:\n"+listaString);
String cadena = listaString.get(0);
log("Cadena obtenida:\n"+cadena);
String[] vect= cadena.split(",");
log(vect[0]+" - "+vect[1]);
System.exit(0);
//34
String cadena = "El asesinato del Dr. Monroe, 12/04/1990";

log("Cadena original:\n"+cadena);
String[] partes = cadena.split(",");
log("Titulo:\n"+partes[0]);
log("Fecha:\n"+partes[1]);
System.exit(0);
//33
import java.io.FileReader;
import java.io.BufferedReader;

public final static String PATH ="C:\\Users\\Uriel
Carraro\\Documents\\programacion\\testJava";
File f = new File(PATH+"\\resultados.txt");
String contenido=null;
int tam=0;
List<String> listaContenido = new ArrayList<String>();
List<Control.Libro> listaLibros = new ArrayList<Control.Libro>();
try{
FileReader fr = new FileReader(f.getName());
BufferedReader br = new BufferedReader(fr);
if(f.exists() == true && f.isFile() == true){
log("El archivo \""+f.getName()+"\" existe");
log("Ruta completa:"+f.getAbsolutePath());
if(f.canRead() == true)
log("Se puede leer");
if(f.canWrite() == true)
log("Se puede escribir");
log("\tContenido del archivo:");
while((contenido=br.readLine())!=null){
log(contenido);
listaContenido.add(contenido);
}
}
log("---------------------------------");
listaContenido.stream().forEach(System.out::println);
log("--Tam:"+listaContenido.size());
}catch(Exception e){
log("Ha ocurrido un error");
this.titulo=titulo;
this.fecha=fecha;
return fecha;
}
return titulo;
@Override
//32
Converter<String,Integer> conv = (from) -> Integer.valueOf(from);
Integer entero = conv.convert("12");
log("--Convertido:"+conv);
}
@FunctionalInterface
interface Converter<F, T> {
T convert(F from);
//31
java.util.List<String> nombres =
java.util.Arrays.asList("Eusebio","Horacio","Berenice","Ana","Alondra","Carla");
log("--Lista original:"+nombres);
java.util.Collections.sort(nombres, (String a, String b) -> {
return b.compareTo(a);
});
log("--Lista ordenada (descendente):"+nombres);
java.util.Collections.sort(nombres, (String a, String b) -> {
return a.compareTo(b);
});
log("--Lista ordenada (ascendente):"+nombres);
log("");
java.util.List<String> otros =
java.util.Arrays.asList("Eusebio","Horacio","Berenice","Ana","Alondra","Carla");
log("--Lista original:"+otros);
java.util.Collections.sort(otros, (x,y) -> x.compareTo(y));
log("--Lista ordenada:"+otros);
//30
public class Control {
Calculos calculo = new Calculos(){
@Override
public double getCelsius(double fahrenheit){
return 0.5 * (fahrenheit -32);
}
};
log("--Celsius:");
log("\t"+calculo.getCelsius(123.08));
log("--Kelvin:");
log("\t"+calculo.getKelvin(calculo.getCelsius(123.08)));
interface Calculos{
public static double CONSTANTE = 273.15;
double getCelsius(double fahrenheit);
default double getKelvin(double celsius){
return celsius + CONSTANTE;
//29
new Control().calcular();
//Estilo Java 8
public void calcular(){
Operacion operacion = (a,b) -> (a+b) / 2.0 ;
log("--Promedio:"+operacion.calcularPromedio(34.0,33.0));
interface Operacion {
double calcularPromedio(double a, double b);
//28

//Estilo Java 7
new Control().calcular();
//Estilo Java 7
public void calcular(){
Operacion operacion = new Operacion(){
@Override
public double calcularPromedio(int a, int b){
return (a+b) / 2.0;
};
log("--Promedio: "+operacion.calcularPromedio(45,33));
interface Operacion {
double calcularPromedio(int a, int b);
}
//27 Lambda
import java.util.Comparator;
List<String> listaNueva = Arrays.asList("Teta","Beta","Alpha","Gamma");
new Control().ordenar(listaNueva);
public void ordenar(List<String> lista){
log("--Nueva lista:"+lista);
Collections.sort(lista, (String s1, String s2) -> s1.compareTo(s2));
log("--Lista ordenada:"+lista);
}
//26 Lambda
import java.util.Comparator;
List<String> lista =
Arrays.asList("Gallito","Gato","Ave","Perro","Vaca","Pollo","Vaquita");
log("--Lista original:"+lista);
//Estilo Java 7
Collections.sort(lista, new Comparator<String>(){
@Override
public int compare(String s1, String s2){
return s1.compareTo(s2);
});
log("--Lista ordenada:"+lista);
List<String> listaNueva = Arrays.asList("Beta","Alpha","Gamma");
log("--Nueva lista:"+listaNueva);
//Usando expresión lambda
Collections.sort(listaNueva, (String s1, String s2) -> s1.compareTo(s2));
log("--Lista ordenada:"+listaNueva);
//25
import java.util.stream.Collectors;
import java.util.Random;
List<String> nombres = Arrays.asList("","Genaro","Maria","Joaquin","","Ignacio");
List<String> quitarEspacios = nombres.stream().filter(nombre ->

!nombre.isEmpty()).collect(Collectors.toList());
log("--Lista sin espacios:");
quitarEspacios.forEach(System.out::println);
List<Integer> numeros = Arrays.asList(45,-32,0,1,5,12,9,-3,7,33);
List<Integer> cuadrados = numeros.stream().map(n ->

n*n).distinct().collect(Collectors.toList());
log("--Cuadrados:");
cuadrados.forEach(System.out::println);
List<String> letras = Arrays.asList("A","","","E","I","","O","U","");
int cuentaVacios = (int) letras.stream().filter(letra -> letra.isEmpty()).count();
log("--Vacios:"+cuentaVacios);
Random aleatorio = new Random();
log("--Aleatorios:");
aleatorio.ints().limit(2).sorted().forEach(System.out::println);
}
//24
Carro car = new Carro();
car.mensaje();
interface Vehiculo {
default void mensaje(){
System.out.println("Soy un Vehiculo");
interface Ruedas {
default void mensaje(){
System.out.println("Tengo 4 Ruedas");
}
}
class Carro implements Vehiculo, Ruedas {
public void mensaje(){
Vehiculo.super.mensaje();
Ruedas.super.mensaje();
System.out.println("Soy un Carro");
//23
import java.util.function.Predicate;
List<Integer> numeros = Arrays.asList(1,2,3,4,5,6,7,8);
evaluar(numeros, n -> n % 3 == 0);
log("--------------------------");
evaluar(numeros, n -> n % 2 == 0);
static void evaluar(List<Integer> lista, Predicate<Integer> predicado){

for(Integer n : lista){
if(predicado.test(n)){
log(n+ " ");
//21
List<String> nombres = Arrays.asList("Horacio","Miguel","Pedro","Mariana");
nombres.forEach(System.out::println);
}
//20
public final static String SALUDO="Hola, buenos días";
Servicio serv = mensaje -> System.out.println(SALUDO+" ,"+mensaje);
serv.imprimir("Fernando");
serv.imprimir("Kamyla");
serv.imprimir("Adrian");
interface Servicio{
void imprimir(String mensaje);
//19

List<String> nombres =
Arrays.asList("Mario","Antonio","Eusebio","Leonardo","Berenice");
Control c = new Control();
c.ordenar(nombres);
log(""+nombres);
private void ordenar(List<String> nombres){
Collections.sort(nombres, (n1,n2) -> n1.compareTo(n2));
//18
import java.util.function.Function;
import java.util.Optional;

Arrays.asList("Tomas","Angel","Maria","Pedro","Jose","Yolanda");
log("--Usando ciclo for each:");
for(String nombre : nombres){
if(noEsPedro(nombre)){
log(nombre);
log("--Usando Streams, Filter y forEach:");
nombres.stream()
.filter(Control::noEsPedro)
log("--Usando estilo imperativo:");
Control.Usuario usuario = new Control.Usuario(nombre);
log(" "+usuario);
List<Control.Usuario> listaUsuarios = Arrays.asList(

new Control.Usuario("Hugo",32,
Arrays.asList("7221229988","7221332452")),
new Control.Usuario("Pedro",34,
Arrays.asList("7227768978","7223337865")),
new Control.Usuario("Alondra",17,
Arrays.asList("722332121","7221776609")));
log("--Usando Function:");
listaUsuarios.stream()
.map(new Function<Control.Usuario, Object>(){
@Override
public Object apply(Control.Usuario usuario){
return usuario.getTelefonos();
}).forEach(System.out::println);
log("--Usando flatMap y Optional:");
Optional<String> telefonoBuscar= listaUsuarios.stream()
.map(usuario -> usuario.getTelefonos().stream())
.flatMap(stringStream -> stringStream.filter(telefono ->

telefono.equals("7227768978")))
.findAny();
log("--Telefono: "+telefonoBuscar);
log("--");
telefonoBuscar.ifPresent(tel -> System.out.println(tel));
log("--");
telefonoBuscar.ifPresent(System.out::println);
public static boolean noEsPedro(String nombre){
return !nombre.equals("Pedro");
static class Usuario {
private String nombre;
private Integer edad=22;
private List<String> telefonos;
public Usuario(String nombre, Integer edad){
this.nombre=nombre;
this.edad=edad;
public Usuario(String nombre, Integer edad, List<String> telefonos){
this.nombre=nombre;
this.edad=edad;
this.telefonos=telefonos;
}
public Usuario(String nombre){
this(nombre,12);
public void setNombre(String nombre){
this.nombre=nombre;
return nombre;
public void setTelefonos(List<String> telefonos){
this.telefonos=telefonos;
public List<String> getTelefonos(){
return telefonos;
public void setEdad(Integer edad){
this.edad=edad;
}
public Integer getEdad(){
return edad;
@Override
return "Usuario{ nombre: "+nombre+", edad: "+edad+"}";
//17
//import java.util.ArrayList;
//import java.util.function.Consumer;
//import java.util.function.Predicate;
public static void main(String[] args){

Arrays.asList("Ana","Pedro","Paola","Veronica","Jacobo","Mario");
//Control.Usuario usuario = new Control.Usuario("","");
log("--Usando Streams, Filter, Map y Function:");
nombres.stream().filter(Control::noEsPedro).map(new Function<String,Usuario>(){
@Override
public Usuario apply(String nombre){
return usuario;
}).map(usuario -> usuario.getNombre()).forEach(System.out::println);
log("--Sin usar Function:");
nombres.stream().filter(Control::noEsPedro)
.map(nombre -> {
return usuario;
log("--Sin usar Function ni instanciar clase Usuario:");
.map(nombre -> {
return new Control.Usuario(nombre);

log("--Sin usar Function ni instanciar clase Usuario (referencia de metodos):");
.map(Control.Usuario::new).map(usuario ->
usuario.getNombre()).forEach(System.out::println);
log("--Usando ciclo for each y estilo imperativo");
log(""+usuario);
log("--Usando Collect:");
List<Control.Usuario> usuarios = nombres.stream()
.map(Control.Usuario::new)
.collect(Collectors.toList());
log(""+usuarios);
log("--Uso de MaptoInt");
int suma = usuarios.stream()
.mapToInt(usuario -> {
return usuario.getEdad();
}).sum();
log("suma: "+suma);
log("--Simplificando, usando referencias a metodos");
suma = usuarios.stream()
.mapToInt(Control.Usuario::getEdad).sum();
log("--Suma:"+suma);
private static boolean noEsPedro(String nombre){
this.nombre=nombre;
this.edad=edad;
}
this(nombre,12);
this.nombre=nombre;
return nombre;
this.edad=edad;
return edad;
@Override
}
}
//16
//import java.util.ArrayList;
//import java.util.function.Consumer;
//import java.util.function.Predicate;
Arrays.asList("Ana","Pedro","Paola","Veronica","Jacobo","Mario");
//Control.Usuario usuario = new Control.Usuario("","");
log("--Usando Streams, Filter, Map y Function:");
nombres.stream().filter(Control::noEsPedro).map(new Function<String,Usuario>(){
@Override
public Usuario apply(String nombre){
return usuario;
}
log("--Sin usar Function:");
.map(nombre -> {
return usuario;
log("--Sin usar Function ni instanciar clase Usuario:");
.map(nombre -> {
return new Control.Usuario(nombre);
log("--Sin usar Function ni instanciar clase Usuario (referencia de metodos):");
.map(Control.Usuario::new).map(usuario ->
usuario.getNombre()).forEach(System.out::println);
log("--Usando ciclo for each y estilo imperativo");
log(""+usuario);
}
}
log("--Usando Collect:");
List<Control.Usuario> usuarios = nombres.stream()
.map(Control.Usuario::new)
.collect(Collectors.toList());
log(""+usuarios);
this.nombre=nombre;
this.edad=edad;
this(nombre,0);
this.nombre=nombre;
return nombre;
this.edad=edad;
return edad;
@Override

}
//15
import java.util.function.Predicate;
import java.util.function.Consumer;
List<String> nombres = Arrays.asList("Ana","Edith","Juan","Pedro","Horacio");
log("--Usando ciclo forEach:");
for(String n : nombres){
if(!n.equals("Pedro")){
log(n);
log("--Usando stream, lambdas y Predicate:");

nombres.stream().filter(new Predicate<String>(){
public boolean test(String nombre){
}).forEach(nombre -> System.out.println(nombre));
log("--Usando stream, lambdas, Predicate y referencia a metodos:");
nombres.stream().filter(new Predicate<String>(){
public boolean test(String nombre){
}).forEach(System.out::println);
log("--Sin usar Predicate:");
nombres.stream().filter(nombre -> !nombre.equals("Pedro"))
.forEach(nombre -> System.out.println(nombre));
log("--Usando Consumer(Consumidor):");
nombres.stream().filter(nombre -> !nombre.equals("Pedro"))
.forEach(new Consumer<String>(){
@Override
public void accept(String nombre){
System.out.println(nombre);
});
log("--Usando un metodo dentro del filter:");
nombres.stream().filter(nombre -> noEsPedro(nombre))
log("--Usando un metodo dentro del filter (y referencia a metodos):");
//14
Servicios suma = (a, b) -> a+b;

log("32 + 65= "+ new Control().funcionA(32,65,suma));
public int funcionA(int a, int b, Servicios servicios){
return servicios.operacion(a,b);
interface Servicios{
public abstract int operacion(int a, int b);
//13
Servicios concatenar = (nombre, apellidos) -> nombre.concat(" "+apellidos);

log("Apellidos: "+new Control().funcionB("Andonaegui","Uribe",concatenar));
public String funcionB(String x, String y, Servicios servicios){
return servicios.union(x,y);
interface Servicios{
public abstract String union(String x, String y);
//12

List<String> numeros = Arrays.asList("1","2","3","4","5");
log("--Listar todos los numeros:");
numeros.stream().forEach(System.out::println);
List<String> letras = Arrays.asList("A","B","C","D","E","F");
log("--Letras:"+letras);
log("--Minusculas");
letras.stream().map(l-> l.toLowerCase()).forEach(System.out::println);
//11
Lion lion = new Lion();
log("--Iniciando...");
log("--name:"+lion.name);//si se muestra el name
lion.clean();
}
abstract class Cat {
String name ="El gato barato";//atributo que hereda Lion
void clean(){
System.out.println("Una clase abstract no puede ser instanciada");
class Lion extends Cat {
void clean(){
System.out.println("--Metodo clean de la clase Lion");
//10
import com.codemonkey.clases.BobcatKitten;
BobcatKitten bobCatKitten = new BobcatKitten();
bobCatKitten.encontrar();
bobCatKitten.encontrar(true);
//bobCatKitten.encontrar();
//9
import com.codemonkey.clases.BigCat;
BigCat cat = new BigCat();
log("--name:"+cat.name);
//log("--hasFur:"+cat.hasFur);
//log("--hasPaws:"+cat.hasPaws);
//log("--id:"+cat.id);
}
//8
List<String> lista = new ArrayList<String>();
lista.add("A");
lista.add("B");
lista.add("C");
lista.add("D");
lista.add("E");
if(!lista.isEmpty()){
log("--Lista llena:"+lista);
lista.stream().map(s-> s.toString()).forEach(System.out::println);
}
//7
import com.codemonkey.clases.Usuario;
import com.codemonkey.clases.Computadora;
if(!getUsuarios().isEmpty()){
log("--Lista de usuarios llena");
log("--Total usuarios:"+getUsuarios().size());
for(Usuario user : getUsuarios()){
log("--Id: "+user.getIdusuario());
log("--Usuario: "+user.getUsuario());
log("--Password: "+user.getPassword());
log("--Area: "+user.getArea());
log("--Id Computadora:
"+user.getComputadora().getIdcomputadora());
log("--No. bien: "+user.getComputadora().getBien());
log("--No. arrendamiento:
"+user.getComputadora().getArrendado());
log("--No. asignado: "+user.getComputadora().getAsignado());
log("--Tipo: "+user.getComputadora().getTipo());
log("--Modelo: "+user.getComputadora().getModelo());
log("--Operativo: "+user.getComputadora().getOperativo());
log("--Maquina: "+user.getComputadora().getMaquina());
log("--Ip: "+user.getComputadora().getIp());
log("--Dns: "+user.getComputadora().getDns());
log("--Red: "+user.getComputadora().getRed());
static List<Usuario> getUsuarios(){
List<Usuario> usuarios = new ArrayList<Usuario>();
usuarios.add(new Usuario(1l,"AdrianTorres","*****","Sistemas", new

Computadora(1l, "mxj-213f","7723","22",
"Linux","Escritorio","PC22","192.168.2.34","192.168.1.1","WORKGROUP","Toshiba")));
usuarios.add(new Usuario(6l,"MarianaRom","*****","Administracion", new

Computadora(6l, "mxj-hij","7710","9",
"Windows","Laptop","PC09","192.168.2.10","192.168.1.1","WORKGROUP","Lenovo")));
return usuarios;
//6
import com.codemonkey.clases.Triangulo;
import com.codemonkey.servicios.Funciones;
import com.codemonkey.servicios.FuncionesImpl;
Funciones funcionesImpl = new FuncionesImpl();
Triangulo my_triangulo = new Triangulo(funcionesImpl);
my_triangulo.setNombre("Triangulo equilatero");
my_triangulo.setAlto(12);//altura
my_triangulo.setAncho(24);//base
log("--Triangulo:"+my_triangulo);
log("--Area:"+my_triangulo.obtenerArea( (double) my_triangulo.getAncho(),

(double) my_triangulo.getAlto()));
log("--Perimetro:"+my_triangulo.obtenerPerimetro(10.0));
}
//5
import com.codemonkey.clases.Colores;
String my_color = Colores.GREEN.getValor();
new Control().log("--Tu color es:"+my_color);
public void log(String out){
}
//4
import static java.lang.System.out;
import java.util.Calendar;
Cliente cliente = new Cliente();
cliente.setAbono(320);
cliente.setDiaPago(7); //1 Domingo, 2 Lunes, 3 Martes, 4 Miércoles, 5 Jueves, 6 Viernes, 7

Sábado
cliente.setMedioContacto(MedioContacto.TWITTER);
cliente.setEmail("gatobalin@latinmail");
cliente.setTwitter("@Gatobalin");
cliente.setTelefono("722332222");
//inyectamos el objeto especifico
cliente.setMensaje(new MensajeTwitter());
cliente.enviarRecordatorio();
System.exit(0);
}
class Cliente{
private long idcliente;
private int diaPago;
private double abono;
private String telefono;
private String twitter;
private String email;
private MedioContacto medioContacto;
private IMensaje mensaje;
public Cliente(){}
public Cliente(int diaPago, double abono, String telefono
,String twitter, String email){
super();
this.diaPago=diaPago;
this.abono=abono;
this.telefono=telefono;
this.twitter=twitter;
this.email=email;
}
public void setIdcliente(long idcliente){
this.idcliente=idcliente;
public long getIdcliente(){
return idcliente;
public void setMedioContacto(MedioContacto medioContacto){
this.medioContacto=medioContacto;
public MedioContacto getMedioContacto(){
return medioContacto;
public void setMensaje(IMensaje mensaje){
this.mensaje=mensaje;
public IMensaje getMensaje(){
return mensaje;
public void setTwitter(String twitter){
this.twitter=twitter;
}
public String getTwitter(){
return twitter;
public void setEmail(String email){
this.email=email;
public String getEmail(){
return email;
public void setTelefono(String telefono){
public String getTelefono(){
return telefono;
public void setDiaPago(int diaPago){
}
public int getDiaPago(){
return diaPago;
public void setAbono(double abono){
this.abono=abono;
public double getAbono(){
return abono;
public void enviarRecordatorio() {
Calendar calendar = Calendar.getInstance();
int dia = calendar.get(Calendar.DAY_OF_WEEK);
if (dia == diaPago && abono >= 300) {
if(medioContacto == MedioContacto.EMAIL)
mensaje.enviar(email, "Favor de pasar a pagar");
else if (medioContacto == MedioContacto.SMS)
mensaje.enviar(telefono, "Favor de pasar a pagar");
else if(medioContacto == MedioContacto.TWITTER)
mensaje.enviar(twitter, "Favor de pasar a pagar");
}
}
interface IMensaje {
void enviar(String destinatario, String mensaje);
class MensajeTwitter implements IMensaje {
@Override
public void enviar(String destinatario, String mensaje) {
System.out.printf("Enviando mensaje via Twitter a %s \n Mensaje: %s", destinatario,

mensaje);
enum MedioContacto{
EMAIL, SMS, TWITTER;
}
//3
import java.util.Calendar;
import javax.swing.JOptionPane;
Cliente cli = new Cliente(7, 340.00, "7221225843");
out.println("Enviando recordatorio ...");
cli.enviarRecordatorio();
System.exit(0);
class Cliente{
private int diaPago;
private double abono;
private String telefono;
public Cliente(){}
public Cliente(int diaPago, double abono, String telefono){
super();
this.abono=abono;
public void setDiaPago(int diaPago){
public int getDiaPago(){
return diaPago;
public void setAbono(double abono){
this.abono=abono;
public double getAbono(){
return abono;
public void setTelefono(String telefono){
}
public String getTelefono(){
return telefono;
public void enviarRecordatorio(){
Calendar calendar = Calendar.getInstance();
int dia = calendar.get(Calendar.DAY_OF_WEEK);
if(dia == this.diaPago && this.abono >= 300.00){
JOptionPane.showMessageDialog(null, "Favor de pagar");
//2. Uniones o simulación de uniones en tipos genéricos que usan covarianza o contravarianza
//source: http://www.javamexico.org/blogs/cid/curiosidades_programando_java
public class Control<T> {
static interface Animal {
default void eat(){
System.out.println("Comiendo");
}
}
static abstract class Dog {
public abstract void walk();
public static <T extends Dog & Animal> void process(T type) {
type.eat();
static class Bulldog extends Dog implements Animal{
public void walk(){
System.out.println("El perro es un cuadrupedo");
Control.<Bulldog>process(new Bulldog());
}
//1. Creando listas
List<Integer> lista = new ArrayList() {{ add(7); add(9); add(1);}};
lista.add(3);
out.println(lista);
out.println(lista.getClass());

Taller Oca Jse8

Caricato da

Informazioni sul documento

Copyright

Formati disponibili

Condividi questo documento

Condividi o incorpora il documento

Opzioni di condivisione

Hai trovato utile questo documento?

Questo contenuto è inappropriato?

Copyright:

Formati disponibili

Taller Oca Jse8

Caricato da

Copyright:

Formati disponibili

Taller OCA JSE8

public class Control{

public static void main(String[] args) {

//una clase abstract no puede ser instanciada

//Electrodomestico my_electro = new Electrodomestico();

Horno my_horno = new Horno();

//objeto Electrodomestico creado

//objeto Horno creado

abstract class Electrodomestico{

System.out.println("objeto Electrodomestico creado");

public abstract void encender();

public abstract void apagar();

class Horno extends Electrodomestico{

System.out.println("objeto Horno creado");

public void encender(){

public void apagar(){

public class Control{

public static void main(String[] args) {

Ingeniero my_ingeniero = new Ingeniero();

//objeto Empleado creado

//objeto Ingeniero creado

my_ingeniero = new Ingeniero(12);

//objeto empleado creado

my_ingeniero = new Ingeniero(12,10000);

//Una clase final no permite extender de ella

final class NoExtendible{}

//Error de compilación, es imposible extender una clase final

//class Extendible extends NoExtendible{}

//Empleado is-a Empleado

private double salario;

System.out.println("objeto Empleado creado");

public Empleado(double salario){

public double getSalario(){

public void setSalario(double salario){

public String toString(){

return "salario:"+salario+", ";

//Ingeniero is-a Ingeniero

class Ingeniero extends Empleado{

private int hrs;

System.out.println("objeto Ingeniero creado");

public Ingeniero(int hrs){

public Ingeniero(int hrs, double salario){

public int getHrs(){

public void setHrs(int hrs){

public String toString(){

return super.toString()+" hrs:"+hrs;

public class Control{

public static void main(String[] args) {

X my_x = new X();

//my_x.msg("Fernando");//Error de compilación es private, no se puede acceder

my_x = new X(5, 6);

//variable de instancia(atributo de la clase, un método también es un atributo de la clase)

private int valor;

static int TAM =0;

public X(int valor){

public X(int valor, int TAM){

public void msg(){

System.out.println("Metodo de instancia de X");

//Es un atributo private, no puede ser accesible desde una instancia

private void msg(String cad){

System.out.println("Hola "+cad+" desde metodo de instancia private de X");

public void msg(String cad, int a){

System.out.println("Tienes "+a+" segundos de haber iniciado");

public int getValor(){