Diferencias

Muestra las diferencias entre dos versiones de la página.

--- bloque2:tiposvariables [03/03/2018 16:19] – [Tipos de Datos en Java] Fernando Valdeón
+++ bloque2:tiposvariables [16/09/2024 20:53] (actual) – editor externo 127.0.0.1
@@ Línea 8: / Línea 8: @@
 Cada dato se define con un tipo específico, y se puede gestionar de una forma concreta a ese tipo, o en algunos casos convertirlos a otros tipos que sean semejantes.
  ===== Tipos de Datos en Java =====
 Java tiene infinidad de tipos de datos para poder ofrecer un manejo más potente de cada uno de ellos.
-Pero hay una clasificación general en cuanto a sus tipos:
+Desde el punto de vista más general, en Java solo hay 2 tipos de datos:
   * Tipos de ''datos primitivos''
   * Tipos de ''datos de referencia'' a Objetos, o simplemente ''Objetos''.
+Solo hay 8 ''tipos primitivos'': son muy fáciles de reconocer. Así que, **todo lo que no es un tipo primitivo, sin lugar a dudas, es un ''objeto''**.
+ ===== Tipos de datos primitivos =====
+Estos tipos de datos son más sencillos de usar, más rápidos, y más ligeros. Solo existen 8 tipos de primitivos:
+^Tipo primitivo^ Valor^
+|int| números enteros con 4000 millones de valores|
+|byte| números enteros con 256 valores|
+|short| números enteros con 65000 valores|
+|long| numeros enteros largos, por encima de los 4000 millones de valores|
+|float| decimales con coma flotante, precisión simple|
+|double| decimales con coma flotante, precisión doble|
+|boolean| valor binario, verdadero o falso|
+|char| un caracter, 65000 valores|
+  * **Tipos Enteros**
+    * ''byte'' 8 bits (1 byte)
+    * ''short'' 16 bits (2 bytes)
+    * ''int'' 32 bits (4 bytes)
+    * ''long'' 64 bits (8 bytes)
+Representan los números enteros: negativos, positivos y el 0. Dependiendo del tamaño valor que queramos representar usaremos uno u otro. Están codificados mediante [[https://es.wikipedia.org/wiki/Complemento_a_dos|complemento a dos]]
+El más usado es el tipo ''int''.
+  * **Tipos Reales **
+Representan los números reales, con coma flotante.
+     * ''float'' 32 bits (4 bytes)
+     * ''double'' 64 bits (8 bytes)
+Representan los números decimales o con notación científica:
+<code>
+.14
+.5E12 -> 2,5 * 10 elevado a 12
+E-5 -> 2 * 10 elevado a -5
+</code>
+Están codificados mediante el estándar [[https://es.wikipedia.org/wiki/Formato_en_coma_flotante_de_doble_precisi%C3%B3n|IEEE 754]]
+  * **Tipo Booleano**
+Representan el valores binarios mediante el dominio: ''true/false''
+  * **Tipo Caracter **
+Representan un único caracter, usando 16 bits, usando codificación ''unicode''. Los 256 primeros caracteres ''unicode'' corresponden con la tabla ASCII.
+ ==== Dominio de tipos primitivos ====
+{{ :bloque2:tiposjava.png?600 |}}
- ==== Tipos de datos primitivos ====
- ===== Caracteres de escape =====
  ===== Variables =====
- === Definición de una variable ===
+Las variables son las estructuras en las que almacenamos cada uno de los valores que tenemos en Java. Cada variable se crea para un tipo de datos concreto, ya sea ''primitivo'' o de ''referencia a objetos''.
- === Declaración de una variable ===
- === Inicialización de una variable ===
+Representan un lugar de la memoria del ordenador, y se accede a ella mediante un nombre ''identificador''. En memoria ocupan el tamaño necesario para el __tipo de datos__ que contiene.
- ===== Literales =====
+ ==== Declaración de una variable ====
+__Declarar una variable__ es el acto de crear una variable. En Java, tan solo tenemos que poner el ''tipo de datos'' de la variable seguido del ''identificador'', separados por un espacio.
+**Una variable se crea una sola vez por programa, pero se puede usar muchas veces**.
+<code java>
+//Variables de tipo primitivo
+int variableEntera;
+char letra;
+boolean respuesta;
+double numeroDecimal;
+//Variables de referencia a objetos
+Scanner objetoLectura;
+String palabra;
+File fichero;
+</code>
+**Se debe evitar declarar varias variables en la misma linea**.
+ ==== Inicialización de una variable ====
+El concepto de __inicializar una variable__ significa asignarle un valor por primera vez en el programa.
+Una variable puede inicializarse en el momento de su declaración (creación) o en un momento posterior.
+<code java>
+//Tipos primitivos
+int numero = -3456;
+int double = 4.34;
+boolean valor;
+valor = false;
+char letra;
+letra = 'a';
+//Objetos
+String cadena = "hola";
+File fichero = new File();
+</code>
+===== Constantes =====
+Las ''constantes'' son un tipo de variable que impide modificar su valor. Se usan cuando tenemos variables que sabemos que no van a cambiar su valor.
+Se definen al principio de la clase, antes del método ''main()''. Una variable la hacemos constante mediante el uso de dos palabras reservadas: ''static'' y ''final''.
+<code java>
+public class MiClase{
+   static final int LIMITE_VELOCIDAD = 120;
+   static final String SALUDO = "Hola Mundo";
+   public static void main(String[] args){
+      //código de mi programa
+   }
+}
+</code>
+Sus identificadores se escriben en ''CONSTANT_CASE'': solo mayúsculas y barra baja para separar palabras.
+ ===== Valores Literales =====
+Los valores literales es un aspecto un ligado a ciertos tipos de datos, que suele costar entender al principio. El problema surge al comprender cómo traducir valores de nuestra realidad (pensamientos) a la realidad de la máquina (código binario).
+**Un valor literal es simplemente la representación del valor de un tipo de datos concreto de Java mediante código escrito**.
+==== Literales de enteros ====
+Todo nº entero escrito en el código de java es la representación literal de un tipo ''int''.
+Para los literales de tipo ''long'' debo indicar el caracter ''L'' a continuación del nº entero.
+Los tipos ''byte'' y ''short'' no tienen representación literal, pero se usa un literal de tipo ''int'' que no supere el tamaño del tipo.
+<code java>
+int numero = 345;
+numero = -2345665;
+long enteroLargo = 345L;
+enteroLargo = -234535234523L
+byte numeroByte = 120;
+short numeroShort = 1034;
+</code>
+==== Literales de reales ====
+Todo nº decimal o con notación científica representa un ''double''.
+Para representar un valor literal de un tipo ''float'' debo indicar el caracter ''F'' a continuación del nº.
+<code java>
+// 3.345 ó 3.1E12 son literales double
+double realDoble = 3.345;
+realDoble = 3.1E124; // 3.1 x 10^124
+float realSimple = 3.345;  -> Error de compilación, no es un float
+realSimple = 3.345F;
+realSimple = 3.1E-121F;  // 3.1 x 10^-121
+</code>
+==== Literales booleanos ====
+Para representar los valores booleano en el código tenemos únicamente los valores ''true'' y ''false'';
+<code java>
+boolean valor = true;
+valor = false;
+</code>
+==== Literales de caracter ====
+Los literales de caracter representan el valor de un solo caracter, aunque eso no quiere decir que se representen con un solo caracter.
+Un solo caracter rodeado de comillas simples ''''' representa un tipo ''char''.
+<code java>
+char letra = 'a';
+letra = ' ';  // caracter espacio en blanco
+letra = '9';
+</code>
+=== Caracteres de escape ===
+Dentro de los literales de tipo caracter tenemos una serie de caracteres que no se pueden representar de forma escrita: las tabulaciones, los saltos de linea, las comillas dobles o simples, etc.
+Para poder representar esos caracteres, se usa lo que se conoce como ''caracteres de escape''
+^Caracter de escape^Descripción^
+|\n|Salto de linea|
+|\t|Una tabulación|
+|\b|Retroceder un caracter|
+|\r|Retorno de carro|
+|\'|Comilla simple|
+|\"|Comilla doble|
+|\\|Contrabarra|
+<code java>
+char saltoLinea = '\n';
+char tabulacion = '\t';
+</code>
+==== Literales de cadenas de caracteres ====
+El tipo de datos String representa cadenas de caracteres, pero no es un tipo primitivo, sino un objeto.
+Su valor literal consiste en una seria de 0 ó más caracteres dentro de comillas dobles ''"'';
+<code java>
+String nombre = "Fernando";
+nombre = "Maria";
+nombre = "";  // cadena de 0 caracteres
+</code>
 ----
 (c) {{date> %Y}} Fernando Valdeón