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
public class Control{ public static void main(String[] args) { 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 System.out.println(my_ingeniero);//salario:0.0, hrs:12 my_ingeniero = new Ingeniero(12,10000); System.out.println(my_ingeniero);//salario:10000.0, hrs:12 } }
//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){ this.salario=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 public String toString(){ return super.toString()+" hrs:"+hrs; }
}
//77
public class Control{ public static void main(String[] args) { 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 public String toString(){ return "X{valor: "+valor+"}"; }
}
//76.
public class Control{ public static void main(String[] args) { 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.
public class Control{ public static void main(String[] args) { 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.
public class Control{ public static void main(String[] args) {
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.
public class Control{ public static void main(String[] args) { 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.
public class Control{ public static void main(String[] args) { 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 class Control{ public static final int TAM = 100; public static void main(String[] args) { 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.
public class Control{ static int i = 4; public static void main(String[] args) { for(new Control().i = 10; new Control().i < 20 ; new Control().i++){ System.out.println("Hola "+i);// del 10 al 19 } } }
//69.
public class Control{ static int x =12; public static void main(String[] args) { int
x = 20;
System.out.println("x = "+x); // x = 20 // El compilador toma la x de menor scope (alcance) } }
//68.
public class Control{ public static void main(String[] args) { 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.
public class Control{ public static void main(String[] args) { 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.
public class Control{ public static void main(String[] args) { 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.
public class Control{ public static void main(String[] args) { 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
public class Control{ public static void main(String[] args) { 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.
public class Control{ public static void main(String[] args) { 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){ this.salario=salario; } }
//62.
public class Control{ public static void main(String[] args) { 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.
public class Control{ public static void main(String[] args) { Oficinista ofi = new Oficinista(); ofi.mostrarEdad();//"El oficinista tiene 23 años de edad" } }
class Empleado { private int edad = 33;
public void mostrarEdad(){ System.out.println("El empleado tiene "+edad+" años de edad"); } }
class Oficinista extends Empleado{ private int edad = 23;
public void mostrarEdad(){ System.out.println("El oficinista tiene "+edad+" años de edad"); } }
//60. Shadowing
public class Control{ public static void main(String[] args) { 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
public class Control{ public static void main(String[] args) { System.out.println(new Cliente().getNombre()); //Imprimoirรก: Hola, buenos dias Fernando } }
class Cliente { private String nombre = "Fernando";
public String getNombre(){ String nombre = "Hola, buenos dias "; nombre += this.nombre; return nombre; } }
//58
public class Control{ public static void main(String[] args) { 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
public class Control{ public static void main(String[] args) { 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
public class Control{ public static void main(String[] args) {
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
public class Control{ public static void main(String[] args) { 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
public class Control{ public static void main(String[] args) {
} }
//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
public class Control{ public static void main(String[] args) { 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
public class Control{ public static void main(String[] args) { 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
public class Control{ public static void main(String[] args) { //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
public class Control{ public static void main(String[] args) { 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
public class Control{ public static void main(String[] args) { 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;
public class Control{ public static void main(String[] args) { 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 public String toString(){ 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
public class Control{ public static void main(String[] args) { 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+""); }
static void log(String out){ javax.swing.JOptionPane.showMessageDialog(null,out); } }
//46
import java.util.Arrays; import java.util.List;
import com.codemonkey.clases.Empleado;
public class Control{ public static void main(String[] args) { 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(); Empleado e2 = new Empleado(); Empleado e3 = 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;
public class Control{ public static void main(String[] args) {
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()); }
static void log(String out){ javax.swing.JOptionPane.showMessageDialog(null,out); } }
//44
public class Control{ public static void main(String[] args) { 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); }
static void log(String out){ javax.swing.JOptionPane.showMessageDialog(null,out); } }
//43
import java.util.Arrays;
import java.util.ArrayList; import java.util.List; import java.io.File;
public class Control{ public static void main(String[] args) { 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))) .forEach(System.out::println);
log("\tArchivos xml:"+listaXML); listaXML.stream().forEach(System.out::println); }
static void log(String out){ System.out.println(out); } }
//42
import java.util.Arrays; import java.util.List;
public class Control{ public static void main(String[] args) { 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);
}
static void log(String out){ System.out.println(out);
} }
//41
import java.util.Arrays; import java.util.List; import com.codemonkey.clases.Checador;
public class Control{ public static void main(String[] args) { 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); }
static void log(String out){ System.out.println(out); }
}
//40
import java.util.Arrays; import java.util.List; import com.codemonkey.clases.Checador;
public class Control{ public static void main(String[] args) { 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);
}
static void log(String out){ System.out.println(out); }
}
interface Predicate { boolean test(int n); }
//39
import java.time.LocalDate; import java.time.LocalTime; import java.time.LocalDateTime; import java.time.Month;
public class Control{ public static void main(String[] args) { log(getTiempo()); }
static void log(String out){ javax.swing.JOptionPane.showMessageDialog(null,out); }
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); total+="\tFecha: " + date3+"\n";
LocalTime date4 = LocalTime.of(22, 15); total+="\tFecha: " + date4+"\n";
LocalTime date5 = LocalTime.parse("20:15:30"); total+="\tFecha: " + date5+"\n"; return total; }
}
//38
import javax.swing.JOptionPane;
public class Control{
public static void main(String[] args) { 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));
}
static void log(String out){ 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.File; import java.io.FileReader; import java.io.BufferedReader; import java.util.ArrayList; import java.util.List;
public class Control{
public final static String PATH ="C:\\Users\\Uriel Carraro\\Documents\\programacion\\testJava";
public static void main(String[] args) { 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 void log(String out){ System.out.println(out); }
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 public String toString(){ return "Libro{titulo:"+titulo+", fecha:"+fecha+"}"; } } }
//36
import java.util.Arrays; import java.util.List; import java.util.ArrayList;
public class Control{ public static void main(String[] args) { 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); }
static void log(String out){ javax.swing.JOptionPane.showMessageDialog(null,out); }
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 public String toString(){ return "Libro{titulo:"+titulo+", fecha:"+fecha+"}"; } }
}
//35
import java.util.Arrays; import java.util.List;
public class Control{ public static void main(String[] args) { 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); }
static void log(String out){ javax.swing.JOptionPane.showMessageDialog(null,out); } }
//34
public class Control{ public static void main(String[] args) { 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); }
static void log(String out){ javax.swing.JOptionPane.showMessageDialog(null,out); } }
//33
import java.io.File; import java.io.FileReader; import java.io.BufferedReader; import java.util.ArrayList; import java.util.List;
public class Control{
public final static String PATH ="C:\\Users\\Uriel Carraro\\Documents\\programacion\\testJava";
public static void main(String[] args) { 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"); }
}
static void log(String out){ System.out.println(out); }
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 public String toString(){ return "Libro{titulo:"+titulo+", fecha:"+fecha+"}"; } } }
//32
public class Control{ public static void main(String[] args) { Converter<String,Integer> conv = (from) -> Integer.valueOf(from); Integer entero = conv.convert("12"); log("--Convertido:"+conv); }
static void log(String out){ System.out.println(out);
} }
@FunctionalInterface interface Converter<F, T> { T convert(F from); }
//31
public class Control{ public static void main(String[] args) { 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);
}
static void log(String out){ System.out.println(out); }
}
//30
public class Control { public static void main(String[] args) { 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))); }
static void log(String out){ System.out.println(out); } }
interface Calculos{ public static double CONSTANTE = 273.15;
double getCelsius(double fahrenheit);
default double getKelvin(double celsius){ return celsius + CONSTANTE; } }
//29
public class Control { public static void main(String[] args) { new Control().calcular(); }
static void log(String out){ System.out.println(out); }
//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
public class Control {
public static void main(String[] args) { //Estilo Java 7 new Control().calcular(); }
static void log(String out){ System.out.println(out); }
//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.Arrays; import java.util.List; import java.util.Collections; import java.util.Comparator;
public class Control { public static void main(String[] args) { List<String> listaNueva = Arrays.asList("Teta","Beta","Alpha","Gamma"); new Control().ordenar(listaNueva); }
static void log(String out){ System.out.println(out); }
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.Arrays; import java.util.List; import java.util.Collections; import java.util.Comparator;
public class Control { public static void main(String[] args) { 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);
}
static void log(String out){ System.out.println(out); }
}
//25
import java.util.Arrays; import java.util.List; import java.util.stream.Collectors; import java.util.Random;
public class Control{ public static void main(String[] args) { 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);
}
static void log(String out){ System.out.println(out);
} }
//24
public class Control{ public static void main(String[] args) { 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; import java.util.Arrays; import java.util.List;
public class Control { public static void main(String[] args) { 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+ " "); } } }
static void log(String out){ System.out.println(out); } }
//21
import java.util.Arrays; import java.util.List;
public class Control{ public static void main(String[] args) { List<String> nombres = Arrays.asList("Horacio","Miguel","Pedro","Mariana"); nombres.forEach(System.out::println); } }
//20
public class Control { public final static String SALUDO="Hola, buenos dĂas"; public static void main(String[] args) { Servicio serv = mensaje -> System.out.println(SALUDO+" ,"+mensaje); serv.imprimir("Fernando"); serv.imprimir("Kamyla"); serv.imprimir("Adrian"); }
}
interface Servicio{ void imprimir(String mensaje); }
//19
import java.util.Arrays; import java.util.List; import java.util.Collections;
public class Control { public static void main(String[] args) {
List<String> nombres = Arrays.asList("Mario","Antonio","Eusebio","Leonardo","Berenice"); Control c = new Control(); c.ordenar(nombres); log(""+nombres); }
static void log(String out){ System.out.println(out); }
private void ordenar(List<String> nombres){ Collections.sort(nombres, (n1,n2) -> n1.compareTo(n2)); } }
//18
import java.util.Arrays; import java.util.List; import java.util.function.Function; import java.util.Optional;
public class Control {
public static void main(String[] args) { List<String> nombres = 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) .forEach(System.out::println);
log("--Usando estilo imperativo:"); for(String nombre : nombres){ if(noEsPedro(nombre)){ 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 void log(String out){ System.out.println(out); }
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; }
public String getNombre(){ 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 public String toString(){ return "Usuario{ nombre: "+nombre+", edad: "+edad+"}"; } } }
//17
import java.util.Arrays; import java.util.List; //import java.util.ArrayList; //import java.util.function.Consumer; //import java.util.function.Predicate; import java.util.function.Function; import java.util.stream.Collectors;
public class Control { public static void main(String[] args){
List<String> nombres = 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){ Control.Usuario usuario = new Control.Usuario(nombre); return usuario; } }).map(usuario -> usuario.getNombre()).forEach(System.out::println);
log("--Sin usar Function:"); nombres.stream().filter(Control::noEsPedro) .map(nombre -> { Control.Usuario usuario = new Control.Usuario(nombre); return usuario; }).map(usuario -> usuario.getNombre()).forEach(System.out::println);
log("--Sin usar Function ni instanciar clase Usuario:"); nombres.stream().filter(Control::noEsPedro) .map(nombre -> { return new Control.Usuario(nombre); }).map(usuario -> usuario.getNombre()).forEach(System.out::println);
log("--Sin usar Function ni instanciar clase Usuario (referencia de metodos):"); nombres.stream().filter(Control::noEsPedro) .map(Control.Usuario::new).map(usuario -> usuario.getNombre()).forEach(System.out::println);
log("--Usando ciclo for each y estilo imperativo"); for(String nombre : nombres){ if(noEsPedro(nombre)){ Control.Usuario usuario = new Control.Usuario(nombre); log(""+usuario); } }
log("--Usando Collect:"); List<Control.Usuario> usuarios = nombres.stream() .filter(Control::noEsPedro) .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);
}
static void log(String out){ System.out.println(out); }
private static boolean noEsPedro(String nombre){ return !nombre.equals("Pedro"); }
static class Usuario { private String nombre; private Integer edad=22;
public Usuario(String nombre, Integer edad){ this.nombre=nombre; this.edad=edad; }
public Usuario(String nombre){ this(nombre,12); }
public void setNombre(String nombre){ this.nombre=nombre; }
public String getNombre(){ return nombre; }
public void setEdad(Integer edad){ this.edad=edad; }
public Integer getEdad(){ return edad; }
@Override public String toString(){ return "Usuario{ nombre: "+nombre+", edad: "+edad+"}"; } }
}
//16
import java.util.Arrays; import java.util.List; //import java.util.ArrayList; //import java.util.function.Consumer; //import java.util.function.Predicate; import java.util.function.Function; import java.util.stream.Collectors;
public class Control { public static void main(String[] args){ List<String> nombres = 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){ Control.Usuario usuario = new Control.Usuario(nombre); return usuario; }
}).map(usuario -> usuario.getNombre()).forEach(System.out::println);
log("--Sin usar Function:"); nombres.stream().filter(Control::noEsPedro) .map(nombre -> { Control.Usuario usuario = new Control.Usuario(nombre); return usuario; }).map(usuario -> usuario.getNombre()).forEach(System.out::println);
log("--Sin usar Function ni instanciar clase Usuario:"); nombres.stream().filter(Control::noEsPedro) .map(nombre -> { return new Control.Usuario(nombre); }).map(usuario -> usuario.getNombre()).forEach(System.out::println);
log("--Sin usar Function ni instanciar clase Usuario (referencia de metodos):"); nombres.stream().filter(Control::noEsPedro) .map(Control.Usuario::new).map(usuario -> usuario.getNombre()).forEach(System.out::println);
log("--Usando ciclo for each y estilo imperativo"); for(String nombre : nombres){ if(noEsPedro(nombre)){ Control.Usuario usuario = new Control.Usuario(nombre); log(""+usuario); }
}
log("--Usando Collect:"); List<Control.Usuario> usuarios = nombres.stream() .filter(Control::noEsPedro) .map(Control.Usuario::new) .collect(Collectors.toList());
log(""+usuarios);
}
static void log(String out){ System.out.println(out); }
private static boolean noEsPedro(String nombre){ return !nombre.equals("Pedro"); }
static class Usuario { private String nombre; private Integer edad=22;
public Usuario(String nombre, Integer edad){ this.nombre=nombre;
this.edad=edad; }
public Usuario(String nombre){ this(nombre,0); }
public void setNombre(String nombre){ this.nombre=nombre; }
public String getNombre(){ return nombre; }
public void setEdad(Integer edad){ this.edad=edad; }
public Integer getEdad(){ return edad; }
@Override public String toString(){ return "Usuario{ nombre: "+nombre+", edad: "+edad+"}";
} } }
//15
import java.util.Arrays; import java.util.List; import java.util.function.Predicate; import java.util.function.Consumer;
public class Control { public static void main(String[] args){ 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){ return !nombre.equals("Pedro"); } }).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){ return !nombre.equals("Pedro"); } }).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)) .forEach(System.out::println);
log("--Usando un metodo dentro del filter (y referencia a metodos):"); nombres.stream().filter(Control::noEsPedro) .forEach(System.out::println);
}
static void log(String out){ System.out.println(out); }
private static boolean noEsPedro(String nombre){ return !nombre.equals("Pedro"); }
}
//14
public class Control { public static void main(String[] args){ Servicios suma = (a, b) -> a+b;
log("32 + 65= "+ new Control().funcionA(32,65,suma));
}
static void log(String out){ System.out.println(out); }
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
public class Control { public static void main(String[] args){ Servicios concatenar = (nombre, apellidos) -> nombre.concat(" "+apellidos);
log("Apellidos: "+new Control().funcionB("Andonaegui","Uribe",concatenar));
}
static void log(String out){ System.out.println(out); }
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
import java.util.Arrays; import java.util.List;
public class Control {
public static void main(String[] args){ 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); }
static void log(String out){ System.out.println(out); } }
//11
public class Control { public static void main(String[] args) { Lion lion = new Lion(); log("--Iniciando..."); log("--name:"+lion.name);//si se muestra el name lion.clean();
}
static void log(String out){ System.out.println(out); } }
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;
public class Control { public static void main(String[] args) { BobcatKitten bobCatKitten = new BobcatKitten(); bobCatKitten.encontrar(); bobCatKitten.encontrar(true); //bobCatKitten.encontrar(); } }
//9
import com.codemonkey.clases.BigCat;
public class Control { public static void main(String[] args) { BigCat cat = new BigCat(); log("--name:"+cat.name); //log("--hasFur:"+cat.hasFur); //log("--hasPaws:"+cat.hasPaws); //log("--id:"+cat.id); }
static void log(String out){ System.out.println(out);
} }
//8
import java.util.ArrayList; import java.util.List;
public class Control{ public static void main(String[] args) { 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); } }
static void log(String out){ System.out.println(out);
}
}
//7
import java.util.ArrayList; import java.util.List;
import com.codemonkey.clases.Usuario; import com.codemonkey.clases.Computadora;
public class Control{ public static void main(String[] args) { 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 void log(String out){ System.out.println(out); }
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;
public class Control{ public static void main(String[] args) {
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));
}
static void log(String out){ System.out.println(out); } }
//5
import com.codemonkey.clases.Colores;
public class Control{ public static void main(String[] args){ String my_color = Colores.GREEN.getValor(); new Control().log("--Tu color es:"+my_color); }
public void log(String out){ System.out.println(out); } }
//4
import static java.lang.System.out; import java.util.Calendar;
public class Control{ public static void main(String[] args){ 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){ this.telefono=telefono; }
public String getTelefono(){ return telefono; }
public void setDiaPago(int diaPago){ this.diaPago=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 static java.lang.System.out; import java.util.Calendar; import javax.swing.JOptionPane;
public class Control{ public static void main(String[] args){ 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.diaPago=diaPago;
this.abono=abono; this.telefono=telefono; }
public void setDiaPago(int diaPago){ this.diaPago=diaPago; }
public int getDiaPago(){ return diaPago; }
public void setAbono(double abono){ this.abono=abono; }
public double getAbono(){ return abono; }
public void setTelefono(String telefono){ this.telefono=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"); } }
public static void main(String[] args) { Control.<Bulldog>process(new Bulldog()); }
}
//1. Creando listas
import static java.lang.System.out; import java.util.List; import java.util.ArrayList;
public class Control{ public static void main(String[] args) { List<Integer> lista = new ArrayList() {{ add(7); add(9); add(1);}}; lista.add(3); out.println(lista); out.println(lista.getClass()); } }