“Java es un lenguaje de programación y una plataforma informática comercializada por primera vez en 1995 por Sun Microsystems”, así de fácil resume la propia web de Java qué es esta tecnología.
Nació con el objetivo de ser un lenguaje de programación de estructura sencilla que pudiera ser ejecutado en diversos sistemas operativos.
La similitud en el nombre entre Java y JavaScript genera que en ocasiones se confundan. En cambio, ambos son totalmente diferentes.
Mostrando algunas de sus diferencias
| Java | JavaScript |
|---|---|
| Es un lenguaje complilado | Es un lenguaje interpretado |
| Se depura en dos fases | Se depura en una fase |
| Es un lenguaje orientado a objetos puro | Está basado en prototipos |
| Es fuertemente tipado | Es débilmente tipado |
Las variables no son un concepto nuevo, cualquiera que sepa matemáticas está familiarizado con el concepto de variables.
Una variable es un contenedor en el que puede almacenar cualquier dato. Por ejemplo, puedes tener la siguiente variable:
Variables en Java
Las variables Java son un espacio de memoria en el que guardamos un determinado valor (o dato). Para definir una variable seguiremos la estructura:
1[privacidad] tipo_variable identificador;
Java es un lenguaje de tipado estático. Por lo cual todas las variables tendrán un tipo de dato (ya sea un tipo de dato primitivo o una clase) y un nombre de identificador.
El tipo de dato se asignará a la hora de definir la variable. Además, en el caso de que las variables sean propiedades de objetos tendrán una privacidad.
Ejemplos de variables serían…
1int numero = 2; 2String cadena = "Hola"; 3long decimal = 2.4; 4boolean flag = true;
Las variables son utilizadas como propiedades dentro de los objetos.
1class Triangulo { 2 private long base; 3 private long altura; 4}
No te preocupes por el concepto de objeto, ya que lo revisaremos más adelante cuando hablemos de la Programación Orientada a Objetos
Tipos de variables en Java
Dentro de Java podemos encontrar los siguientes tipos de variables:
1class Triangulo { 2 private long base; 3 private long altura; 4}
1class Triangulo { 2 static long lados = 3; 3}
Si además queremos que el valor no pueda cambiar nunca la definiremos como final.
1class Matematicas { 2 final static long PI = 3.14159; 3}
1int variable = 2;
1public Triangulo(long base, long altura){...}
Cuando vayamos a dar un nombre a una variable deberemos de tener en cuenta una serie de normas. Es decir, no podemos colocar el nombre que queramos a una variable.
Los identificadores son secuencias de texto unicode, sensibles a mayúsculas cuya primer carácter solo puede ser una letra, número, símbolo dolar $ o subrayado _ . Si bien es verdad que el símbolo dolar no es utilizado por convención. Es recomendable que los nombres de los identificadores sean legibles y no acrónimos que no podamos leer. De tal manera que a la hora de verlos se auto-documenten por sí mismos. Además estos identificadores nunca podrán coincidir con las palabras reservadas.
Algunas reglas no escritas, pero que se han asumido por convención son:
Los valores literales son aquellos que podemos asignar a las variables. Dependiendo del tipo de variable podremos asignar unos valores u otros.
Literales de enteros
Los enteros que podemos utilizar serán byte, short, int y long. Los literales que les asignemos siempre será un número entero.
1byte variableByte = 12; 2short variableShort = 12; 3int variableInt = 12; 4long variableLong = 12;
Si bien para el caso del tipo long podemos crear literales de enteros que acaben en L (mayúscula o minúscula, aunque por legilibilidad se recomienda la primera)
1long variableLong = 12D;
Hay otros valores que pueden ser manejados por los literales enteros, para cuando representemos el número en diferentes bases. Por ejemplo cuando los manejemos como binarios o hexadecimales. Para este caso habrá que manejar literales de enteros que tengan dicho formato.
1int variableBinaria = 011010; 2int variableHexadecimal = 0x1a;
Literales de decimales Los dos tipos de datos de decimales que podemos manejar son float y double. Para estos casos la representación del literal de decimales serán con separación de un punto entre la parte entera y la parte decimal.
1float variableFloat = 12.2; 2double variableDouble = 12.2;
De igual manera podemos utilizar las letras F o f para el tipo de dato float y D o d para el tipo de dato double. Siempre, por legilibilidad se recomienda la letra en mayúsculas.
1float variableFloat = 12.2F; 2double variableDouble = 12.2D;
Literales de caracteres y cadenas
Tanto los caracteres del tipo de dato char, como las cadenas del tipo de datos String contienen caracteres Unicode UTF-16.
Los caracteres UTF-16 se pueden escribir directamente en la cadena o si nuestro editor de textos no nos permite el manejo de esa codificación los podemos poner escapados en el formato.
1'uCODIGOUNICODE'
Por ejemplo la letra como la ñ se escaparía de la siguiente forma:
1'u00F1'
Para utilizarla en una cadena de texto “España” podríamos poner
1String pais = "Espau00F1a";
Para los caracteres utilizaremos comillas simples para delimitarlos, mientras que para las cadenas utilizaremos comillas dobles.
1char variableChar = ‘a’; 2String variableString = “cadena”;
Como ya hemos comentado Java es un lenguaje de tipado estático. Es decir, se define el tipo de dato de la variable a la hora de definir esta. Es por ello que todas las variables tendrán un tipo de dato asignado.
El lenguaje Java da de base una serie de tipos de datos primitivos.
| Tipo | Posible Valores | Descripción | Valor por defecto |
|---|---|---|---|
| byte | valores numéricos de -128 a 127 (ambos inclusive) | Representa un tipo de dato de 8 bits con signo. De tal manera que puede almacenar los valores numéricos de -128 a 127 (ambos inclusive). | 0 |
| short | valores numéricos de -32.768 a 32.767 | Representa un tipo de dato de 16 bits con signo. De esta manera almacena valores numéricos de -32.768 a 32.767. | 0 |
| int | valores numéricos | Es un tipo de dato de 32 bits con signo para almacenar valores numéricos. Cuyo valor mínimo es -231 y el valor máximo 231-1. | 0 |
| long | valores numéricos entre -263 a 263-1 | Es un tipo de dato de 64 bits con signo que almacena valores numéricos entre -263 a 263-1 | 0L |
| float | Valores numericos | Es un tipo dato para almacenar números en coma flotante con precisión simple de 32 bits. | 0.0f |
| double | Valores numericos | Es un tipo de dato para almacenar números en coma flotante con doble precisión de 64 bits. | 0.0d |
| char | carácter Unicode | Es un tipo de datos que representa a un carácter Unicode sencillo de 16 bits. Nota: el carácter Unicode deben estar encerradas entre comillas simples | 'u0000' |
| String (o cualquier objeto) | Cualquier serie de caracteres | Las cadenas son la única forma en que tenemos que almacenar palabras (series de caracteres). Nota: las cadenas deben estar encerradas entre comillas. | null |
| boolean | true | false | Sirve para definir tipos de datos booleanos. Es decir, aquellos que tienen un valor de true o false. Ocupa 1 bit de información. | false |
Un programa en Java se compone de un conjunto de sentencias que se ejecutan para resolver un problema. Las sentencias son el elemento básico de ejecución de los programa Java.
A parte de las sentencias, en un programa Java nos encontraremos con expresiones y bloques.
Expresiones
Una expresión es un conjunto de variables, operadores e invocaciones de métodos que se construyen para poder ser evaluadas retornando un resultado.
Ejemplos de expresiones son:
1int valor = 1; 2if (valor 1 > valor2) { ... }
Cuando tengamos expresiones de evaluación complejas es recomendable que utilicemos paréntesis para saber cual es el orden de ejecución de operaciones.
Ya que si tenemos una expresión como
12 + 10 / 5
No será la misma si ponemos Ya que si tenemos una expresión como
1(2 + 10) / 5 ó 2 + (10 / 5)
En el caso de no utilizar paréntesis se ejecutará el orden de preferencia de operadores. En este caso la división tiene más preferencia que la suma.
Sentencias
Una sentencia es la unidad mínima de ejecución de un programa. Un programa se compone de conjunto de sentencias que acaban resolviendo un problema. Al final de cada una de las sentencias encontraremos un punto y coma (;).
Tenemos los siguientes tipos de sentencias.
Sentencias de declaración
1int valor = 2;
Sentencias de asignación
1valor = 2;
Sentencias de incremento o decremento
1valor++;
Invocaciones a métodos
1System.out.println("Hola Mundo");
Creaciones de objetos
1Circulo miCirculo = new Circulo(2,3);
Sentencias de control de flujo
1if (valor>1) { … }
Bloques
Un bloque es un conjunto de sentencias los cuales están delimitados por llaves.
1if (expresion) { 2 // Bloque 1 3} else { 4 // Bloque 2 5}
El operador Java más sencillo es el operador de asignación. Mediante este operador se asigna un valor a una variable. El operador de asignación es el símbolo igual.
La estructura del operador de asignación es:
variable = valor;
Así podemos asignar valores a variables de tipo entero, cadena,…
1int numero = 3; 2String cadena = "Hola Mundo"; 3double decimal = 4.5; 4boolean verdad = true;
Los operadores aritméticos en Java son los operadores que nos permiten realizar operaciones matemáticas: suma, resta, multiplicación, división y resto.
Los operadores aritméticos en Java son:
| Operador | Descripción |
|---|---|
| + | Operador de Suma. Concatena cadenas para la suma de String |
| - | Operador de Resta |
| * | Operador de Multiplicación |
| / | Operador de División |
| % | Operador de Resto |
Los operadores aritméticos en Java los utilizaremos entre dos literales o variables y el resultado, normalmente lo asignaremos a una variable o bien lo evaluamos.
variable = (valor1|variable1) operador (valor2|variable2);
Así podemos tener los siguientes usos en el caso de que queramos asignar su valor.
1suma = 3 + 7; // Retorna 10 2resta = 5 - 2; // Retorna 3 3multiplicacion = 3 * 2; // Retorna 6 4division = 4 / 2; // Retorna 2 5resto = 5 % 3; // Retorna 2
Ten en cuenta que pueden ser valores o variables:
1suma = vble1 + 3; // Sumamos 3 al valor de la variable vble1 2resta = vble1 - 4; // Restamos 4 al valor de la variable vble1
O podríamos utilizarlo en una condición
1if (variable > suma + 3) { ... }
En este caso no asignamos el resultado de la suma a una variable, solo lo evaluamos.
Los operadores unarios en Java son aquellos que solo requieren un operando para funcionar.
Los operadores unitarios que tenemos en Java son:
| Operador | Descripción |
|---|---|
| + | Operador unario suma. Indica un número positivo. |
| - | Operador unario resta. Niega una expresión. |
| ++ | Operador de incremento. Incrementa el valor en 1. |
| – | Operador de decremento. Decrementa el valor en 1. |
| ! | Operador de complemento lógico. Invierte el valor de un booleano |
Por ejemplo podríamos tener el siguiente código:
1int valor = 2; 2System.out.println(-valor); // Imprimirá por pantalla un -2
Los operadores de incremento se pueden aplicar como prefijo o como sufijo.
1++ variable; 2variable ++; 3-- variable; 4variable --;
El operador de complemento lógico sirve para negar un valor lógico. Se suele utilizar delante de una operación de evaluación booleana. Normalmente en sentencias de decisión o bucles.
La estructura es:
! (expresion)
Si la expresión era un true la convierte en false y si era false la convierte en true.
Podemos verlo en el siguiente ejemplo:
1int vble1 = 2; 2int vble2 = 3; 3 4if !(vble1 > vble2) 5 System.out.println("variable 1 es más pequeña que la variable 2");
Como podemos observar el valor de la expresión evaluada es convertido.
Los operadores de igualdad y relacionales en Java son aquellos que nos permiten comparar el contenido de una variable contra otra atendiendo a si son variables con un valor igual o distinto o bien si los valores son mayores o menores.
| Operación | Sintaxis | Ejemplos |
|---|---|---|
| Igual a | == | Es 5 == 5? True! Es 5 == 4? False! Es 5 == '5'? True! |
| No Igual a | != | Es 5 != 5? False! Es 5 != '5'? False! Es 1 != 'Hello' True! |
| Mayor que | > | Es 5 > 5? False! Es 6 > 3? True! |
| Menos que | < | Es 6 < 12? True |
| Mayor o igual | >= | Es 6 <= 6? True Es 3 <= 6? True |
| Menor o igual | <= | Tienes la idea 🙂 |
Los operadores condicionales en Java son aquellos que evalúan dos expresiones booleanas.
| Operación | Sintaxis | Ejemplos |
|---|---|---|
| AND | && | Con AND, ambos lados TIENEN QUE SER TRUE para que todo se convierta en realidad. Es (5 == 5 && 3 > 1) ? True! Es ('Ramon' == 'Pedro' && 2 == 2) ? False! |
| OR | || | Es ('Oscar' != 'Maria' OR 2 != 2)? True! Es (5 == '5' AND 'Ramon' != 'Pedro') OR (2 == 2)? True! |
| NOT | ! | NOT será exactamente lo contrario del resultado del operador lógico: Es !(5 > 5)? True! Is !(True)? False! |
| Temerario | ?: | con operador temerario podras hacer condiciones en una sola linea (5 == 5) ? 5 :0 |
Bien, ahora es cuando todo empieza a ponerse divertido! Para controlar el flujo de tu aplicación, tendrás varias opciones y las utilizarás cada día. Por lo tanto, debes sentirte cómodo usándolas.
Un programa en Java se ejecuta en orden desde la primera sentencia hasta la última.
Si bien existen las sentencias de control de flujo las cuales permiten alterar el fujo de ejecución para tomar decisiones o repetir sentencias.
Dentro de las sentencias de control de flujo tenemos las siguientes:
Son sentencias que nos permiten tomar una decisión para poder ejecutar un bloque de sentencias u otro.
Las sentencias de decisión son: if-then-else y switch.
Mediante if-then-else podremos evaluar una decisión y elegir por un bloque u otro.
1if (expresion) { 2 // Bloque then 3} else { 4 // Bloque else 5}
Mientras que con switch podremos evaluar múltiples decisiones y ejecutar un bloque asociado a cada una de ellas.
1switch (expresion) { 2 case valor1: 3 bloque1; 4 break; 5 case valor2: 6 bloque2; 7 break; 8 case valor3: 9 bloque3; 10 break; 11 … 12 default: 13 bloque_por_defecto; 14}
Usa
switchen lugar deifcuando:
• Estás comparando varias condiciones posibles de una expresión y la expresión en sí no es trivial. • Tienes múltiples valores que pueden requerir el mismo código .
• Tienes algunos valores que requerirán esencialmente toda la ejecución de otro valor, más solo unas pocas declaraciones.
Utilizaifen lugar deswitchcuando:
• Deseas probar la veracidad de una expresión.
• Solo tienes una única prueba afirmativa.
• Necesitas evaluar diferentes expresiones para cada rama.
Las sentencias de bucle nos van a permitir ejecutar un bloque de sentencias tantas veces como queramos, o tantas veces como se cumpla una condición.
En el momento que se cumpla esta condición será cuando salgamos del bucle.
Las sentencias de bucle en Java son: while, do-while y for.
En el caso de la sentencia while tenemos un bucle que se ejecuta mientas se cumple la condición, pero puede que no se llegue a ejecutar nunca, si no se cumple la condición la primera vez.
1while (expresion) { 2 bloque_sentencias; 3}
Por otro lado, si utilizamos do-while, lo que vamos a conseguir es que el bloque de sentencias se ejecute, al menos, una vez.
1do { 2 bloque_sentencias; 3} while (expresion)
La sentencia for nos permite escribir toda la estructura del bucle de una forma más acotada. Si bien, su cometido es el mismo.
1for (sentencias_inicio;expresion;incremento) { 2 bloque_sentencias; 3}
For Extendido o bucles for each
En las últimas versiones de Java se introdujo una nueva forma de uso del for, a la que se denomina “for extendido” o “for each”. Esta forma de uso del for, que ya existía en otros lenguajes, facilita el recorrido de objetos existentes en una colección sin necesidad de definir el número de elementos a recorrer. La sintaxis que se emplea es:
1 for (TipoARecorrer nombreVariableTemporal : nombreDeLaColección ) { 2 Instrucciones; 3 }
Las sentencias de ramificación son aquellas que nos permiten romper con la ejecución lineal de un programa.
El programa se va ejecutando de forma lineal, sentencia a sentencia. Si queremos romper esta linealidad tenemos las sentencias de ramificación.
Las sentencias de ramificación en Java son: break y continue.
En el caso de break nos sirve para salir de bloque de sentencias, mientras que continue sirve para ir directamente al siguiente bloque.
Java es mas que otro lenguaje de programacion con instrucciones divertidas que podemos ir descubriendo duranto a lo largo del curso