Archivo
Operadores relacionales y condicionales en Java.
Vamos a dar un paso más para llegar a ser grandes desarrolladores y vamos a meternos de lleno en los operadores relacionales y lógicos.
Operadores relacionales
Los operadores relacionales determinan si un operando es mayor, menor, igual, distinto a otro operando.
El operador (==) determinan si los dos operandos son iguales, el operador (!=) determinan si los dos operandos son distintos, el operador (>) determina si el primer operando es mayor que el segundo, el operador (>=) determina si el primer operando es mayor o igual que el segundo, el operador (<) determina es el primer operando es menor que el segundo y el operador (<=) determina si el primer operando es menor o igual que el segundo.
Son operadores muy sencillos de utilizar y como resultado de la operación devuelven un booleano true o false según se cumpla o no la relación entre los operandos. Estos operadores se suelen utilizar junto a las estructuras de control condicionales, pero como aún no las hemos visto vamos a ver un ejemplo mucho más sencillo:
class OperadoresRelacionales { public static void main(String[] args) { int operando1 = 1; int operando2 = 1; System.out.println( operando1 == operando2 ); //Imprime true porque los dos operandos son iguales System.out.println( operando1 != operando2 ); //Imprime false porque los dos operandos no son distintos operando1 = 3; operando2 = 3; System.out.println( operando1 > operando2 ); //Imprime false porque el operando1 no es mayor que el operando2 System.out.println( operando1 >= operando2 ); //Imprime true porque el operando1 es igual que el operando2 operando1 = 3; operando2 = 10; System.out.println( operando1 < operando2 ); //Imprime true porque el operando1 es menor que el operando2 System.out.println( operando1 <= operando2 ); //Imprime true porque el operando1 es menor que el operando2 } }
Operadores lógicos
Los operadores lógicos tienen que ver con la lógica booleana, realizan las operaciones booleanas AND y OR comparando valores booleanos. Tenemos dos operadores, el operador (&&) que realiza la operación AND, y el operador (||) que realiza la operación OR.
Estas dos operaciones devuelven un booleano true o false dependiendo del operador utilizado. Si se utiliza el operador && devolverá true solamente cuando los dos operandos sean true, en caso contrario devolverá false. Si se utiliza el operador || devolverá true con que uno de los operandos sea true, y solo devolverá false cuando los dos operandos sean false.
Este tipo de operadores se utilizan principalmente en las estructuras de control condicionales para comprobar condiciones. Vamos a ver un ejemplo sencillo para entenderlo mejor:
class OperadoresLogicos { public static void main(String[] args) { boolean verdadero = true; boolean falso = false; int operando1 = 1; int operando2 = 1; System.out.println( verdadero && falso ); //Imprime false porque uno de los dos operandos es false System.out.println( verdadero || falso ); //Imprime true porque uno de los dos operandos es true System.out.println( operando1==operando2 && operando1>operando2 ); //Imprime false porque no se cumplen las dos condiciones. //Antes de evaluarse el operador AND, se evaluan los operadores //relacionales, dando como resultado un valor true en el primer operando //y un valor false en el segundo operando. El operador AND evalua entonces //los dos booleanos y devuelve false porque uno de los dos es falso. System.out.println( operando1==operando2 || operando1>operando2 ); //Imprime true porque se cumplen al menos una condicion. //Antes de evaluarse el operador OR, se evaluan los operadores //relacionales, dando como resultado un valor true en el primer operando //y un valor false en el segundo operando. El operador OR evalua entonces //los dos booleanos y devuelve true porque uno de los dos es verdadero. } }
Cabe destacar que los operadores condicionales son excluyentes, por lo que el segundo operando solo se evalúa si es necesario.
Por ejemplo, la siguiente condición, false && true, devolverá false y solo analizará el primer operando. No le hace falta analizar el segundo porque el operador && devuelve false si alguno de los dos o los dos son false. Algo similar ocurre con el operador ||, si tenemos la siguiente condición true || false, devolverá true sin analizar el segundo operando porque el operador || devuelve true si alguno o los dos son true.
Operadores de asignación, aritméticos y unarios en Java.
Ahora que ya sabemos declarar e inicializar las variables vamos a ver que es lo que podemos hacer con ellas. Empezaremos estudiando los operadores del lenguaje Java.
Los operadores son símbolos especiales que llevan a cabo operaciones específicas y luego devuelven un resultado. Los operadores le resultaran muchísimo más sencillo si ha estudiado algo de matemáticas.
Hay que tener en cuenta que no todos los operadores tienen la misma prioridad, esto es así también en las matemáticas, no es lo mismo (3+3)/2 que 3+3/2. En el primer ejemplo primero se realiza la suma y después la división dando un resultado de 3. En el segundo caso primero se realiza la división porque tiene más prioridad que la suma, dando un resultado de 4.5.
Operador de asignación
El operador más sencillo y más utilizado es el operador de asignación. Ya lo hemos utilizado anteriormente y sirve para asignar un valor a una variable, para ello utilizamos el símbolo igual (=).
Ejemplos:
int numero = 5; int edad = 22; String cadena = "Hola";
Como vemos no solo sirve para asignar tipos primitivos a variables primitivas. También se utiliza para asignar referencias a objetos.
Operadores aritméticos
Los operadores aritméticos son los operadores que realizan sumas, restas, multiplicaciones, divisiones y la operación de módulo. Entre estos cinco es posible que el que más desconozcas es el operador de módulo que se utiliza para calcular el resto de una división.
El operador suma es el símbolo más (+), el operador resta es el símbolo menos (-), el operador multiplicación es el símbolo arterisco (*), el operador división es el símbolo contrabarra (/), el operador módulo es el símbolo porcentaje (%).
También podemos combinar los operadores aritméticos con el operador de asignación para crear asignaciones compuestas. Por ejemplo x+=1 equivale a x=x+1. El operador + también se utiliza para concatenar Strings.
Vamos a ver un ejemplo sencillo del uso de estos operadores:
class Aritmetica { public static void main (String[] args) { int resultado = 1 + 2; // resultado vale 3 System.out.println(resultado); //Imprime 3 resultado = resultado - 1; //resultado vale 2 System.out.println(resultado); //Imprime 2 resultado = resultado * 2; // resultado vale 4 System.out.println(resultado); //Imprime 4 resultado = resultado / 2; // resultado vale 2 System.out.println(resultado); //Imprime 2 resultado += 8; // resultado vale 10 resultado = resultado % 7; // resultado vale 3 System.out.println(resultado); //Imprime 3 String primero = "Primer trozo,"; String segundo = "segundo trozo,"; System.out.println(primero+segundo+"tercer trozo."); //Imprime Primer trozo,segundo trozo,tercer trozo. } }
Operadores unarios
Los operadores unarios solo requieren un operando y realizan varias tareas, entre ellas incrementar/disminuir un valor en uno, negar una expresión o invertir el valor de un booleano.
El operador + indica un valor positivo, el operador – indica un valor negativo, el operador ++ incrementa en uno, el operador – decrementa en uno y el operador ! invierte el valor de un booleano, es decir si el valor es true lo convierte a false, y al contrario.
Vamos a ver un ejemplo sencillo:
class Unario { public static void main(String[] args) { int resultado = 1; resultado--; //resultado vale 0 System.out.println(resultado); //Imprime 0 resultado++; // resultado vale 1 System.out.println(resultado); //Imprime 1 resultado = -resultado; // resultado vale -1 System.out.println(resultado); //Imprime -1 boolean falso = false; System.out.println(falso); // Imprime false System.out.println(!falso); // Imprime true } }
El operador de decremento/incremento se puede utilizar como sufijo o prefijo, pero hay que tener en cuenta como se evaluan. Si se utiliza el operador como prefijo primero se incrementa/decrementa y luego se utiliza el valor, si se utiliza como sufijo primero se utiliza su valor y después se decrementa.
Vamos a ver un ejemplo sencillo de este comportamiento:
class UnarioPrueba { public static void main(String[] args) { int resultado = 1; resultado++; //resultado vale 2 System.out.println(resultado); //Imprime 2 System.out.println(resultado++); //Imprime 2 System.out.println(resultado); //Imprime 3 System.out.println(++resultado); //Imprime 4 } }
Introducción mínima a los Strings en Java
En la anterior entrada vimos como declarar e inicializar variables de tipo primitivo en Java. Hay que destacar que de momento estamos utilizando variables locales al método main que solo son accesibles desde el propio método main de la clase.
Más adelante estaremos preparados para descubrir los diferentes ámbitos que puede tener una variable, pero de momento vamos a enfrentarnos a los Strings.
Antes de explicar los Strings en Java quería explicar los operadores, las estructuras de control y entrar más en detalle en el mundo de la POO en Java. Pero como dentro de los ejemplos de esos capítulos futuros utilizaremos los Strings para imprimir información en la consola he creído necesario introducirlos antes. Como veis aprender un lenguaje de programación no es una secuencia lineal, tarde o temprano estaremos preparados para utilizar todo lo aprendido y combinarlo para desarrollar aplicaciones mucho más avanzadas.
Strings
Los Strings son secuencias de carácteres. Cuando sólo queremos almacenar un carácter utilizamos una variable de tipo primitivo char, pero si lo que queremos es almacenar una cadena de carácteres es mejor utilizar los Strings. Los Strings no son variables de tipo primitivo, son variables de tipo referencia, es decir, objetos.
La diferencia entre una variable de tipo primitivo y un objeto es que la variable de tipo primitivo almacena el valor de la variable mientras que la variable de tipo referencia almacena una dirección de memoria donde se encuentra almacenado el objeto. De todas formas no hay que preocuparse por esto, en Java no existen los punteros como en C, por lo que nos evitamos trabajar a tan bajo nivel con direcciones de memoria.
La plataforma Java nos brinda la clase String para crear y manipular cadenas de carácteres. La forma más sencilla de declarar e inicializar una variable de tipo String es la siguiente:
String cadena = "Hola a todos.";
En este caso, el literal Hola a todos. se encierra entre comillas. El compilador será el encargado de crear un objeto String que almacene ese valor.
Como veremos más adelante, al ser un objeto también podemos instanciar un String utilizando la palabra clave new y un constructor de la clase String. Pero esto es un poco más avanzado para nosotros en esta etapa, así que utilizaremos la forma directa a partir de ahora.
Los Strings son inmutables, es decir, cada vez que se crea una variable de tipo String no se puede modificar. Esto no quiere decir que una vez inicializada una variable de tipo String con una cadena no podamos reemplazarla por otra.
La clase String cuenta con una serie de métodos que podemos utilizar para manipular Strings. Podemos verlo en la API oficial de Java:
Si es la primera vez que entrais a navegar por la API puede que sea un poco caótico pero es la mejor documentación de la que disponen los desarrolladores para obtener información. Y no os desanimeis, hay muchos paquetes, cientos de clases, miles de métodos, pero no teneis que saberlos todos. Simplemente conocer su existencia y saber que están ahí y que podemos utilizarlos en los casos que creamos necesarios.
Hasta aquí es suficiente como introducción a los Strings para comprender mejor las siguientes entradas. Más adelante iremos utilizando métodos de esta clase para manipular nuestros Strings, desde calcular el número de carácteres que tienen, concatenar cadenas, buscar la posición de un determinado carácter, etc. Pero antes de irnos un ejemplo completo para imprimir una cadena de carácteres por la consola estándar utilizando el método println del objeto out de la clase System.
public class Ejemplo { public static void main(String []args) { String cadena = "Esto es un ejemplo de String."; System.out.println(cadena); } }
Variables de tipo primitivo en Java
En la anterior entrada dedicada al mundo Java vimos los conceptos mínimos necesarios de la POO, pero todo fue puramente teórico y esto es así porque enseñar un lenguaje de programación no es tarea fácil, no es una secuencia lineal que puedas seguir de inicio a fin ya que todas las características estan muy ligadas entre sí.
Pero por algún lugar tendremos que empezar, por eso los primeros ejemplos que iremos viendo costarán de poco más que una simple clase con un método main. Si recordais el primer ejemplo del Hola Mundo vimos que una clase se definia con la palabra clave class seguido del nombre de la clase. Todo el código de la clase iba encerrado entre llaves. Además la clase principal que lanza la ejecución de la aplicación debe de tener un método especial, el método main.
La estructura mínima necesaria para que un programa escrito en Java compile es la siguiente:
class nombreDeClase { public static void main(String args[]) { } }
Aunque no lo he comentado en entradas anteriores, cuando guardais el fichero con el código fuente debeis aseguraos que el fichero se llama exactamente igual que el nombre de la clase: nombreDeClase.java, sino el compilador de Java dará un error. No os preocupeis si de momento no se entiende el porque de la palabras public, static, void, string, poco a poco lo iremos viendo todo. Por ahora hacerlo simplemente así.
Variables
Como vimos en la entrada anterior un objeto almacena su estado en campos, estos campos no son más que variables, espacios de memoria que almacenan algún valor y están identificados por un nombre. En Java se definen las siguientes reglas para nombrar a las variables:
- Los nombres de variable distinguen entre minúsuclas y mayúsculas, por lo que no es lo mismo una variable llamada nombre que otra variable llamada Nombre.
- Los nombres de variable pueden ser cualquier identificador legal, es decir, una secuencia de carácteres alfanuméricos, pero deben empezar con una letra, el signo del dólar o un guión subrayado, no por un número. De todas formas por convención los nombres de las variables suelen empezar con una letra minúscula. Tampoco pueden contener espacios en blanco.
Ejemplo: Una variable que se llame 1nombre no es válida, pero una que se llame nombre1 sí.
- El nombre de una variable no puede ser una palabra clave o reservada del lenguaje:
abstract continue for new switch assert*** default goto* package synchronized boolean do if private this break double implements protected throw byte else import public throws case enum**** instanceof return transient catch extends int short try char final interface static void class finally long strictfp** volatile const* float native super while * ya no se usan ** añadidas en 1.2 *** añadidas en 1.4 **** añadidas en 5.0
- La convención es utilizar camelCase para nombrar las variables. Es decir si tenemos una variable que almacene el nombre completo de una persona podríamos utilizar el identificador nombreCompleto. Así nombraremos las variables de nuestros ejemplos.
Los tipos de datos primitivos
En Java antes de utilizar cualquier variable hay que declararla. Un ejemplo:
int edad = 22;
De esta forma le decimos al compilador que existe una variable llamada edad que contiene datos numéricos y que tiene un valor inicial de 22. Además del tipo de datos int, el lenguaje Java soporta otros siete tipos de datos primitivos. Un tipo primitivo esta predefinido por el lenguaje y son palabras clave que no podemos utilizar para nombrar a nuestras propias variables.
Java cuenta con los siguientes tipos primitivos:
- byte: El tipo de datos byte es de 8 bits. Tiene un valor mínimo de -128 y un valor máximo de 127. Este tipo de datos puede ser útil para ahorrar memoria.
- short: El tipo de datos short es de 16 bits. Tiene un valor mínimo de -32.768 y un valor máximo de 32.767.
- int: El tipo de datos int es de 32 bits. Tiene un valor mínimo de -2.147.483.648 y un valor máximo de 2.147.483.647. Para valores enteros este tipo de datos es generalmente la mejor opción ya que permite almacenar una amplia gama de valores.
- long: El tipo de datos long es de 64 bits. Tiene un valor mínimo de -9.223.372.036.854.775.808 y un valor máximo de 9.223.372.036.854.775.807. Puedes utilizar este tipo de datos cuando necesites valores más amplios que los previstos en int.
- float: El tipo de datos float es un tipo de datos que permite almacenar valores en coma flotante de simple precisión, es decir, números decimales. Se suele utilizar para ahorrar memoria. Este tipo de datos no debe utilizarse para valores precisos, para ello contamos con una serie de clases que veremos más adelante.
- double: El tipo de datos double es un tipo de datos que permite almacenar valores en coma flotante de doble precisión. Para los valores decimales esta es la opción que más suele utilizarse. Y como dijimos antes este tipo de datos tampoco debe utilizarse para valores muy precisos.
- boolean: El tipo de datos boolean solo tiene dos posibles valores, true o false. Se utiliza este tipo de datos para hacer un seguimiento de condiciones.
- char: El tipo de datos char es un tipo de datos que almacena un bit de carácteres Unicode-16. Tiene un valor mínimo de ‘\u0000′ que representa el 0 y un valor máximo de ‘\uffff’ que representa el 65.635. Suele utilizarse para almacenar carácteres Unicode.
Valores por defecto:
No siempre es necesario asignar un valor cuando se declara una variable. Las variables que se declaran pero no se inicializan se establecen a un valor por defecto predeterminado por el compilador. En general, este valor suele ser cero o nulo, dependiendo del tipo de datos. Pero esto solo es así en las variables de instancia (campos de una clase).
Las variables locales, que son las que empezamos a tocar, deben inicializarse antes de utilizarse o se producirá un error en tiempo de compilación.
Veamos ahora algunos ejemplos del uso de variables de tipo primitivo en Java. Los siguientes ejemplos son sencillos, no realizan ninguna tarea en especial, simplemente declarar e inicializar variables:
boolean resultado = true; char caracter = 'C'; byte enteroByte = 100; short enteroCorto = 10000; int entero = 100000; long enteroLargo = 30L; float decimalSimple = 24.67F; double decimalDoble = 3678.8767;
La L mayúsucla y la F mayúscula le indican al compilador que tomen el literal 30 y 24.67 como si fueran de tipo long y float respectivamente. Esto es así porque los literales enteros por defecto son de tipo int y los literales decimales por defecto son de tipo double.
Conceptos básicos sobre la programación orientada a objetos en Java.
Cuando nos sumergimos dentro del desarrollo en la plataforma Java lo primero que hacemos es instalar y configurar todo lo necesario para empezar a programar nuestras aplicaciones. Después comenzamos a experimentar con la primera aplicación sencilla para aprender como funciona el mecanismo de compilación y ejecución en la JVM.
Una vez hecho esto es necesario aprender las características del lenguaje de programación Java. Pero Java no es un lenguaje normal y corriente, es un lenguaje orientado a objetos, por lo que antes de empezar con las características propias del lenguaje hacen falta aprender los conceptos básicos de la programación orientada a objetos, de ahora en adelante, POO.
Empezar con la POO no es muy díficil, pero para aprender las buenas prácticas hace falta mucha experiencia. Esta entrada no pretende ser una explicación avanzada de la POO, patrones de diseño y buenas prácticas, sino que pretende explicar los conceptos mínimos necesarios para empezar a adentrarse en el mundo Java.
¿Qué es un objeto?
El concepto más importante en la POO es el concepto del objeto. Para entenderlo facilmente ya que es un concepto un tanto abstracto mira a tu alrededor, seguro que tienes muchos ejemplos de objetos del mundo real: tu gato, la mesa, la televisión, el ordenador.
Los objetos del mundo real no son muy distintos de los objetos en el mundo del software. Ambos comparten dos características, todos ellos tienen un estado y un comportamiento.
¿Qué quiere decir esto? Piense por ejemplo en un gato. Un gato tiene un nombre, un color de pelaje y pertenece a una raza. Todas estas características conforman el estado del gato y es más, pueden cambiar en el tiempo. Por ejemplo, el gato cuando crece cambia el color de su pelaje, incluso puede cambiar su nombre. Además del estado que tenga el gato, tiene un comportamiento. Los gatos pueden maullar, correr, comer, mover la cola.
Identificar el estado y el comportamiento de los objetos del mundo real es una buena manera de empezar a pensar en términos de programación orientada a objetos.
Un objeto software almacena su estado en campos (variables), y expone su comportamiento a través de métodos (funciones). Los métodos operan en el estado interno del objeto y son el principal mecanismo para la comunicación entre objetos. De esta forma se oculta el estado interno del objeto ya que toda interacción con él se realiza a través de los métodos.
Esto se conoce como la encapsulación de los datos del objeto, un principio fundamental en la POO. El objeto tiene una interfaz bien definida que expone al resto de objetos. ¿Por qué es una buena práctica la encapsulación? Imaginaros que hemos definido un objeto Bicicleta que solo tiene 7 marchas. Si solo dejamos acceder al estado de la bicicleta a través de los métodos podremos controlar en un método que la marcha introducida sea un valor númerico en el intervalo 1-7, rechazando cualquier otra marcha. El principio de encapsulación nos permite construir aplicaciones más seguras, es uno de los pilares básicos de la POO.
¿Qué es una clase?
Hasta ahora hemos hablado de los objetos, pero tanto en el mundo real como en el mundo del software los objetos pertenecen a una clase. Una clase en el mundo del software no es más que una plantilla que se utiliza para la creación de objetos. Cada objeto en el mundo Java es único, tiene una identidad. Esto es así también en el mundo real, imaginar que hay dos personas iguales que tienen el mismo nombre y apellidos, a pesar de ser exactamente iguales se tratan de forma distinta y cada uno tiene su estado y su comportamiento.
Toda aplicación Java esta formada por objetos que comparten mensajes entre sí para resolver un problema de negocio. Y más importante aún, toda aplicación Java está formada por al menos una clase con un método especial, que es el punto de partida de la aplicación. Es el método que lanza la JVM para iniciar la aplicación, el método main.
Ya estamos preparados para estudiar las características básicas del lenguaje. De todas formas iremos explicando más adelante como definir clases e instanciar (crear) nuevos objetos.
