pello.ioPosts
JavaJutsu: clases
Java es una especie de C++ simplificado al que le han quitado la herencia múltiple y los punteros. Como todo lenguaje orientado a objetos utiliza clases, con sus propiedades y métodos. Veamos un par de ejemplos:
Clase Genérica:
/**
* Clases
* Clase que muestra la declaración de una clase
*
* Para compilar:
* javac Clases.java
*
* Para ejecutarlo:
* java Clases
*/
// Librería necesaria para trabajar con la entrada/salida
import java.io.*;
/**
* clase Clases
* Clase que muestra la declaración de una clase
*
* @author Pello Altadill
*/
public class Clases {
// ATRIBUTOS de CLASE
String nombre;
/**
* Método constructor, se ejecuta al crear una instancia de la clase
*/
Clases ()
{
nombre = "Juan Solo";
System.out.println("Has creado una instancia de la clase");
}
/**
* saludo
* Un método de la clase que simplemente saca un mensaje
*/
void saludo ()
{
System.out.println("Hola Mundo, soy " + nombre);
}
/**
* main
* Función principal
* esta función es la que se inicia directamente al ejecutar el programa
*/
public static void main (String args[])
{
// Creamos una INSTANCIA de la clase:
// es como declarar una variable, pero el tipo es el
// nombre de la clase
Clases unaClase = new Clases();
// Con la instancia llamamos a uno de sus métodos
unaClase.saludo();
}
}
Clase Cliente:
/**
* Cliente
* Clase que muestra la declaración de una clase
*
* Para compilar:
* javac Cliente.java
*
* Para ejecutarlo:
* java Cliente
*/
// Librería necesaria para trabajar con la entrada/salida
import java.io.*;
// Libería necesaria para la clase Date
import java.util.Date;
/**
* clase Cliente
* Muestra la declaración de una clase que representa un cliente.
* Una clase se compone de atributos (propiedades) y métodos (funciones)
* La clase representa una entidad y cuando definimos una variable de
* de esa clase
*
* @author Pello Altadill
*/
public class Cliente {
// ATRIBUTOS o PROPIEDADES DE LA CLASE
public String nombre;
public String apellidos;
public Date nacimiento;
public int codigo;
// MÉTODOS DE LA CLASE: Constructores, y otras funciones
/**
* Cliente
* este es el método constructor, al que se invoca
* al crear una instancia de la clase
*/
Cliente ()
{
System.out.println("Has creado una instancia de Cliente");
}
/**
* Cliente
* Otro constructor con parámetros.
* Nos sirve para crear una instancia
*/
Cliente (String nombre, String apellidos, Date nacimiento, int codigo)
{
System.out.println("Has creado una instancia de Cliente");
this.nombre = nombre;
this.apellidos = apellidos;
this.nacimiento = nacimiento;
this.codigo = codigo;
}
/**
* nombreCompleto
* Método que une el nombre y el apellido del Cliente
* @return resultado
*/
public String nombreCompleto ()
{
String resultado = nombre + " " + apellidos;
return resultado;
}
/**
* fichaCliente
* Método que muestra todos los datos del cliente
*
*/
public void fichaCliente ()
{
System.out.println("--Ficha del Cliente--");
System.out.println("Código: " + codigo);
System.out.println("Nombre completo: " + nombreCompleto());
System.out.println("Fecha nacimiento: " + nacimiento);
}
/**
* saluda
* Un método que nos muestra un saludo
*/
public void saluda ()
{
System.out.println("Hola mundo desde la clase");
}
/**
* 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 Cliente
*/
public static void main (String args[])
{
// Creamos un par de instancias
Cliente unCliente = new Cliente();
Cliente otroCliente = new Cliente("Darth","Vader", new Date(), 666);
unCliente.codigo = 89;
otroCliente.fichaCliente();
unCliente.saluda();
}
}
JavaJutsu: matrices o arrays de varias dimensiones
¿Cómo creamos y accedemos a los elementos de un array de varias dimensiones? Muy fácil. Como en c.
/**
* Matrices
* Clase que muestra la declaración y uso de Arrays de varias dimensiones
* le he llamado Matriz por distinguir, aunque formalmente puede ser los mismo.
*
* Para compilar:
* javac Matrices.java
*
* Para ejecutarlo:
* java Matrices
*/
// Librería necesaria para trabajar con la entrada/salida
import java.io.*;
/**
* clase Matrices
* Clase que muestra la declaración y uso de Arrays de dos o más dimensiones
*
*
* @author Pello Altadill
*/
public class Matrices {
/**
* main
* Función principal
* esta función es la que se inicia directamente al ejecutar el programa
*/
public static void main (String args[])
{
// Vamos a definir un array de enteros de dos dimensiones y otro de tres
int valores[][];
int [][] dorsales;
// Podemos establecer el tamaño mediante new, y puede ser distinto para cada dimensión:
// En este caso definimos un array de DIEZ y TRES elementos
int [][] puntos = new int[10][3];
// Podemos inicializar los arreglos con valores concretos,
// lo cual sería una forma de implícita de especificar su tamaño:
int numeros[][] = %7B%7B7,15,42},{69,666,23},{5,87,1},{0,665,-1%7D%7D;
char letras [][] = %7B%7B'a','b','c','d'},{'e','f','g','h'%7D%7D;
// Podemos crear Matrices de Strings
String heroes[][] = %7B%7B"Gandalf","Trancos"}, {"Haplo","Alfred"},{"Jon Nieve", "Brienne"%7D%7D;
// Podemos alterar valores de un elemento del array
heroes[0][1] = "Aragorn";
numeros[1][2] = 24;
// Y por supuesto operar con ellos:
// al elemento 0 del array heroes le concatenamos algo:
heroes[2][0] = heroes[2][0] + " lord Comandante";
numeros[3][1]++;
// para recorrer estos arrays con un for, hay que anidar tantos for
// como dimensiones tenga el array:
// ATENCIÓN a la forma de acceder al subarray en el segundo FOR
System.out.println("Estos son los mayores heroes, por sagas: ");
for (int i = 0;i < heroes.length; i++)
{
System.out.println("Saga " + i);
for (int j = 0; j < heroes[i].length; j++)
{
System.out.println("\tEn el índice " + i + "," + j +": " + heroes[i][j]);
}
}
}
}
Mecano es una pequeña aplicación web hecha en java usando el framework Struts. Struts no es más que una librería que nos permite hacer la aplicación con el patrón MVC.
Tiene unos diez años y dudo que pueda funcionar con el struts actual pero por si alguien quiere echarle un ojo, dejo el enlace:
JavaJutsu: arrays
En java los arrays se declaran más o menos como en c. Tenemos estructuras mejores dentro de las utilidades de java.util.*, pero si queremos algo básico y no nos importa que sea rígido podemos declarar arrays así:
/**
* Arrays
* Clase que muestra la declaración y uso de arrays
*
* Para compilar:
* javac Arrays.java
*
* Para ejecutarlo:
* java Arrays
*/
// Librería necesaria para trabajar con la entrada/salida
import java.io.*;
/**
* clase Arrays
* Clase que muestra la declaración y uso de arrays. Los arrays
* o arreglos son variables que contienen un conjunto de datos del mismo tipo
* indexados numéricamente desde el 0 en adelante.
*
* NOTA: pueden crearse arrays de elementos del tipo básico: int, float,...
* y también pueden crearse de clases.
* NOTA2: los arrays en java se definen con un tamaño concreto y no puede
* alterarse. Si necesitamos elasticidad entonces debemos usar clases
* como por ejemplo Vector.
*
* @author Pello Altadill
*/
public class Arrays {
/**
* main
* Función principal
* esta función es la que se inicia directamente al ejecutar el programa
*/
public static void main (String args[])
{
// Vamos a definir un array de enteros, todavía sin especificar el tamaño.
// Lo podemos hacer de dos formas:
int valores[];
int [] dorsales;
// Podemos establecer el tamaño mediante new:
// En este caso definimos un array de DIEZ elementos,
// pero ATENCIÓN, los índices irán del 0 al 9.
int [] puntos = new int[10];
// Si quisieramos crear un array de caracteres que contenga el abecedario
// lo hariamos así. El abecedario español tiene 28 letras, en el array serán
// del 0 al 27.
char abecedario[] = new char[28];
boolean verdades[] = new boolean[5];
// Podemos inicializar los arreglos con valores concretos,
// lo cual sería una forma de implícita de especificar su tamaño:
int numeros[] = {7,15,42,69,666};
char letras [] = {'a','b','c','d','e','f','g','h'};
// Podemos crear arrays de Strings
String heroes[] = {"Gandalf", "Haplo", "Jon Nieve", "Vader", "Trancos"};
// para acceder a un elemento del array debemos indicar su índice.
// el índice es un número entero que va de 0 al tamaño-1 del array
System.out.println("The number of the beast: " + numeros[4]);
// Podemos alterar valores de un elemento del array
verdades[0] = false;
numeros[2] = 23;
// Y por supuesto operar con ellos:
// al elemento 0 del array heroes le concatenamos algo:
heroes[0] = heroes[0] + " el gris";
numeros[3] = numeros[2] + 8;
// Vale, ¿que hacemos con el array? Podemos recorrerlo con un for
// Todo array tiene una propiedad que es length, la cual no da su tamaño
// Por ejemplo, los elementos del array puntos los podemos inicializar
// con un valor concreto:
for (int i = 0;i< puntos.length; i++)
{
puntos[i] = 0;
}
System.out.println("Estos son los mayores heroes: ");
for (int i = 0;i < heroes.length; i++)
{
System.out.println("En el índice " + i + ": " + heroes[i]);
}
}
}
JavaJutsu: break y continue
Estas dos sentencias funcionan como en c. Break sirve para salir de una estructura de control como un switch case o de un bucle.
El continue sirve para que el bucle salte a la siguiente vuelta, sin salir del bucle.
Atención al ejemplo y a cómo hacer breaks cuando hay más de un bucle.
/**
* BreakContinue
* Clase que muestra el uso de sentencias Break Continue para
* alterar la ejecución de bucles While, Do-While, o For
*
* Para compilar:
* javac BreakContinue.java
*
* Para ejecutarlo:
* java BreakContinue
*/
// Librería necesaria para trabajar con la entrada/salida
import java.io.*;
/**
* clase BreakContinue
* Clase que muestra el uso de Break y Continue que nos sirven para
* modificar el normal comportamiento de los bucles.
* - Con break se rompe el bucle y se sale de él.
* - Con continue interrumpimos la ejecución actual del bucle y se salta a la siguiente vuelta
* sin salir del bucle.
*
*
* @author Pello Altadill
*/
public class BreakContinue {
/**
* main
* Función principal
* esta función es la que se inicia directamente al ejecutar el programa
*/
public static void main (String args[])
{
// Declaramos una serie de variables
int numero, anterior;
int x,y;
x = 10;
while (x > 0)
{
if (x == 5)
{
break; // salimos del bucle
}
x--;
}
// Vamos a buscar los números primos
// que hay del 2 al 20
for (numero = 2; numero < 20; numero++)
{
anterior = numero;
do
{
anterior--;
// En cuanto es divisible, salimos
if (numero % anterior == 0)
{
break;
}
} while(anterior > 2);
// Si se ha llegado hasta el final, es primo
if (anterior == 2)
{
System.out.println(numero + " es un PRIMO");
}
}
// Si tenemos dos bucles anidados,
// ¿cómo podemos salir de un bucle concreto con break?
// hay que usar una etiqueta, que es un identificador seguido de
// dos puntos:
salida:
for(x=1;x<20;x++)
{
System.out.println("Bucle principal: " + x);
if (20 % x == 7)
{ // salimos del bucle principal
break;
}
// para salir desde el bucle interno hasta fuera
// tendremos que usar la etiqueta salida
for(y=10;y>0;y--)
{
System.out.println("Bucle interno: " + y);
if (20 % y == 4)
{ // Salimos de este y del bucle principal también
// pero hay que especificar la etiqueta de salida
break salida;
}
}// for2
}// for1
}
}
JavaJutsu: el bucle for
Se declara igualito que el bucle for de c. Los bucle for se utilizan cuando necesitamos que un número concreto de iteraciones (ej: recorrer un array), ni más ni menos, aunque siempre se puede romper el bucle. A bajo nivel se supone que los bucle for son más rápidos que los while.
/**
* For
* Clase que muestra el uso de un bucle for
*
* Para compilar:
* javac For.java
*
* Para ejecutarlo:
* java For
*/
// Librería necesaria para trabajar con la entrada/salida
import java.io.*;
/**
* clase For
* Muestra el uso de un bucle for. Los bucles for sirven para
* ejecutar unas sentencias un número determinado de veces.
* Los bucles while se usan cuando la condición de salida es más incierta,
* o dependemos del valor de alguna variable.
*
* Formato:
* for (inicio;condición;actualización)
* {
* sentencias;
* }
* @author Pello Altadill
*/
public class For {
/**
* main
* Función principal
* esta función es la que se inicia directamente al ejecutar el programa
*/
public static void main (String args[])
{
// Vamos a dar 10 vueltas.
// En los bucles for solemos usar un número como índice
// del bucle.
int i,j,k;
i = j = k = 0;
// Vamos a dar 10 vueltas: dentro del for
// - Primero iniciamos: i=0;
// - Luego ponemos la condición de salida: i>0
// - Luego ponemos la actualiación
for (i=0; i<10; i++)
{
System.out.println("Dentro del bucle 1 : " + i);
}
// podemos inicializar la variable dentro del for
// pero ojo, el ámbito de z solo será el bucle for.
for (int z = 10; z>0; z--)
{
System.out.println("Dentro del bucle 2 : " + z);
}
// Podemos usar más de una variable usando la ,
for (j=0, k=20; j<10 && k>0; j++, k=k-2)
{
System.out.println("Dentro del bucle 3 : " + j + " , " + k);
}
// El bucle infinito:
// for (;;)
}
}
JavaJutsu: el bucle do while
Esto es lo mismo que en c. El bucle do while es una iteración que al menos se ejecuta una vez.
/**
* DoWhile
* Clase que muestra los bucles while
*
* Para compilar:
* javac DoWhile.java
*
* Para ejecutarlo:
* java DoWhile
*/
// Librería necesaria para trabajar con la entrada/salida
import java.io.*;
/**
* clase DoWhile
* Muestra el uso de bucles do while. Este tipo de bucles
* es como el while, repiten unas sentencias mientras una condición sea verdadera
* pero en su caso la primera iteración sucede siempre ya que la condición se comprueba
* al final.
* Formato:
* do
* {
* sentencias;
* } while();
*
* @author Pello Altadill
*/
public class DoWhile {
/**
* main
* Función principal
* esta función es la que se inicia directamente al ejecutar el programa
*/
public static void main (String args[])
{
// Vamos a comprobar si un número es primo
// para eso hay que verificar que solo es divisible
// por si misma o por 1.
int numero, anterior;
// Les asignamos a las dos
numero = anterior = 7;
// para guardar el resultado
boolean esPrimo = true;
// Ejecutamos el do-while
do
{
anterior--;
if (numero % anterior == 0)
{
esPrimo = false;
}
} while(anterior > 2 && esPrimo);
// Mostramos el resultado
if (esPrimo)
{
System.out.println("Este numero: " + numero + " es primo");
}
else
{
System.out.println("Este numero: " + numero + " NO es primo");
}
}
}
JavaJutsu: el bucle while
Los bucles se hacen igual que en c. Vamos a ver un ejemplo con el bucle while:
/**
* While
* Clase que muestra los bucles while
*
* Para compilar:
* javac While.java
*
* Para ejecutarlo:
* java While
*/
// Librería necesaria para trabajar con la entrada/salida
import java.io.*;
/**
* clase While
* Muestra el uso de bucles while. Este tipo de bucles
* repiten unas sentencias mientras una condición sea verdadera.
* El final no será previsible.
* Formato:
* while (true)
* {
* sentencias;
* }
*
* @author Pello Altadill
*/
public class While {
/**
* main
* Función principal
* esta función es la que se inicia directamente al ejecutar el programa
*/
public static void main (String args[])
{
// Vamos a usar un contador
int contador = 10;
// Ejecutamos el bucle mientras contador sea mayor que 0
while (contador > 0)
{
System.out.println("Dentro del bucle " + contador);
// y vamos decrementando
contador--;
}
// Vamos a hacer otra prueba
contador = 10;
System.out.println("El siguiente bucle:");
// Atención: podemos actualizar la variable en la propia condición
while (contador-- > 0)
{
System.out.println("Dentro del bucle " + contador);
}
// el bucle infinito: simplemente poniendo en la condición true
//while (true)
// {
// sentencias;
// }
}
}
D6 dices in svg
Scalar vector graphics dice set, quick and dirty.
Dados en formato vectorial.
Download (svg file, dices one by one)
JavaJutsu: el switch case
Cuando necesitamos comprobar una condición sobre el valor de una variable en lugar de usar un montón de if-else debemos usar un switch case. En el caso de Java es como c pero a partir de la versión 7 podemos usar Strings!!
/**
* SwitchCase
* Clase que muestra el uso de un switch case
*
* Para compilar:
* javac SwitchCase.java
*
* Para ejecutarlo:
* java SwitchCase
*/
// Librería necesaria para trabajar con la entrada/salida
import java.io.*;
/**
* clase SwitchCase
* Clase que muestra el uso de un switch case
* Estas estructuras son como un if-else-if pero se aplican comprobando
* si una variable tiene determinado valor
*
* switch (variable)
* {
* case valor1 : sentencias; break;
* case valor2 : sentencias: break;
* ...
* default: sentencias;
* }
*
* NOTA: no olvides el break para cada caso.
* NOTA2: el switchcase en java funciona para tipos simples (int, char) y desde la versión 7 para todos
* incluidos Strings
*
* NOTA3: no se permiten los intervalos como en VB.
*
* @author Pello Altadill
*/
public class SwitchCase {
/**
* main
* Función principal
* esta función es la que se inicia directamente al ejecutar el programa
*/
public static void main (String args[])
{
int numero = 0;
int dorsal = 10;
// Según el valor de edad sacaremos un mensaje u otro
// NO hay que olvidar el break para cada CASO!!!!!!
switch (numero)
{
case 0:
System.out.println("Eres un 0");
break;
case 15:
System.out.println("Eres la niña bonita");
break;
case 42:
System.out.println("Eres la respuesta a todo");
break;
case 69:
System.out.println("Eres el puerto tftp, malpensao.");
break;
default:
System.out.println("Eres un número sin personalidad: " + numero);
break;
}
// Podemos agrupar más opciones como una especia de OR:
switch (dorsal)
{
case 3:
case 4:
case 5:
System.out.println("Dorsal de un defensa" + dorsal);
break;
case 10:
System.out.println("El dorsal del capitán: " + dorsal);
break;
case 9:
System.out.println("El dorsal de un ariete: " + dorsal);
break;
default:
System.out.println("Eres un número sin personalidad: " + dorsal);
break;
}
}
}
subscribe via RSS