pello.ioPosts
En la url http://www.chaos.cx he colgado un experimento que sirve para compartir contenidos de forma anónima, pública o privada: ya sean enlaces, fotos, vídeos, etc..
Todavía es una versión prealfa y los errores campan a sus anchas.
Esta montado sobre una especie de framework que no merece tal nombre, en php+mysql y todo el código está alojado en github
SQLite es un gestor de BBDD ligero con el que podemos crear una BBDD que se guarda en un ficherito y luego podemos explotar la BBDD con SQL. En linux o en cualquier consola en la que dispongamos de SQLite, si queremos crear una BBDD hacemos lo siguiente:
JavaJutsu: HashTable
Un hashtable es un array donde los índices pueden ser objetos no necesariamente numéricos. Cada índice debe ser único.
Lo habitual es que el índice sea un String.
HashSet
La muchachada siempre se altera un poco cuando oye hablar de un tipo de estructura que se llama hash. HashSet es una implementación del interfaz Set.
Veamos un ejemplo:
Vector
Java tiene un montón de clases útiles para representar colecciones o estructuras de datos bien conocidas: listas, pilas,... Vamos a ver un Vector, una especie de array dinámico en el que no hace falta indicar el tamaño.
/**
* Vectores
* Clase que muestra el uso de la estructura de datos Vector
*
* Para compilar:
* javac Vectores.java
*
* Para ejecutarlo:
* java Vectores
*/
// Librería necesaria para trabajar con la entrada/salida
import java.io.*;
// Librería necesaria para trabajar con Vector
import java.util.*;
/**
* clase Vectores
* Muestra el uso de la estructura de datos Vector
* El Vector es un super array que permite tamaño dinámico
* y añade muchos métodos para gestionar su contenido.
* Los elementos pueden ser cualquier objeto y se pueden repetir.
*
* @author Pello Altadill
*/
public class Vectores {
/**
* main
* Función principal
* Desde la función principal probamos un Vector
*/
public static void main (String args[])
{
Jugador crack = new Jugador("Maradona",10);
Jugador catacrack = new Jugador("Drenthe",13);
Jugador cr7 = new Jugador("Ronaldo",7);
// Creamos una instancia de Vector para guardar una plantilla
Vector plantilla = new Vector();
// Metemos unos elementos:
plantilla.addElement(crack);
plantilla.addElement(catacrack);
plantilla.addElement(cr7);
// Recorrer la estructura con un for;
for (int i = 0; i < plantilla.size();i++) {
((Jugador)plantilla.elementAt(i)).sacarDatos();
}
System.out.println("Otra pasada con Iterator:");
// Vamos a recorrer con un Iterator
Iterator iterador = plantilla.iterator();
// Nota : enumeration está algo desfasado...
// podemos usar un while
while (iterador.hasNext()) {
// Tenemos que forzar el tipo que devuelve lista a Jugador
Jugador jugadorTmp = (Jugador)iterador.next();
// Ahora ya podemos jugar con esa variable
jugadorTmp.sacarDatos();
}
// Vamos a quitar elementos:
// por referencia de objeto -el primero que encuentre-
plantilla.removeElement(cr7);
// por índice
plantilla.removeElementAt(0);
// Añadimos un elemento creado al vuelo:
plantilla.addElement(new Jugador("Torres",9));
System.out.println("Otra pasada con Enumeration:");
// Recorrer la estructura con el interfaz Enumeration
// Los elementos del Vector pasan a ser un Enumeration
// con unas funciones añadidas: hasMoreElements y nextElement
// Nota : enumeration está algo desfasado...
// podemos usar un while
for (Enumeration lista = plantilla.elements();lista.hasMoreElements();) {
// Tenemos que forzar el tipo que devuelve lista a Jugador
Jugador jugadorTmp = (Jugador)lista.nextElement();
// Ahora ya podemos jugar con esa variable
jugadorTmp.sacarDatos();
}
// Podemos dejar el Vector vacío:
plantilla.removeAllElements();
}
}
/**
* Clase Jugador
* la usamos como objeto para manejar con un vector
*/
class Jugador {
public String nombre;
public int dorsal;
/**
* Constructor
* @param String nombre
* @param int dorsal
*/
Jugador (String nombre, int dorsal) {
this.nombre = nombre;
this.dorsal = dorsal;
}
/**
* sacarDatos
* Muestra los datos de una jugador
*/
public void sacarDatos () {
System.out.println("\nNombre: " + nombre + "\nDorsal: " + dorsal);
}
}
JavaJutsu: funciones estáticas
El programa para jugar a piedra papel tijera:
/**
* @(#)PiedraPapelTijera.java
*
*
* @author
* @version 1.00 2012/1/30
*/
import java.util.Random;
import java.io.*;
public class PiedraPapelTijera {
/**
* log
* Muestra por consola un string
* lo hacemos para simplificar la llamada a System.out.println
* en el resto de funciones
* @param String msg
*/
public static void log(String msg) {
System.out.println(msg);
}
/**
* solicitarUsuario
* Solicita al usuario y número y lo convierte a entero
* @return int
*/
public static int solicitarUsuario() {
Console consola = System.console();
int resultado = 0;
String linea = "";
log("Dame algo:\n 1.Piedra\n 2.Papel\n 3.Tijera");
linea = consola.readLine();
resultado = Integer.parseInt(linea);
return resultado;
}
/**
* maquinaDecideSigno
* Genera un número aleatorio entre 1 y 3
* muestra el nombre del signo escogido
* @return int
*/
public static int maquinaDecideSigno() {
Random random = new Random();
int signo = 0;
// Creamos un array de nombres de signos
// para poder mostrar qué signo saca la máquina
String nombreSignos[] = {"","Piedra","Papel","Tijera"};
signo = random.nextInt(3) + 1;
log("La máquina saca "+ signo+ " es decir: " + nombreSignos[signo]);
return signo;
}
/**
* decidirGanardor
* Decide quién gana:
* 0: empate
* 1: humano
* 2: máquina
* @param int humano
* @param int maquina
* @return int
*/
public static int decidirGanardor(int humano, int maquina) {
int resultado = 0;
switch (humano)
{
case 1: log("Tú has elegido Piedra");
switch (maquina)
{
case 1: resultado = 0;
break;
case 2: resultado = 2;
break;
case 3: resultado = 1;
break;
}
break;
case 2: log("Tú has elegido Papel");
switch (maquina)
{
case 1: resultado = 1;
break;
case 2: resultado = 0;
break;
case 3: resultado = 2;
break;
}
break;
case 3: log("Tú has elegido Tijera");
switch (maquina)
{
case 1: resultado = 2;
break;
case 2: resultado = 1;
break;
case 3: resultado = 0;
break;
}
break;
}
return resultado;
}
public static void main(String args[])
{
String lectura = "";
int jugadah, jugadam, resultado;
int jugador, maquina;
// Inicializo todos a la vez
// qué pro que soy
jugador = maquina = jugadam = jugadah = resultado = 0;
do {
jugadah = solicitarUsuario();
jugadam = maquinaDecideSigno();
resultado = decidirGanardor(jugadah, jugadam);
if (resultado == 1 ) {
log("Ganas la ronda");
jugador++;
} else if (resultado == 2) {
log("Pierdes la ronda");
maquina++;
}
log("Tú: " + jugador + " Com:" + maquina+"\n\n");
} while (jugador<3 && maquina<3);
if (jugador > maquina) {
log("Excelent work");
}
else {
log("n0000000b");
}
log("Winners don't use drugs");
}
}
La resistencia es fútil
De un viejo post de este sitio he llevado a cabo una presentación en la que se habla de algunas pelis relacionadas con la informática, los robots, la ia y el frikismo. En Slideshare se puede ver online.
http://www.slideshare.net/
JavaJutsu: funciones estáticas.
Vamos a hacer un programa procedimental usando funciones estáticas, es decir, nada de POO.
En esta caso el ejemplo es un generador de quinielas:
import java.util.Random;
/**
* @(#)Quinela.java
*
*
* @author Pello Altadill
* @version 0.1
*/
public class Quinela {
/**
* generarNumero
* Método que genera un número aleatorio entre 0 y 2
* @return int
*/
public static int generarNumero () {
Random aleatorio = new Random();
int resultado = 0;
resultado = aleatorio.nextInt(3);
return resultado;
}
/**
* determinarSigno
* Dado un número entero determina un signo de la quiñela
* @param int numero
* @return char
*/
public static char determinarSigno (int numero) {
char resultado = ' ';
switch (numero) {
case 0: resultado = '1';
break;
case 1: resultado = 'X';
break;
case 2: resultado = '2';
break;
default:resultado = '1';
break;
}
return resultado;
}
/**
* mostrar
* Genera un String con el número de casilla y el signo
* @param int casillo
* @param char signo
* @return String
*/
public static String mostrar(int casilla, char signo) {
String resultado = "";
resultado = casilla + ".- " + signo;
return resultado;
}
/**
* @param args the command line arguments
*/
public static void main(String[] args) {
int tmp = 0;
int casillaTmp = 0;
char signoTmp = ' ';
for (int i = 1; i< 16; i++) {
// 1. Generar un número entre 0-2
tmp = generarNumero();
// 2. Determinar el signo: 1, X, 2
signoTmp = determinarSigno(tmp);
// 3. Mostrarlo
System.out.println(mostrar(i,signoTmp));
}
}
}
JavaJutsu, herencia entre clases
Este es un ejemplo de herencia, la clase ClienteVip que hereda de Cliente:
/**
* ClienteVip
* Clase que muestra la declaración de una clase que extiende a otra:
* es decir muestra la HERENCIA
*
* Para compilar:
* javac ClienteVip.java
*
* Para ejecutarlo:
* java ClienteVip
*/
// Librería necesaria para trabajar con la entrada/salida
import java.io.*;
// Libería necesaria para la clase Date
import java.util.Date;
/**
* clase ClienteVip
* Muestra la declaración de ClienteVip, una extensión de la clase Cliente.
* Es un ejemplo simple de herencia, donde creamos una clase especializada
* que hereda todos los atributos y métodos de la clase padre.
* Para lograrlo debemos añadir la clausula extends en la declaración
* de la clase.
*
* @author Pello Altadill
*/
public class ClienteVip extends Cliente {
// ATRIBUTOS o PROPIEDADES DE LA CLASE extendida:
public float descuento;
// MÉTODOS DE LA CLASE: Constructores, y otras funciones
/**
* ClienteVip
* este es el método constructor, al que se invoca
* al crear una instancia de la clase
*/
ClienteVip ()
{
// Lamamos al constructor de la clase padre
super();
System.out.println("Has creado una instancia de ClienteVip");
}
/**
* ClienteVip
* Otro constructor con parámetros.
* Nos sirve para crear una instancia
*/
ClienteVip (String nombre, String apellidos, Date nacimiento, int codigo, float descuento)
{
// Lamamos al constructor de la clase padre
super(nombre,apellidos,nacimiento,codigo);
// Establecemos el atributo descuento
this.descuento = descuento;
System.out.println("Has creado una instancia de ClienteVip");
}
/**
* aplicarDescuento
* Método que aplica el descuento del cliente a un determinado total
* @return resultado
*/
public float aplicarDescuento (float precioTotal)
{
float resultado = precioTotal * (1-descuento);
return resultado;
}
/**
* quitarIVA
* Método que le quita el IVA al cliente de un total
*
*/
public float quitarIVA (float precioTotal)
{
float resultado = precioTotal * (0.82F);
return resultado;
}
/**
* fichaCliente
* Método que sobrescribe al de la clase padre Cliente,
* añadiendo un dato más.
*
*/
public void fichaCliente ()
{
// al principio hace los mismo que la clase padre.
super.fichaCliente();
System.out.println("CLIENTE VIP");
System.out.println("Descuento: " + descuento);
}
/**
* main
* Función principal
* esta función es la que se inicia directamente al ejecutar el programa
* Y desde ella vamos a crear una instancia de ClienteVip
*/
public static void main (String args[])
{
// Creamos un par de instancias
ClienteVip unClienteVip = new ClienteVip();
ClienteVip otroClienteVip = new ClienteVip("Frodo","Bolson", new Date(), 19, 0.10F);
unClienteVip.codigo = 89;
otroClienteVip.fichaCliente();
System.out.println("Total 109.56 euros, con descuento del " + otroClienteVip.descuento + "%: " + otroClienteVip.aplicarDescuento(109.56F));
unClienteVip.saluda();
}
}
JavaJutsu: métodos o funciones
En las funciones podemos tener un retorno y pueden lanzar excepciones.
/**
* Metodos
* Clase que muestra la declaración de todo tipo de métodos
*
* Para compilar:
* javac Metodos.java
*
* Para ejecutarlo:
* java Metodos
*/
// Librería necesaria para trabajar con la entrada/salida
import java.io.*;
/**
* clase Metodos
* Muestra la declaración dedistintos tipos de métodos: constructores,
* métodos con distintos tipos de retorno, métodos que lanzan excepciones,
* métodos estáticos, métodos privados, protegidos y públicos
*
* La clase es un poco absurda pero simplemente trata de mostrar distintos
* tipos de métodos
*
* @author Pello Altadill
*/
public class Metodos {
/**
* Metodos
* Constructor sin parámetros
* estos métodos son los únicos que no devuelven algo explicitamente
*/
Metodos () {
System.out.println("Has creado instancia");
}
/**
* Metodos
* Constructor con parámetros
* estos métodos son los únicos que no devuelven algo explicitamente
*/
Metodos (String opcion) {
super();
System.out.println("Opción pasada: " + opcion);
}
/**
* estatico
* Aquellos que tienen la palabra static se consideran Método de clase,
* puede ser invocado sin que se cree una instancia
* de la clase. ver main.
* De estos métodos solo se crea una copia en memoria, al igual que pasa
* con los atributos que se declaran static.
*/
public static void estatico (int veces) {
for (int i = 0; i < veces;i++) {
System.out.println("Estático> " + i);
}
}
/**
* saludar
* Método publico que devuelve un String
* Si no ponemos nada, se considera público
* @return String
*/
String saludar () {
saludoPrivado();
return "Hola yo te saludo.";
}
/**
* saludoPrivado
* Método que saca un mensaje por consola.
* Solo se puede invocar desde dentro de la clase
*/
private void saludoPrivado () {
System.out.println("Java rulez");
}
/**
* tomarDato
* Método publico lee un valor por consola y devuelve un entero
* Puede lanzar dos excepciones
* @return String
* @throws IOException, NumberFormatException
*/
public int tomarDato () throws IOException, NumberFormatException {
Console c = System.console();
String linea = c.readLine("Dame un número: ");
return Integer.parseInt(linea);
}
/**
* main
* Función principal
* esta función es la que se inicia directamente al ejecutar el programa
* @throw IOException
*/
public static void main (String args[]) throws IOException
{
// Probamos el método estático. No necesitamos crear instancia!!!
Metodos.estatico(5);
Metodos pruebaMetodos = new Metodos("hola");
pruebaMetodos.saludar();
int entero = pruebaMetodos.tomarDato();
}
}
subscribe via RSS