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;
System.out.println("El resultado es : " + z);
} else {
System.out.println("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 = '/';
System.out.print("El resultado es : ");
switch ( op ) {
case '+':
System.out.println( a + b );
break;
case '-':
System.out.println( a - b );
break;
case '*':
System.out.println( a * b );
break;
case '/':
System.out.println( a / b );
break;
default:
System.out.println("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;
 }
System.out.println("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;
System.out.println("El resultado es: " + j );
}
}

Estructuras de iteración

While

public class Cuadrado{

public static void main(String args[]){
int contador = 1;
while ( contador <= 5 ) {
System.out.println("*****");
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 );
System.out.println(dígitos);
}
}

For

int[] laiEnteros = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};

for (int i = 0; i < 10; i ++)
System.out.println (laiEnteros[i]);
For Mejorado

int[] laiEnteros = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};

for (int liElemento : laiEnteros)
System.out.println (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) System.out.println("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;

System.out.println(nombre+" "+apellido1+" "+apellido2);

return 0;
}