Conceptos Generales de Java
Tipo de variable
Cada variable debe tener un tipo de dato predefinido. Esto determina el rango de
valores que puede almacenar y que operaciones se pueden realizar. Por ejemplo una variable
de tipo entero puede almacenar números sin decimales y puede realizarse operaciones
aritméticas, pero no puede contener palabras.
Tipos de datos primitivos
Tipo Tamaño y formato Rango
enteros
byte 8 bits - complemento a 2
short 16 bits - complemento a 2 -
int 32 bits - complemento a 2
long 64 bits - complemento a 2
números reales
float 32 bits - IEEE 754
double 64 bits - IEEE 754
otros
char 16 bits - caracteres UNICODE '\u0000' al '\uffff'
boolean 1 bit true o false
En otros lenguajes de programación, el formato o el tamaño de los tipos primitivos dependen
del microprocesador o del sistema operativo que se están ejecutando.
Operadores
Un operador realiza una función, toma uno o más argumentos y devuelve un resultado.
Operadores aritméticos
Realizan las operaciones aritméticas básicas: suma (+), resta (-), multiplicación (*) ,división (/) y
módulo(%) para datos de tipo numérico, tanto enteros como reales. Estas son operaciones
binarias porque admiten dos operandos.
Operadores aritméticos unarios
Dentro de los operadores aritméticos tenemos los unarios + y – que simplemente operan con
el signo de un valor dado
También tenemos los auto incremental ++ y el auto decremental --. Ambos operadores pueden
ser sufijos, es decir se coloca antes del operando o posfijo que se sitúa detrás
Operadores relacionales
Operadores relacionales
Operador Utilización Resultado
> A>B verdadero si A es mayor que B
>= A >= B verdadero si A es mayor o igual que B
< A<B verdadero si A es menor que B
<= A <= B verdadero si A es menor o igual que B
== A == B verdadero si A es igual a B
!= A != B verdadero si A es distinto de B
Operadores booleanos
Operadores booleanos
Nombre Operador Utilización Resultado
verdadero cuando A y B son verdaderos. Evaluación
AND && A && B
condicional.
verdadero cuando A o B son verdaderos. Evaluación
OR || A || B
condicional.
NOT ! !A verdadero si A es falso.
verdadero cuando A y B son verdaderos. Siempre
AND & A&B
evalúa ambos operandos.
OR | A|B verdadero cuando A o B son verdaderos. Siempre
evalúa ambos operandos.
XOR ^ A^B verdadero cuando A y B son diferentes
Operadores de asignación (=)
Cambia el valor de la variable que está a la izquierda por un literal o el resultado de la
expresión que se encuentra a la derecha.
Operadores de asignación
Operación Operador Utilización Operación equivalnte
Suma += A += B A=A+B
Resta -= A -= B A=A-B
Multiplicación *= A *= B A=A*B
División /= A /= B A=A/B
Resto de división %= A %= B A=A%B
Operador cast
Cada vez que realizamos una operación obtenemos un resultado. Este resultado podrá tener
un tipo de dato diferente de los operandos
public class CambioTipo {
public static void main(String args[]){
byte unByte = 2;
byte otroByte = 3;
byte result = unByte + otroByte;
}
}
Precedencia de operadores
Primeramente proceden los unarios, luego los aritméticos, posteriormente los
relacionales, detrás vienen los booleanos y por último el operador de asignación. La
regla de precedencia establece que los operadores de mayor nivel se ejecuten
primero.
Precedencia de operadores
Descripción Operadores
operadores posfijos op++ op--
operadores unarios ++op --op +op -op ~ !
multiplicación y división */%
suma y resta +-
operadores relacionales < > <= =>
equivalencia == !=
operador AND &
operador XOR ^
operador OR |
AND booleano &&
OR booleano ||
condicional ?:
operadores de asignación = += -= *= /= %= &= ^= |=
En la tabla se muestra el nivel de precedencia de los operadores. Los de mayor nivel se
encuentran arriba
Utilización de paréntesis
Se utilizan para aislar una porción de la expresión de forma que el cálculo se ejecute de
forma independiente. Puede forzar a una expresión a ignorar las reglas de
precedencia.
int j = 1 + 3 * 4; // resultado j = 13
int h = (1 + 3) * 4 // resultado j = 16
Tomando el primer ejemplo, forzamos al compilador a realizar la suma antes que la
multiplicación.
En este ejemplo es imprescindible la utilización de paréntesis:
int k = 1 + (h = 3);
Estructuras de control
Estructuras de selección
public class DivisionSegura {
public static void main(String args[]){
int x = 12;
int y = 2;
int z = 0;
if( y !=0 ) {
z = x / y;
[Link]("El resultado es : " + z);
} else {
[Link]("Atención! se pretende dividir por 0");
}
}
}
Sentencia switch
public class MiniCalculadora{
public static void main(String args[]){
int a = 1;
int b = 1;
char op = '/';
[Link]("El resultado es : ");
switch ( op ) {
case '+':
[Link]( a + b );
break;
case '-':
[Link]( a - b );
break;
case '*':
[Link]( a * b );
break;
case '/':
[Link]( a / b );
break;
default:
[Link]("error" );
break;
}
}
}
Operador if-else
variable = op1?op2:op3
public class Distancia{
public static void main(String args[]){
int a = 23;
int b = 12;
int j;
if ( a > b ) {
j = a - b;
} else {
j = b - a;
}
[Link]("El resultado es: " + j );
}
public class Distancia2{
public static void main(String args[]){
int a = 23;
int b = 12;
int j = a > b ? a - b : b - a;
[Link]("El resultado es: " + j );
}
}
Estructuras de iteración
While
public class Cuadrado{
public static void main(String args[]){
int contador = 1;
while ( contador <= 5 ) {
[Link]("*****");
contador++;
}
}
}
Do While
public class CuentaDigitos{
public static void main(String args[]){
int número = 4557888;
int dígitos = 0;
do {
número /=10;
dígitos++;
}
while ( número > 0 );
[Link](dígitos);
}
}
For
int[] laiEnteros = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
for (int i = 0; i < 10; i ++)
[Link] (laiEnteros[i]);
For Mejorado
int[] laiEnteros = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
for (int liElemento : laiEnteros)
[Link] (liElemento);
Sentencia break
public class CuentaDigitos{
public static void main(String args[]){
int número = 4557888;
int dígitos = 0;
while ( número > 0 ) {
número /=10;
dígitos++;
if (dígitos ==5) break;
}
if (dígitos ==5) [Link]("El numero tiene 5 o más
dígitos");;
}
}
Sentencia continue
for(int j = 0; j<10; j++){
sentencia 1;
sentencia 2;
sentencia 3;
continue;
sentencia 4;
};
Funciones
int imprimeTodo(String nombre, String apellido1, String apellido2){
if (nombre ==null || nombre =="") return 1;
if (apellido1==null || apellido1=="") return 2;
if (apellido2==null || apellido2=="") return 3;
[Link](nombre+" "+apellido1+" "+apellido2);
return 0;
}