pello.ioPosts
Javajutsu: condicional if-else
En java no existe una operación elseif o elsif, así que hay que hacer un else y luego un if como en c.
Ejemplo de if-else
/**
* IfElse
* Clase que muestra un bloque condicional if-else
*
* Para compilar:
* javac IfElse.java
*
* Para ejecutarlo:
* java IfElse
*/
// Librería necesaria para trabajar con la entrada/salida
import java.io.*;
/**
* clase IfElse
* Muestra el uso de un bloque condicional if-else: si se cumple la
* condición del if se ejecuta su bloque, en caso contrario se ejecuta
* el bloque del else.
* if (condición)
* {
* sentecias_bloque_if;
* }
* else
* {
* sentecias_bloque_else;
* }
*
* @author Pello Altadill
*/
public class IfElse {
/**
* 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 variable.
int a = 666;
int b = 0;
if (a >= b)
{
System.out.println("A es mayor o igual que B");
}
else
{
System.out.println("A es menor que B");
}
}
}
Ejemplo de if-else-if
/**
* IfElse
* Clase que muestra un bloque condicional if-else
*
* Para compilar:
* javac IfElse.java
*
* Para ejecutarlo:
* java IfElse
*/
// Librería necesaria para trabajar con la entrada/salida
import java.io.*;
/**
* clase IfElse
* Muestra el uso de un bloque condicional if-else: si se cumple la
* condición del if se ejecuta su bloque, en caso contrario se ejecuta
* el bloque del else.
* if (condición)
* {
* sentecias_bloque_if;
* }
* else
* {
* sentecias_bloque_else;
* }
*
* @author Pello Altadill
*/
public class IfElse {
/**
* 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 variable.
int a = 666;
int b = 0;
if (a >= b)
{
System.out.println("A es mayor o igual que B");
}
else
{
System.out.println("A es menor que B");
}
}
}
Javajutsu: estructura condicinal if
El if se hace como en c, aunque no todo es igual. Ver código comentado.
/**
* If
* Clase que muestra el uso de un bloque condicional if
*
* Para compilar:
* javac If.java
*
* Para ejecutarlo:
* java If
*/
// Librería necesaria para trabajar con la entrada/salida
import java.io.*;
/**
* clase If
* Muestra el uso de un bloque condicional if, cuyo interior solo
* se ejecuta si la condición del if es verdadera
* if (condición)
* {
* sentecias_bloque_if;
* }
*
* @author Pello Altadill
*/
public class If {
/**
* 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 variable.
int x = 666;
int y = 0;
if (x == 666)
{
System.out.println("x lleva la marca de la bestia");
}
// La condicón del If puede ser cualquier expresión compleja siempre que devuelva un
// valor booleano
if (x > 0 && y < 0)
{
System.out.println("x es positivo e y negativo");
}
// Atención: JAVA NO considera los enteros como booleanos!!
// Tradicionalmente en c y otros lenguajes similares cualquier valor que sea distinto de 0 se considera como un true booleano
// mientras que el 0 se considera como false.
/*
if (x) // En JAVA NO HACER ESTO
{
System.out.println("x es distinto de 0");
}
if (y) // En JAVA NO HACER ESTO
{
System.out.println("y es distinto de 0");
}
// por tanto !y es como preguntar si y es igual a 0
// esta forma de escribir es muy kewl pero se considera poco clara
if (!y) // En JAVA NO HACER ESTO
{
System.out.println("y es 0!!");
}*/
}
}
JavaJutsu: operadores de bits
¿Te interesan los operadores a nivel de bits en Java? Algo malo debes estar haciendo ;)
Los operadores haberlos haylos, otra cosa es que se usen con frecuencia.
/**
* OperadoresBits
* Clase que muestra el uso de operadores de bits
*
* Para compilar:
* javac OperadoresBits.java
*
* Para ejecutarlo:
* java OperadoresBits
*/
/**
* clase OperadoresBits
* Muestra el uso de operadores de bits. Su uso no es que sea muy frecuente
* pero suele estar presente en todos los lenguajes tipo c.
*
* & : AND Conjunción de bits: 1011 & 1001 = 1001
* | : OR disjunción de bits: 1011 | 1001 = 1011
* ^ : XOR disjunción excluyente de bits: 1011 ^ 1001 = 0010
* <<: desplazamiento de bits a la izquierda
* >>: desplazamiento de bits a la derecha
*
*
*
* @author Pello Altadill
*/
public class OperadoresBits {
/**
* main
* Función principal
* esta función es la que se inicia directamente al ejecutar el programa
*/
public static void main (String args[])
{
int numero1, numero2;
numero1 = 0x0010;
numero2 = 0x1101;
System.out.println("Resultado: \n" + (numero1 & numero2));
System.out.println("Resultado: \n" + (numero1 | numero2));
// se puede abreviar:
// numero1 = numero1 & numero2;
numero1 &= numero2;
// Para operaciones en las que el resultado vaya a una de los propios
// operandos (numero1 = numero1 & 0x1111) podemos usar una operadores de asignación especial:
// &=, |=, ^=, >>=, >>>=, <<=
}
}
JavaJutsu: operadores booleanos
Los operadores booleanos son los esenciales de siempore: and, or y not, en su forma habitual: && , || , !
/**
* OperadoresBooleanos
* Clase que muestra el uso de operadores booleanos
*
* Para compilar:
* javac OperadoresBooleanos.java
*
* Para ejecutarlo:
* java OperadoresBooleanos
*/
// Librería necesaria para trabajar con la entrada/salida
import java.io.*;
/**
* clase OperadoresBooleanos
* Muestra el uso de los operadores booleanos: se trata de operaciones
* que operan sobre sentencias y cuyo resultado es un booleano, true o false.
* Las operaciones son:
* && : operación AND, a && b: el resultado es verdadero si a y b son verdaderos
* || : operación OR, a || b: el resultado es verdadero si cualquiera de los dos es verdadero
* ! : operación NOT, !a : invierte el valor booleano de a. Si a es true !a devuelve false.
*
* @author Pello Altadill
*/
public class OperadoresBooleanos {
/**
* main
* Función principal
* esta función es la que se inicia directamente al ejecutar el programa
*/
public static void main (String args[])
{
// probaremos con algunos enteros
int bajo, alto, mediano;
bajo = 4;
alto = 666;
mediano = 42;
// Solo pueden ser true o false
boolean a = false;
boolean b = true;
boolean c = true;
boolean resultado = false;
resultado = a || b;
System.out.println("Si alguno entre A o B es true el resultado es: " + resultado);
resultado = b && c;
System.out.println("B y C son true por tanto el resultado es: " + resultado);
resultado = !(b && c);
System.out.println("B y C son true, pero si le hacemos un NOT: " + resultado);
// Vamos a combinarlo con operadores de comparación
resultado = (bajo < mediano) && (mediano < alto);
System.out.println("El resultado es: " + resultado);
resultado = (bajo == mediano) || (mediano <= alto);
System.out.println("El resultado es: " + resultado);
}
}
Javajutsu, operadores de comparación
¿Operadores de comparación? Los mismos que en c.
/**
* OperadoresComparacion
* Clase que muestra el uso de operadores de comparación
*
* Para compilar:
* javac OperadoresComparacion.java
*
* Para ejecutarlo:
* java OperadoresComparacion
*/
// Librería necesaria para trabajar con la entrada/salida
import java.io.*;
/**
* clase OperadoresComparacion
* Muestra el uso de los operadores de comparación que sirven para comparar
* entre si dos valores. Es importantes saber que:
* - Los dos valores comparadods deben ser del mismo tipo
* - El resultado es booleano, es decir verdadero o falso
*
* Los operadores de comparación son los siguientes:
* > mayor que, por ejemplo a mayor que b: a > b
* < menor que
* == igual que
* >= mayor o igual que
* <= menor o igual que
* != distinto de
*
* Normalmente se utilizan como expresiones para establecer una condición
* en estructuras condicionales, bubles, etc... y unidos mediante operadores
* booleanos pueden construirse expresiones más complejas
*
* @author Pello Altadill
*/
public class OperadoresComparacion {
/**
* main
* Función principal
* esta función es la que se inicia directamente al ejecutar el programa
*/
public static void main (String args[])
{
// Solo pueden ser true o false
boolean resultado;
int enano, grande;
char letra = 'a';
char otraLetra = 'k';
char mayuscula = 'A';
String autobot = "Optimus";
String decepticon = "Megatron";
String agente = "007";
enano = grande = 0;
resultado = (enano == grande);
System.out.println("Son iguales enano y grande? " + resultado);
grande = 42;
// Podemos comparar y mostrar directamente.
// la comparación la ponemos entre paréntesis por claridad
System.out.println("Son iguales enano y grande? " + (enano == grande));
System.out.println("Es enano mayor que grande? " + (enano > grande));
System.out.println("Es enano menor que grande? " + (enano < grande));
System.out.println("Es enano distinto de grande? " + (enano != grande));
// Podemos comparar letras e incluso cadenas
resultado = (letra > otraLetra);
System.out.println("Es 'a' mayor que 'k' " + resultado);
resultado = (letra == mayuscula);
System.out.println("Es 'a' igual que 'A' " + resultado);
// Con las cadenas podemos usar == y !=
System.out.println("Optimos es igual que Megatron? " + (autobot == decepticon));
System.out.println("Optimos es distinto de Megatron? " + (autobot != decepticon));
// Esto no podriamos
//System.out.println("Y si una palabra empieza por un número? " + (agente > autobot));
}
}
JavaJutsu: operadores aritméticos
Los operadores aritméticos de java son iguales que en cualquier otro lenguaje tipo c.
/**
* OperadoresAritmeticos
* Clase que muestra el uso de operadores aritméticos: suma, resta...
*
* Para compilar:
* javac OperadoresAritmeticos.java
*
* Para ejecutarlo:
* java OperadoresAritmeticos
*/
// Librería necesaria para trabajar con la entrada/salida
import java.io.*;
/**
* clase OperadoresAritmeticos
* Muestra la declaración de operadores arítmeticos:
* +, -, *, / : suma, resta, multiplicación, división
* % : resto de la división: 7 % 3 = 1
* ++, -- : incremento y decremento en 1
* - : cambio de signo
*
* Por último tenemos un operador condicional o terciario: ?:
* que equivale a una estructura if-else. Mostramos un
* ejemplo simple
*
* @author Pello Altadill
*/
public class OperadoresAritmeticos {
/**
* main
* Función principal
* esta función es la que se inicia directamente al ejecutar el programa
*/
public static void main (String args[])
{
int a,b,c;
float x,y,z;
a = b = c = 0;
x = y = z = 0;
// Mostramos los valores antes y después
System.out.println("a:" + a + ", b:" + b + ", c:" + c);
System.out.println("x:" + x + ", y:" + y + ", z:" + z);
a = b + 45;
c = a * 666;
x++;
y = --z;
System.out.println("a:" + a + ", b:" + b + ", c:" + c);
System.out.println("x:" + x + ", y:" + y + ", z:" + z);
// Para operaciones en las que el resultado vaya a una de los propios
// operandos (x = x + 4) podemos usar una operadores de asignación especial:
// += , -=, *=, /=, %=
a += 666;
c %= 2;
// Atención a la diferencia entre ++c y c++:
// a = ++c primero se incrementa c, luego se asigna a a
// b = c++ primero se asigna a b, luego se incrementa c
a = b = c = 0;
c = 2;
a = ++c;
b = c++;
System.out.println("a:" + a + ", b:" + b + ", c:" + c);
// Podemos hacer las operaciones más complejas.
// para asegurar y aclarar el orden de operaciones podemos
// meter paréntesis.
x = (y *34) + 42 - (1000 % z);
// El operador condicional ?: permite asignar dos valores alternativos
// según una condición:
// (condición)?valor_si_condición_es_verdadera:valor_en_caso_contrario
// Si y es mayor que 0 a x se le asigna y, en caso contrario a x se le asigna 5
z = (y > 0)?y:5;
System.out.println("x:" + x + ", y:" + y + ", z:" + z);
}
}
La entrada por consola se ha simplificado bastante con el objeto Console.
Ya no hace falta un StreamReader ni nada de eso.
/**
* EntradaPorConsola
* Clase que como solicitar datos al usuario y guardarlos
* en variables.
*
* Para compilar:
* javac EntradaPorConsola.java
*
* Para ejecutarlo:
* java EntradaPorConsola
*/
// Librería necesaria para trabajar con la entrada/salida
import java.io.*;
/**
* clase EntradaPorConsola
* Muestra como se solicitan datos al usuario por consola y guardarlos
* en todo tipo de variables.
* En el caso
* de los enteros HAY QUE CONVERTIR lo que viene por el argumento
* porque viene como un String!
*
* @author Pello Altadill
*/
public class EntradaPorConsola {
/**
* main
* Función principal
* esta función es la que se inicia directamente al ejecutar el programa
*/
public static void main (String args[])
{
// Para leero por consola hay que crear
// una instancia de Console
Console consola = System.console();
// Declaración de variables: tipo nombre;
int edad;
float temperatura;
String lectura;
boolean booleano;
// Para solicitar datos al usuario, usamos el método
// readLine();
// Primero avisamos al usuario:
System.out.println("Por favor, introduce un texto cualquiera: ");
// Así no hay problemas porque son del MISMO TIPO
lectura = consola.readLine();
// Y mostramos por pantalla lo que el usuario ha metido
System.out.println("Has escrito: " + lectura + "\n");
// Primero avisamos al usuario:
System.out.println("Por favor, introduce un número con decimales: ");
lectura = consola.readLine();
// Atención a la CONVERSIÓN. Utilizamos la clase Float,
// y sú metodo para convertir de String al tipo simple float
temperatura = Float.parseFloat(lectura);
// Y mostramos por pantalla lo que el usuario ha metido
System.out.println("Has escrito: " + temperatura + "\n");
// Primero avisamos al usuario:
System.out.println("Por favor, introduce tu edad: ");
lectura = consola.readLine();
// Atención a la CONVERSIÓN. Utilizamos la clase Integer,
// y sú metodo para convertir de String al tipo simple int
edad = Integer.parseInt(lectura);
// Y mostramos por pantalla lo que el usuario ha metido
System.out.println("Has escrito: " + edad);
// Vamos a solicitar un booleano
System.out.println("Por favor, introduce un valor booleano: ");
lectura = consola.readLine();
// Atención a la CONVERSIÓN. Utilizamos la clase Boolean,
// y sú metodo para convertir de String al tipo simple boolean
booleano = Boolean.parseBoolean(lectura);
// Y mostramos por pantalla lo que el usuario ha metido
System.out.println("Has escrito: " + booleano);
}
}
Argumentos de programa principal o main
A los programas de java también se les pueden pasar argumento a la hora de ejecutarlos. Para eso se utiliza el array de Strings args[].
Argumentos tipo Cadena
/**
* ValoresCadenasArgumentos
* Clase que muestra la declaración de variables de cadenas o Strings
* y cómo pasarles lo que viene como argumento
*
* Para compilar:
* javac ValoresCadenasArgumentos.java
*
* Para ejecutarlo:
* java ValoresCadenasArgumentos
*/
/**
* clase ValoresCadenasArgumentos
* Clase que muestra la declaración de variables de cadenas o Strings
* y cómo pasarles lo que viene como argumento. Los argumentos se trasvasan
* a través del parámetro args[] de la función main. Ese parámetro es un conjunto
* de Strings o Cadenas
*
*
* @author Pello Altadill
*/
public class ValoresCadenasArgumentos {
/**
* main
* Función principal
* esta función es la que se inicia directamente al ejecutar el programa
*/
public static void main (String args[])
{
// En el caso de que el argumento sea una frase al ejecutar el programa la pasariamos así:
// C:\jdk>java ValoresCadenasArgumentos "Dios le ayuda"
String frase = "A quien madruga, " + args[0];
System.out.println("El primer argumento es: " + args[0]);
System.out.println("La frase final: \n" + frase);
}
}
Argumentos para guardar en variable de tipo entero
Atención , en este caso tenemos que hacer una conversión.
/**
* ValoresEnteros
* Clase que muestra la declaración de variables numéricas enteras
* y cómo pasarles lo que viene como argumento
*
* Para compilar:
* javac ValoresEnteros.java
*
* Para ejecutarlo:
* java ValoresEnteros
*/
/**
* clase ValoresEnteros
* Muestra la declaración de tipos numéricos enteros básicos:
* y cómo pasarles lo que viene como argumento. En el caso
* de los enteros HAY QUE CONVERTIR lo que viene por el argumento
* porque viene como un String!
*
* @author Pello Altadill
*/
public class ValoresEnterosArgumentos {
/**
* main
* Función principal
* esta función es la que se inicia directamente al ejecutar el programa
*/
public static void main (String args[])
{
// Declaración de variables: tipo nombre;
int dias;
short contador;
String diasString;
// Así no hay problemas porque son del MISMO TIPO
diasString = args[0];
// Atención a la CONVERSIÓN. Utilizamos la clase Integer,
// y sú metodo para convertir de String a int
dias = Integer.parseInt(args[0]);
// Con los short y con cualquier otro tipo básico hariamos
// lo mismo, usar su clase correspondiente y la misma función:
contador = Short.parseShort(args[0]);
// ATENCIÓN: si lo que pasamos como argumento NO ES un entero
// el programa casca irremediablemente y vomita una excepción
// Vamos a probar a mostrarlos por pantalla: concatenamos con +
System.out.println("El total de días es: " + dias);
System.out.println("El contador queda así: " + contador);
}
}
Variables de cadenas o Strings
/**
* ValoresCadenas
* Clase que muestra la declaración de variables de cadenas o Strings
*
* Para compilar:
* javac ValoresCadenas.java
*
* Para ejecutarlo:
* java ValoresCadenas
*/
// Librería necesaria para trabajar con la entrada/salida
import java.io.*;
/**
* clase ValoresCadenas
* Muestra la declaración de Cadenas: son variables que
* contienen más de un caracter: una palabra una frase, etc...
* Para esto no existen tipos primitivos y se usa una clase
* llamada String
*
* Una clase, como ya se verá más adelante es mucho más que un tipo
* de dato. Es una tipo complejo que tiene propiedas y métodos.
*
* @author Pello Altadill
*/
public class ValoresCadenas {
/**
* main
* Función principal
* esta función es la que se inicia directamente al ejecutar el programa
*/
public static void main (String args[])
{
String nombre;
String frase = "A quien madruga, patada en los cojones";
String presidente;
// Podemos iniciarla con una cadena vacía
String otraFrase = "Solo quiero que seamos \"amigos\"";
int edad = 666;
presidente = "Cthulhu";
nombre = "Optimus Prime";
// Los especiales comienzan por \
char nuevaLinea = '\n';
char tabulacion = '\t';
// Podemos unir dos cadenas con el operador de concatenación.
frase = frase + nuevaLinea;
// Vamos a probar a mostrarlos por pantalla:
System.out.println(frase);
// Al concatenar números se convierten en cadenas
frase = presidente + " tiene : " + edad + " años";
System.out.println("La frase queda así: \n" + frase);
System.out.println("Y la otra frase: \n" + otraFrase);
}
}
Java: Variables Booleanas
Las variables booleanas solo pueden tener dos valores: true o false (verdadero o falso). Los valores booleanos son imprescindibles en la programación para la toma de decisiones en estructuras de control, bucles, etc...
/**
* ValoresBooleanos
* Clase que muestra la declaración de variables booleanas
*
* Para compilar:
* javac ValoresBooleanos.java
*
* Para ejecutarlo:
* java ValoresBooleanos
*/
/**
* clase ValoresBooleanos
* Muestra la declaración de booleanos: son variables que solo
* pueden tener dos posibles valores: true (verdadero) o false (falso)
*
* @author Pello Altadill
*/
public class ValoresBooleanos {
/**
* main
* Función principal
* esta función es la que se inicia directamente al ejecutar el programa
*/
public static void main (String args[])
{
// Solo pueden ser true o false
boolean terminado = false;
boolean aprobar = true;
boolean resultado = aprobar;
// Vamos a probar a mostrarlos por pantalla: concatenamos con +
System.out.println("Este programa ha terminado? " + terminado);
System.out.println("Aprobaré la asignatura? " + aprobar);
System.exit(0);
}
}
subscribe via RSS