3
Mar 14

Pildoritas de POO y Java: Conceptos básicos de programación. Operaciones

pildoras poo java
En la anterior pildorita de POO y Java vimos qué era un algoritmo y enumeramos los tipos de instrucciones que los componen y que nos permiten describir un problema: Datos, Operaciones y Sentencias. Además, vimos la primera parte, los Datos.

En esta pildorita vamos a ver el siguiente componente que forma un algoritmo: Las operaciones. Veremos los tipos de operadoresy su orden de precedencia.

Operaciones

Las operaciones son sentencias que realizan un cálculo sobre varios datos. Para realizar dichos cálculos tenemos una serie de operadores aritméticos (sumar, restar, multiplicar...), lógicos (mayor que, menor que, igual que...), y de asignación.

Los operadores sólo pueden ser utilizados con determinados tipos más o menos restrictivos (hay operadores que sirven para numéricos, otras para numéricos y de texto..). Además, los operadores pueden ser utilizados con dos datos – binarios - con un dato – unarios - e incluso terciarios.

Operadores aritméticos

Los operadores aritméticos actúan sobre datos numéricos, es decir, enteros y de coma flotante. Los básicos son + (sumar), - (restar), * (multiplicar), / (dividir) y % (módulo, que es el resto de una división de enteros).

Binarios

Operador Símbolo Descripción
Suma + Suma dos operandos
Resta - Resta dos operandos
Multiplicación * Multiplica dos operandos
División / Divide dos operandos
Módulo % Devuelve el resto de la división de dos operandos
//Suma
int resultadoSuma = 5 + 2; // resultadoSuma vale 7

//Resta
float resultadoResta = 5.3f - 2.07f; // resultadoResta vale 3.2300003

//Multiplicación
short resultadoMultip = 10 * 2; //resultadoMultip vale 20

// División
long resultadoDiv = 1238907 / 92384; //resultadoDiv vale 13

// Módulo		
int resultadoMod = 10 % 3; //resultadoMod vale 1

El operador suma, +, también puede operar con los String, concatenándolos entre ellos. También podemos concatenar a las cadenas valores de otros tipos, como int o long. Veamos un ejemplo:

System.out.println("resultadoSuma: " + resultadoSuma);

El comando System.out.println sirve para mostrar por consola un input introducido como parámetro (entre los paréntesis). Lo que veríamos por pantalla en este caso sería lo siguiente:

"resultadoSuma: 7"

Unarios

Operador Símbolo Descripción
Conversión de entero + Convierte el operando a entero si es un byte, short o char
Negación - Negación aritmética del operador (cambio de signo)
int a = -5;
int b = -a; //b vale 5

Operadores Lógicos

Los operadores lógicos comparan dos valores y devuelven la relación existente entre ambos. Por tanto, el resultado de estos operadores es de tipo booleano, es decir, en términos de verdadero o falso.

Los operadores lógicos a su vez pueden dividirse en dos subtipos: comparación y condicionales. Ambos tipos de operadores además se pueden combinar para realizar expresiones más complejas.

Operadores de comparación

Operador Símbolo Descripción
Mayor que > Devuelve true si el primer operando es mayor que el segundo
Mayor o igual que >= Devuelve true si el primer operando es mayor o igual que el segundo
Menor que < Devuelve true si el primer operando es menor que el segundo
Menor o igual que <= Devuelve true si el primer operando es menor o igual que el segundo
Igual == Devuelve true si los dos operandos son iguales
Distinto != Devuelve true si los dos operadores no son iguales
//Mayor que
boolean mayorQue = 3 > 1; //mayorQue vale true

// Menor que
boolean menorQue = 3 < 1; //menorQue vale false

//Mayor o igual que
boolean mayorIgualQue = 3 >= 3; //mayorIgualQue vale true

//Menor o igual que
boolean menorIgualQue = 3 <= 1; //menorIgualQue vale false

//Igual
boolean igual = 5 == 5; //igual vale true

// Distinto		
boolean distinto = 5 != 5; //distinto vale false

Operadores condicionales

Los operadores condicionales actúan sobre dos datos de tipo booleano, y devuelven un resultado también booleano. También pueden evaluar dos expresiones de comparación, ya que estas expresiones devolverán valores boolean.

Para mayor comprensión de los operadores condicionales os recomiendo ver el apartado de Operadores Condicionales de la Pildorita de Bases de Datos sobre Cláusulas. Las tablas de la verdad os pueden ayudar a comprenderlos mucho mejor

Operador Símbolo Descripción
AND && Devuelve true si ambos operadores son verdaderos
OR || Devuelve true si uno de los operadores es verdadero
Falso ! Opera sobre un elemento y devuelve su valor contrario
//AND
boolean and = true && true; // Vale true
boolean and2 = true && false; //Vale false
boolean andComplejo = (2 > 3) && (1 < 5); //false AND true: Vale false

//OR
boolean or = true || false; //Vale true. El intérprete ni siquiera mirará el sgundo elemento
boolean or2 = false || false; //Vale false
boolean orComplejo = (2 < 3) || (1 > 2); //Vale true

//Negacion
boolean not = !(3 > 1); //not vale false

Operadores de asignación

Los operadores de asignación son operadores especiales que asignan un valor a una variable. El operador básico ya lo hemos visto en anterior ejemplos, el =, pero en conjunción con otros símbolos como el de suma, se pueden realizar atajos.

Binarios

Operador Símbolo Ejemplo Expresión equivalente
Asignación básica = A = B; No Aplica
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
Modulo %= A %= B A = A % B
//Asignación básica
int c = 5; // c vale 5

//Suma
c += 15; // c vale 20

//Resta
c-=5; //c vale 15

//Multiplicación
c *= 2; //c vale 30

//División
c /= 2; //c vale 15

//Módulo
c %= 10; //c vale 5

Unarios

Operador Símbolo Descripción
Post-incremento op++ Incrementa en 1 el operador. Se evalúa el valor anterior al incremento
Pre-incremento ++op Incrementa en 1 el operador. Se evalua el valor posterior al incremento
Post-decremento op-- Decrementa en 1 el operador. Se evalúa el valor anterior al incremento
Pre-decremento --op Decrementa en 1 el operador. Se evalúa el valor posterior al incremento
int unarios = 8;

unarios++; //unarios vale 9
++unarios; //unarios vale 10
unarios--; //unarios vale 9
--unarios; //unarios vale 8

boolean postfijo = (9 == unarios++); //postfijo vale false
boolean prefijo = (9 == unarios++); //prefijo vale true

Orden de precedencia

Cuando construimos expresiones complejas donde utilizamos más de un tipo de operador, hay que tener en cuenta el Orden de precedencia de los Operadores.

Operador Símbolo
1 operadores unarios postfijos op++, op--
2 Operadores unarios prefijos ++op, --op, +op, -op, !
3 Multiplicación y División *, /, %
4 Suma y Resta +, -
5 Operadores relacionales <, >, <=, >=
6 Operadores de equivalencia ==, ¡=
7 AND &&
8 OR ||
9 Condicional ?:
10 Operadores de asignación =, +=, -=, *=, /=, %=

 

Para romper el orden de precedencia, al igual que en las matemáticas, utilizaremos paréntesis o corchetes.
  
Y con esto terminamos esta pildorita de operaciones. En próximas pildoritas hablaremos de las sentencias de flujo de ejecución, las funciones y finalmente ciertas consideraciones especiales de Java.

Índice de Pildoritas

Share
29
Apr 13

Pildoritas de Bases de Datos: SQL. Clausulas I

pildoras bbdd

En la entrada anterior de Pildoritas de Bases de Datos comenzamos con SQL viendo los comandos de definición de la base de datos (DDL) y los de manipulación de los datos (DML). Lo siguiente que vamos a ver son las clausulas, una parte importantísima en la definición de comandos DML.

Donde mejor se puede ver la importancia de las clausulas es en las consultas así que os adelanto que a partir de ahora vais a ver el comando SELECT hasta en la sopa.

Clausulas

Las clausulas son condiciones de filtrado para manipular datos.

Ya os adelanté un poco por encima en el anterior post las clausulas FROM y WHERE, pero ni siquiera rascamos un poco el potencial de estas clausulas. Paso a explicarlas y luego ya, como os prometí en el anterior post, veremos ejemplos prácticos donde aplicaremos lo aprendido.

FROM

Especifica de dónde queremos obtener los datos, es decir, de que tabla. Se utiliza no sólo en el comando de consulta, SELECT, sino también en los comandos UPDATE y DELETE por razones obvias, si no indicas donde está al menos lo que quieres manipular, mal vamos.

WHERE

Está clausula es donde se indican las condiciones de filtrado de los datos. Estas condiciones se definen a través de los operadores lógicos y de comparación. Pero no nos adelantemos aún, cada cosa a su tiempo 😉

Esta clausula también se usa en todos los comandos DML.

GROUP BY

La clausula GROUP BY sirve para agrupar la información. Es de gran utilidad combinada con las funciones de agregado que más adelante explicaremos.

Esta clausula es aplicable exclusivamente al comando SELECT.

HAVING

La clausula HAVING tiene siempre que ir acompañada de un GROUP BY. En ella indicamos las condiciones que debe satisfacer cada grupo y donde utilizaremos funciones de agregación. Como en el caso del GROUP BY de utilizarla será en el SELECT.

ORDER BY

Sirve para ordenar la información obtenida a través de la consulta en un determinado orden.

 

Una vez conocidas las clausulas, vamos a ver los operadores lógicos, de comparación y los predicados, lo cual nos servirá para poder indicar nuestras condiciones de filtrado en la clausula WHERE.

Operadores condicionales

Los operadores condicionales se utilizan en la lógica proposicional para admitir o rechazar proposiciones, así como para conectarlas. Los valores de estas proposiciones tendrán un valor Verdadero/Falso (0 o 1 o apagado y encendido, si lo llevamos al campo de los circuitos digitales). Los operadores lógicos operan con estas proposiciones para dar lugar a nuevos valores lógicos.

Los operadores lógicos son los cimientos de la informática, así que confío en que si habéis llegado a un manual de SQL este concepto lo teneis medianamente claro. Si no es así, os recomiendo una lectura al artículo de Wikipedia donde se explica el Álgebra de Boole.

AND

El operador AND se traduce en lógica y matemáticas como conjunción. Su resultado será verdadero si ambos operandos son verdaderos.

A B A AND B
Verdadero Verdadero Verdadero
Verdadero Falso Falso
Falso Verdadero Falso
Falso Falso Falso

OR

El operador OR es lo que en lógica se conoce como disyunción. Su resultado será verdadero cuando uno o más de sus operandos es verdadero.

A B A OR B
Verdadero Verdadero Verdadero
Verdadero Falso Verdadero
Falso Verdadero Verdadero
Falso Falso False

NOT

El operador NOT, o negación, opera sobre un sólo operando y nos devuelve su valor contrario.

A NOT A
Verdadero Falso
Falso Verdadero

 

* Para indicar estos valores en SQL indicaremos los vocablos anglosajones TRUE (Verdadero) y FALSE (Falso).

Operadores de comparación

Los operadores de comparación también son operadores lógicos como los condicionales, ya que nos devolverán un valor booleano, es decir, verdadero o falso.

Estos operadores comparan el valor de dos valores y determinan la relación existente entre ambos.

Operador Descripción
= Igual que
< Menor que
> Mayor que
<> Distinto de
<= Menor o igual que
>= Mayor o igual que
BETWEEN Existencia del valor entre un intervalo de valores
LIKE Se aplica con valores de tipo cadena y se utiliza para encontrar registros coincidentes a un patrón modelo
IN Compara conjuntos de valores
IS Compara si dos valores lógicos son iguales

 

Los operadores de comparación suelen ser usados junto a los operadores condicionales para construir expresiones más complejas. Por ejemplo, podríamos utilizar dos operadores diferentes de comparación con el operador lógico AND para determinar si ambas expresiones son verdaderas.

Dependiendo del motor que utilicemos, encontraremos otros muchos operadores de comparación, pero para eso no hay más que echarle un vistazo rápido a la documentación de dicha tecnología.

Ejemplos

Y ahora, como os prometí, vamos a ver algunos ejemplos prácticos donde apliquemos lo aprendido arriba, que es la mejor forma de asimilar todo este tocho de teoría. Los ejemplos de esta sección todavía no serán demasiado complejos, ya que por ahora lo mejor es no complicarnos mucho y asimilar la información poco a poco. Más adelante, cuando termine con la teoría de SQL haré una pildorita exclusiva de ejemplos prácticos.

Para este y para la mayoría de ejemplos utilizaremos la base de datos que definimos en el primer post de las pildoritas.

Entidad-Relacion-Final

Obtener el nombre y apellidos del empleado con DNI 99999999R

SELECT NOMBRE, APELLIDOS FROM EMPLEADOS WHERE DNI = '99999999R'

Obtener los proyectos que hayan empezado a partir del 01/01/2012 y hayan acabado antes de 31/12/2012.

SELECT * FROM PROYECTO 
WHERE FECHA_INICIO > '01/01/2012' AND FECHA_FIN < '31/12/2012'

* Como veis en la parte donde deberíamos indicar los campos hemos utilizado el carácter asterisco. Esto indica que queremos todos los campos de la tabla o tablas indicadas en el FROM

Obtener el nombre de todos los departamentos que estén en las áreas de Desarrollo y Bases de Datos

SELECT NOMBRE FROM PROYECTO WHERE AREA IN ('Desarrollo', 'Bases de Datos')

Obtener todas las compañías cuyo nombre empiece por A y sean de tipo S.L.

SELECT * FROM COMPAÑIA WHRE NOMBRE LIKE'A%' AND TIPO = 'S.L.'

* El caracter % que colocamos después de la A es el llamado carácter comodín y se utiliza para indicar cualquier cadena.

 

Y con esto ponemos fin a la segunda pildorita de SQL. Siento si me he extendido un poco en el tamaño de este post, pero no he visto forma humana de poder dividirlo en más partes sin que se pierda el contexto.

En la próxima pildorita veremos el resto de clausulas que nos quedan, GROUP BY y HAVING, y las funciones de agregación.

Índice de Pildoritas

Share