Universidad Tecnológica de El Salvador

Programación III MSc. René Alberto Castro Velásquez

UNIDAD I – INTRODUCCIÓN A JAVA UTILIZANDO EL IDE NETBEANS.

1.3. OPERADORES.
INTRODUCCIÓN.
Los operadores son símbolos que identifican una operación a ser efectuada. Java
provee un amplio conjunto de operadores para manipular variables.
La tabla siguiente muestra los operadores en Java, listados según la precedencia en la cual son
evaluados.
Operador Sintaxis
Agrupamiento ()

Pre y post incremento/decremento ++, --

Unarios +, -, !, (cast)

Multiplicación, división, módulo *, /, %

Adición, sustracción, concatenación +, -, +

Operadores de rotación <<, >>, >>>

Comparación <, <=, >, >=, instanceof

Igualdad/desigualdad ==, !=

Bit a bit: AND, OR, XOR &, |, ^

Cortocircuito: AND, OR &&, ||

Ternario ?:

Asignación =

Asignación con operación *=, /=, %=, +=, -=, <<=, >>=, >>>=, &=, ^=, |=

OPERADORES INCREMENTALES.
El operador incremental ++ agrega uno al número donde se encuentra asociado, mientras que el
operador decremental -- resta uno. Los dos operadores son aplicados ya sea como prefijos o
sufijos de cualquier variable que representen números.
El usar estos operadores como prefijos es referido como preincremento y predecremento,
causando que el incremento o decremento suceda inmediatamente y el nuevo valor sea usado en
la sentencia.
z = ++x;
El usar estos operadores como sufijos es referido como postincremento y postdecremento, y causa
que el incremento o decremento suceda después que la variable es usada en la sentencia.
y = x++;

Página 1 de 7
Universidad Tecnológica de El Salvador
Programación III MSc. René Alberto Castro Velásquez

OPERADORES ARITMÉTICOS.
Son usados en expresiones matemáticas de la misma forma como son usados
en álgebra.
Por ejemplo:
public class DemoAritmeticos {
public static void main(String [] args) {
System.out.println(5 + 4 * 6 / 3 - 2); // ¿Cuál es el resultado?
System.out.println((5 + 4) * 6 / (3 - 2)); // ¿Cuál es el resultado?
System.out.println(2 ^ 3); // ¿Por qué no da 8?

int x = 5, y, z;
y = x++;
System.out.println("x = " + x + "\ny = " + y); // ¿Cuál es el resultado?

x = 5;
z = ++x;
System.out.println("x = " + x + "\nz = " + z); // ¿Cuál es el resultado?

int m = 14 % 4;
System.out.println("m = " + m); // ¿Cuál es el resultado?

m = 12;
System.out.println("m >> 2 = " + (m >> 2)); // ¿Cuál es el resultado?

double d = 5.0;
d *= 4.0;
System.out.println("d = " + d); // ¿ Cuál es el resultado?

// ¿ Cuál es el resultado?
System.out.println("Ternario: " + (x == 5 ? "si" : "no"));
// ¿Cómo escribiría un operador ternario anidado?
}
}

OPERADORES DE ASIGNACIÓN.
Permiten que una variable pueda ser usada en una sentencia y asignada
al resultado, todo en una misma sentencia.
Por ejemplo:
d *= 4;
es igual a:
d = d * 4;

OPERADORES DE ROTACIÓN
Estos operadores actúan sobre valores enteros al rotar (desplazar) sus valores binarios hacia la
derecha o izquierda.
Desplazar un bit hacia la izquierda causa que un cero sea colocado en el dígito menos significativo,
moviendo todos los demás bits una posición hacia la izquierda y perdiendo el bit más significativo
(el bit que se encuentra más a la izquierda).

Página 2 de 7
Universidad Tecnológica de El Salvador
Programación III MSc. René Alberto Castro Velásquez

Ejemplo:
0 0 1 0 1 1 0 1 (45)
Si este valor fuera desplazado una vez hacia la izquierda (usando el operador <<), se obtendría lo
siguiente:
0 1 0 1 1 0 1 0 (90)
Esto sucede así porque un bit es desplazado hacia la izquierda, mientras un cero es añadido en el
extremo derecho de la cantidad, así:
Valor original 0 0 1 0 1 1 0 1 = 45
Desplazar 1 bit
hacia la izquierda
Bit perdido 0 1 0 1 1 0 1 0 Nuevo bit
0
Nuevo valor 0 1 0 1 1 0 1 0 = 90
Explicación adicional:
Recuerde que 0 0 1 0 1 1 0 1 en binario es igual a 45, tal como se muestra:
= 0 x 27 + 0 x 26 + 1 x 25 + 0 x 24 + 1 x 23 1 x 22 + 0 x 21 + 1 x 20
= 0 x 128 + 0 x 64 + 1 x 32 + 0 x 16 +1x8 +1x4 +0x2 +1x1
= 0 +0 + 32 +0 +8 +4 +0 +1
= 45
De la misma manera, 0 1 0 1 1 0 1 0 en binario es igual a 90, tal como se muestra:
= 0 x 27 + 1 x 26 + 0 x 25 + 1 x 24 + 1 x 23 0 x 22 + 1 x 21 + 0 x 20
= 0 x 128 + 1 x 64 + 0 x 32 + 1 x 16 +1x8 +0x4 +1x2 +0x1
= 0 + 64 +0 + 16 +8 +0 +2 +0
= 90
De forma similar, el operador de rotación hacia la derecha mueve los bits hacia la derecha. La
única diferencia es que uno es signado (>>) y el otro no (>>>). El signado coloca el bit del signo en
el extremo izquierdo de la cantidad mientras desplaza los bits restantes hacia la derecha. En el
caso del no signado siempre coloca un cero en el extremo derecho sin importar el bit del signo,
desplazando todos los bits (incluido el del signo) hacia la derecha.
0 0 1 0 1 1 0 1 (45)
Al usar >> o >>> se obtiene:
0 0 0 1 0 1 1 0 (22)

Página 3 de 7
Universidad Tecnológica de El Salvador
Programación III MSc. René Alberto Castro Velásquez

Valor original 0 0 1 0 1 1 0 1 = 45
Desplazar 1 bit
hacia la derecha
Nuevo bit 0 0 0 1 0 1 1 0 Bit perdido
0
Nuevo valor 0 0 0 1 0 1 1 0 = 22
Explicación adicional:
Recuerde que 0 0 0 1 0 1 1 0 en binario es igual a 22, tal como se muestra:
= 0 x 27 + 0 x 26 + 0 x 25 + 1 x 24 + 0 x 23 1 x 22 + 1 x 21 + 0 x 20
= 0 x 128 + 0 x 64 + 0 x 32 + 1 x 16 +0x8 +1x4 +1x2 +0x1
= 0 +0 +0 + 16 +0 +4 +2 +0
= 22
Ejemplo:
public class DemoRotacion {
public static void main(String [] args) {
int a = 11;
// ¿Qué imprime?
System.out.println("Valor original de a = " + a);
// ¿Qué imprime?
System.out.println("Correr 1 bit a la izquierda = " + (a << 1));
// ¿Qué imprime?
System.out.println("Correr 1 bit signado a la derecha = " + (a >> 1));
// ¿Qué imprime? ¿Por qué?
System.out.println("Correr 1 bit no signado a la derecha = " + (a >>> 1));

int b = -10;
// ¿Qué imprime?
System.out.println("\nValor original de b = " + b);
// ¿Qué imprime?
System.out.println("Correr 3 bits a la izquierda = " + (b << 3));
// ¿Qué imprime?
System.out.println("Correr 1 bit signado a la derecha = " + (b >> 1));
// ¿Qué imprime? ¿Por qué?
System.out.println("Correr 1 bit no signado a la derecha = " + (b >>> 1));

byte c = -12;
// ¿Qué imprime?
System.out.println("\nValor original de c = " + c);
// ¿Qué imprime?
System.out.println("Correr 3 bits a la izquierda = " + (c << 3));
// ¿Qué imprime?
System.out.println("Correr 1 bit signado a la derecha = " + (c >> 1));
// ¿Qué imprime? ¿Por qué?
System.out.println("Correr 1 bit no signado a la derecha = " + (c >>> 1));
// ¿Qué sucede si usa cast a tipo de datos byte? ¿Por qué?
}
}

Página 4 de 7
Universidad Tecnológica de El Salvador
Programación III MSc. René Alberto Castro Velásquez

OPERADORES DE COMPARACIÓN.
A continuación se muestra una tabla con los operadores de comparación y los
tipos de datos con los cuales pueden ser usados.

Operador Sintaxis Tipo de datos válido

Menor que < byte, short, int, long, float, double, char

Menor o igual
<= byte, short, int, long, float, double, char
que
Mayor que > byte, short, int, long, float, double, char

Mayor o igual
>= byte, short, int, long, float, double, char
que
byte, short, int, long, float, double, char, boolean,
Igual a ==
referencias
byte, short, int, long, float, double, char, boolean,
Diferente de !=
referencias

Instancia de instanceof Referencias

Estos operadores serán estudiados durante el desarrollo del curso.

OPERADORES BOOLEANOS.
Los operadores booleanos son usados para combinar dos
o más expresiones booleanas en una sola expresión
booleana. Los operadores condicionales AND (&&) y OR
(||) pueden ser usados para combinar dos expresiones
booleanas, mientras que los operadores bit a bit AND (&),
OR (|) y OR exclusivo – XOR (^) pueden ser usados tanto
en expresiones booleanas como en enteros.
Ejemplo:
public class BooleanosDemo {
public static void main(String[] args) {
boolean a = true;
boolean b = false;
System.out.println("a = " + a);
System.out.println("b = " + b);

System.out.println("\na && b = " + (a && b));

System.out.println("a || b = " + (a || b));
System.out.println("a | b = " + (a | b));
System.out.println("!(a && b) = " + !(a && b));
System.out.println("!(a & b) = " + !(a & b));
}
}

Página 5 de 7
Universidad Tecnológica de El Salvador
Programación III MSc. René Alberto Castro Velásquez

Estos operadores serán estudiados al momento de desarrollar el tema “Estructuras de Control”.

NOTA: Existe una diferencia entre los términos “operador bitwise” y “operador condicional
lógico”. A este último también se le conoce como “operador de corto circuito”. Puede obtener
información adicional en las direcciones:
https://docs.oracle.com/javase/tutorial/java/nutsandbolts/op2.html
http://docs.oracle.com/javase/tutorial/java/nutsandbolts/op3.html

OPERADOR TERNARIO.
Se llama así porque posee tres operandos y es
básicamente un mecanismo abreviado para escribir
una estructura de control if - else.
La sintaxis es la siguiente:
(expresión booleana) ? sentencia1 : sentencia2
La primera parte es una expresión booleana seguida
por un signo de interrogación. Si la expresión
booleana es verdadera, la sentencia1 es ejecutada. Si
la expresión booleana es falsa, la sentencia2 es ejecutada.
Por ejemplo:
El operador ternario Equivale a
int x = 5; int x = 5;
System.out.println("Ternario: " + if (x == 5)
(x == 5 ? "si" : "no")); System.out.println("Ternario: si");
else
System.out.println("Ternario: no");

COMENTARIOS EN JAVA.
Existen tres formas de colocar comentarios:
1. Use // para comentar lo que aparezca después de ellas. Muy útil para
colocar comentarios de una sola línea.
2. Use /* y */ para comentar todo lo que esté encerrado entre ellos.
Muy útil para colocar comentarios de varias líneas.
3. /** y */ son comentarios que se escriben para que el generador JavaDoc los incluya en la
documentación.
NOTA: Puede obtener información adicional sobre el uso de comentarios y JavaDoc en las
direcciones:
https://www.tutorialspoint.com/java/java_documentation.htm
http://www.javatpoint.com/java-comments
http://www.oracle.com/technetwork/articles/java/index-137868.html
http://www.dummies.com/programming/java/how-to-use-javadoc-to-document-your-classes/

Página 6 de 7
Universidad Tecnológica de El Salvador
Programación III MSc. René Alberto Castro Velásquez

CREAR ARCHIVO EJECUTABLE EN JAVA.

El formato de archivos jar es común para la distribución de programas y librerías
que están escritas en Java. El acrónimo Jar proviene de Java Archive, y es un
formato de archivo contenedor y de compresión. Cada archivo Jar contiene otros
archivos comprimidos y es muy fácil de abrir.
Generar un archivo Jar es sumamente sencillo y normalmente se efectúa de forma
automática, sólo se debe revisar que está marcada la opción Project Properties -> Build ->
Packaging -> Build JAR after compiling.
A continuación haga clic en la opción Clean and build, disponible con cualquiera de las acciones
siguientes:
1. Presionar el botón con el símbolo de martillo y una escoba ( ).
2. Usar la combinación de teclas Shift + F11.
3. Seleccionar la opción de menú Run -> Clean and Build Project.
El archivo Jar será generado dentro del folder dist.
NOTAS:
1. Necesita tener Java instalado en el equipo.
2. Si la aplicación se encuentra en modo gráfico bastará con hacer doble clic sobre el archivo
Jar para ejecutarlo.
3. Si la aplicación se encuentra en modo texto, es necesario abrir una instancia de la línea de
comandos y navegar hacia el directorio donde se encuentra el archivo Jar. A continuación
deberá ejecutarlo con la instrucción siguiente:
C:\Directorio donde se encuentra el archivo>java -jar archivo.jar

Página 7 de 7