Skip to content

Instantly share code, notes, and snippets.

@HiroNakamura

HiroNakamura/Control.java

Created October 30, 2017 02:07
Show Gist options
  • Save HiroNakamura/8c68a19ba6a0dd04a2a88ddbc0f2022a to your computer and use it in GitHub Desktop.
Save HiroNakamura/8c68a19ba6a0dd04a2a88ddbc0f2022a to your computer and use it in GitHub Desktop.
Download ZIP
Más ejemplos de Java 8: Streams, Collectors, Map, filter, default, method references
Raw
Control.java
package com.codemonkey;
/**
*
*
*@author Codemonkey
*@description Ejemplos de programas en Java
*/
//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());
}
}*/
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment