¡Descarga Ejemplos de java para java basico desde cero a nivel intermedio y más Apuntes en PDF de Programación Java solo en Docsity!
PRÓLOGO
Introducción
Java a través de ejemplos presenta los conceptos básicos del lenguaje de programación Java y muestra sus posibilidades más relevantes para el desarrollo de aplicaciones. El libro se centra en la explicación detallada de los fundamentos del lenguaje, evitando los temas de carácter especializado.
La didáctica de esta publicación se basa en el aprendizaje guiado mediante ejemplos comentados y gráficos de apoyo a las explicaciones, evitándose las aclaraciones puramente teóricas y el uso de un nivel de detalle excesivo en la información suministrada.
Este libro, por tanto, resulta especialmente adecuado para los lectores que no poseen unos conocimientos previos del lenguaje o para aquellos cuyo principal objetivo es adquirir los fundamentos de Java para, posteriormente, poder afrontar con una base sólida el aprendizaje de aspectos específicos tales como las comunicaciones, acceso a bases de datos, presentaciones multimedia, etc.
Se incluyen dos apéndices con más de 500 preguntas y sus respuestas basadas en los conceptos fundamentales de Java. Estas cuestiones permiten que el lector pueda comprobar la corrección y completitud con los que va asimilando las diferentes materias.
Los contenidos del libro se han dividido en 9 capítulos que contienen 38 lecciones; cada una de estas lecciones forma una unidad de estudio que conviene afrontar de manera individualizada. Para facilitar la comprensión de estas unidades, las lecciones se han diseñado con un tamaño reducido: de unas 8 páginas por término medio.
En el siguiente apartado se presenta una relación de las lecciones, agrupadas en capítulos y con la referencia del número de página donde comienza cada una.
XIV JAVA A TRAVÉS DE EJEMPLOS JESÚS BOBADILLA SANCHO ([email protected])
Lecciones incluidas en la publicación
Capítulo 1: toma de contacto, variables, tipos de datos y operadores
LECCIÓN 1: Instalación del entorno de desarrollo LECCIÓN 2: Primer programa en java: “Hola mundo” LECCIÓN 3: Variables y tipos de datos LECCIÓN 4: Operadores
Capítulo 2: estructuras de control
LECCIÓN 5: El bucle FOR LECCIÓN 6: El bucle WHILE LECCIÓN 7: La instrucción condicional IF LECCIÓN 8: La instrucción condicional SWITCH LECCIÓN 9: Ejemplos
Capítulo 3: métodos y estructuras de datos
LECCIÓN 10: Métodos LECCIÓN 11: Strings LECCIÓN 12: Matrices (arrays, vectores) LECCIÓN 13: Ejemplos de programación
Capítulo 4: programación orientada a objetos usando clases
LECCIÓN 14: Definición de clases e instancias LECCIÓN 15: Sobrecarga de métodos y constructores LECCIÓN 16: Ejemplos LECCIÓN 17: Clases utilizadas como Parámetros LECCIÓN 18: Propiedades y métodos de clase y de instancia LECCIÓN 19: Paquetes y atributos de acceso LECCIÓN 20: Ejemplo: máquina expendedora
Capítulo 5: programación orientada a objetos usando herencia
LECCIÓN 21: Herencia LECCIÓN 22: Ejemplos LECCIÓN 23: Polimorfismo LECCIÓN 24: Clases abstractas e interfaces
Capítulo 6: excepciones
LECCIÓN 25: Excepciones predefinidas LECCIÓN 26: Excepciones definidas por el programador
Capítulo 7: interfaz gráfico de usuario
LECCIÓN 27: Creación de ventanas LECCIÓN 28: Paneles y objetos de disposición ( layouts ) LECCIÓN 29: Etiquetas, campos y áreas de texto LECCIÓN 30: Cajas de verificación, botones de radio y listas
XVI JAVA A TRAVÉS DE EJEMPLOS JESÚS BOBADILLA SANCHO ([email protected])
El diagrama presentado en la página anterior nos muestra la secuencia de las lecciones contenidas en el libro. El estudio de las lecciones que presentan fondo de color blanco es importante para conseguir un nivel adecuado de conocimientos en el lenguaje Java.
Las lecciones del gráfico que tienen fondo gris pueden ser omitidas en caso de necesidad; esto es posible debido a que se corresponden con ejercicios de consolidación de los temas anteriores o porque se refieren a características del lenguaje que se utilizan con menos frecuencia. En cualquier caso, el estudio de estas lecciones resulta importante para conseguir una mejor asimilación de los conceptos explicados, por lo que es muy conveniente acudir a ellas una vez comprendidas las lecciones que les preceden.
Los cuadrados grises contienen lecciones que pueden ser abordadas en cualquier orden, por ejemplo, después de la lección 10, podemos estudiar en primer lugar la 12 y después la 11 o viceversa.
Esperamos que estas indicaciones puedan ayudar a ahorrar tiempo a los lectores que desean estudiar en primer lugar las características más relevantes del lenguaje, pudiendo profundizar posteriormente en dichos conceptos y en algún otro menos utilizado en la programación general.
ÍNDICE
PRÓLOGO ......................................................................................... XIII
JESÚS BOBADILLA SANCHO ([email protected]) ÍNDICE IX
B: SOLUCIONES A LAS CUESTIONES DE AUTOEVALUACIÓN
- DATOS Y OPERADORES CAPÍTULO 1: TOMA DE CONTACTO, VARIABLES, TIPOS DE
- 1.1 Instalación del entorno de desarrollo................................... ........................................
- 1.2 Primer programa en java: “Hola mundo”........................................................................
- 1.3 Variables y tipos de datos................................................................................................... - 1.3.1 Variables ...................................................................................................................... - 1.3.2 Tipos de datos............................................................................................................. - 1.3.3 Tipos numéricos enteros ......................................................................................... - 1.3.4 Tipos numéricos decimales .................................................................................... - 1.3.5 Tipo booleano........................................................................................................... - 1.3.6 Tipo carácter ............................................................................................................. - 1.3.7 Conversión exp lícita de tipos (Casting)...............................................................
- 1.4 Operadores .......................................................................................................................... - 1.4.1 Introducción.............................................................................................................. - 1.4.2 Operadores aritméticos............................................................................................ - 1.4.3 Operadores lógicos .................................................................................................. - 1.4.4 Operadores de comparación...................................................................................
- CAPÍTULO 2: ESTRUCTURAS DE CONTROL
- 2.1 El bucle FOR ......................................................................................................................
- 2.1.1 Sintaxis .......................................................................................................................
- 2.1.2 Ejemplos de aprendizaje ..........................................................................................
- 2.1.3 Situaciones erróneas.................................................................................................
- 2.1.4 Ejemplos de resolución de problemas...................................................................
- 2.2 El bucle WHILE ................................................................................................................
- 2.2.1 Sintaxis .......................................................................................................................
- 2.2.2 Ejemplos de aprendizaje.......................................................................................... VIII JAVA A TRAVÉS DE EJEMPLOS JESÚS BOBADILLA SANCHO ([email protected])
- 2.2.3 Ejemplos de resolución de problemas...................................................................
- 2.3 La instrucción condicional IF..........................................................................................
- 2.3.1 Sintaxis .......................................................................................................................
- 2.3.2 Ejemplos de aprendizaje..........................................................................................
- 2.3.3 If anidados.................................................................................................................
- 2.3.4 Situaciones erróneas.................................................................................................
- 2.3.5 Ejemplo de resolución de problemas ....................................................................
- 2.4 La instrucción condicional SWITCH.............................................................................
- 2.4.1 Sintaxis .......................................................................................................................
- 2.4.2 Ejemplos de aprendizaje..........................................................................................
- 2.4.3 Switch anidados........................................................................................................
- 2.4.4 Situaciones erróneas.................................................................................................
- 2.4.5 Ejemplo de resolución de problemas ....................................................................
- 2.5 Ejemplos..............................................................................................................................
- 2.5.1 Cálculo de la hipotenusa de un triángulo .............................................................
- 2.5.2 Punto de corte de dos rectas situadas en el espacio bidimensional..................
- 2.5.3 Soluciones de una ecuación de segundo grado...................................................
- CAPÍTULO 3: MÉTODOS Y ESTRUCTURAS DE DATOS
- 3.1 Métodos...............................................................................................................................
- 3.1.1 Sintaxis ......................................................................................................................
- 3.1.2 Ejemplo 1...................................................................................................................
- 3.1.3 Resultados del ejemplo 1........................................................................................
- 3.1.4 Ejemplo 2...................................................................................................................
- 3.1.5 Resultados del ejemplo 2........................................................................................
- 3.1.6 Paso de argumentos por valor y por referencia ...................................................
- 3.2 Strings..................................................................................................................................
- 3.2.1 Sintaxis ......................................................................................................................
- 3.2.2 Ejemplo básico..........................................................................................................
- 3.2.3 Resultado...................................................................................................................
- 3.2.4 Ejemplo de utilización de la clase String .............................................................
- 3.2.5 Resultados..................................................................................................................
- 3.3 Matrices (arrays, vectores)...............................................................................................
- 3.3.1 Sintaxis ......................................................................................................................
- 3.3.2 Acceso a los datos de una matriz..........................................................................
- 3.3.3 Ejemplo 1...................................................................................................................
- 3.3.4 Resultados del ejemplo 1 ........................................................................................
- 3.3.5 Ejemplo 2...................................................................................................................
- 3.3.6 Resultados del ejemplo 2 ........................................................................................
- 3.3.7 Ejemplo ......................................................................................................................
- 3.4 Ejemplos de programación...............................................................................................
- 3.4.1 Obtención de números primos ...............................................................................
- 3.4.2 “Revienta claves”.....................................................................................................
- 3.4.3 Estadísticas................................................................................................................
- USANDO CLASES CAPÍTULO 4: PROGRAMACIÓN ORIENTADA A OBJETOS
- 4.1 Definición de clases e instancias..................................................................................... - 4.1.1 Sintaxis ....................................................................................................................... - 4.1.2 Representación gráfica ............................................................................................ - 4.1.3 Instancias de una clase............................................................................................. - 4.1.4 Utilización de los métodos y propiedades de una clase..................................... - 4.1.5 Ejemplo completo .................................................................................................... - 4.1.6 Resultado...................................................................................................................
- 4.2 Sobrecarga de métodos y constructores ......................................................................... - 4.2.1 Sobrecarga de métodos............................................................................................ - 4.2.2 Ejemplo ...................................................................................................................... - 4.2.3 Resultado ................................................................................................................... - 4.2.4 Constructores.............................................................................................................
- 4.3 Ejemplos.............................................................................................................................. - 4.3.1 Figura genérica ......................................................................................................... - 4.3.2 Agenda de teléfono .................................................................................................. - 4.3.3 Ejercicio de logística.............................................................................................
- 4.4 Clases utilizadas como Parámetros.............................................................................. - 4.4.1 Código - 4.4.2 Resultados...............................................................................................................
- 4.5 Propiedades y métodos de clase y de instancia - 4.5.1 Propiedades de instancia - 4.5.2 Propiedades de clase............................................................................................. - 4.5.3 Métodos de instancia - 4.5.4 Métodos de clase................................................................................................... - 4.5.5 Ejemplo que utiliza propiedades de clase......................................................... - 4.5.6 Código del ejemplo - 4.5.7 Resultados...............................................................................................................
- 4.6 Paquetes y atributos de acceso..................................................................................... - 4.6.1 Definición de paquetes - 4.6.2 Utilización de las clases de un paquete.............................................................. - 4.6.3 Proceso de compilación cuando se utilizan paquetes - 4.6.4 Atributos de acceso a los miembros (propiedades y métodos) de una clase
- 4.7 Ejemplo: máquina expendedora - USANDO HERENCIA.............................................. CAPÍTULO 5: PROGRAMACIÓN ORIENTADA A OBJETOS
- 5.1 Herencia............................................................................................................................ - 5.1.1 Funcionamiento básico......................................................................................... - 5.1.2 Accesibilidad a los miembros heredados en una subclase............................. - 5.1.3 Constructores de las subclases - 5.1.4 El modificador final..............................................................................................
- 5.2 Ejemplos........................................................................................................................... - 5.2.1 Figuras geométricas X JAVA A TRAVÉS DE EJEMPLOS JESÚS BOBADILLA SANCHO ([email protected]) - 5.2.2 Vehículos................................................................................................................
- 5.3 Polimorfismo - 5.3.1 Conceptos............................................................................................................... - 5.3.2 Ejemplo
- 5.4 Clases abstractas e interfaces........................................................................................ - 5.4.1 Métodos abstractos................................................................................................ - 5.4.2 Clases abstractas - 5.4.3 Interfaces.................................................................................................................
- CAPÍTULO 6: EXCEPCIONES
- 6.1 Excepciones predefinidas - 6.1.1 Introducción - 6.1.2 Sintaxis y funcionamiento con una sola excepción - 6.1.3 Ejemplo con una sola excepción......................................................................... - 6.1.4 Sintaxis y funcionamiento con más de una excepción - 6.1.5 El bloque finally - 6.1.6 Propagación de excepciones................................................................................ - 6.1.7 Estado de una excepción
- 6.2 Excepciones definidas por el programador - 6.2.1 Introducción - 6.2.2 Definición de una excepción definida por el programador............................ - 6.2.3 Utilización de una excepción definida por el programador - 6.2.4 Ejemplo
- CAPÍTULO 7: INTERFAZ GRÁFICO DE USUARIO
- 7.1 Creación de ventanas...................................................................................................... - 7.1.1 Introducción - 7.1.2 Utilización de la clase Frame - 7.1.3 Creación y posicionamiento de múltiples ventanas........................................
- 7.2 Paneles y objetos de disposición ( layouts )................................................................. - 7.2.1 Introducción - 7.2.2 Utilización básica de paneles - 7.2.3 Objeto de disposición (Layout): FlowLayout................................................... - 7.2.4 Objeto de disposición (Layout): BorderLayout - 7.2.5 Objeto de disposición (Layout): GridLayout....................................................
- 7.3 Etiquetas, campos y áreas de texto - 7.3.1 Introducción - 7.3.2 Etiqueta (Label) - 7.3.3 Campo de texto (TextField)................................................................................. - 7.3.4 Área de texto (TextArea)..................................................................................... - 7.3.5 Fuentes (Font)........................................................................................................
- 7.4 Cajas de verificación, botones de radio y listas......................................................... JESÚS BOBADILLA SANCHO ([email protected]) ÍNDICE XI
- 7.4.1 Introducción
- 7.4.2 Cajas de verificación (Checkbox)
- 7.4.3 Botones de radio (CheckboxGroup)...................................................................
- 7.4.4 Lista (List)..............................................................................................................
- 7.4.5 Lista desplegable (Choice)...................................................................................
- 7.5 Diseño de formularios....................................................................................................
- 7.5.1 Diseño del interfaz gráfico deseado...................................................................
- 7.5.2 Implementación en una sola clase......................................................................
- 7.5.3 Implementación en varias clases.........................................................................
- 7.6 Diálogos y menús
- 7.6.1 Introducción
- 7.6.2 Diálogo (Dialog)....................................................................................................
- 7.6.3 Diálogo de carga / almacenamiento de ficheros (FileDialog)
- 7.6.4 Menús (Menu y MenuBar)
- CAPÍTULO 8: EVENTOS
- 8.1 Mecanismo de eventos en java.....................................................................................
- 8.1 Introducción...............................................................................................................
- 8.2 Arquitectura de los eventos.....................................................................................
- 8.3 Interfaces que soportan el mecanismo de eventos..............................................
- 8.4 Esquema general de programación........................................................................
- 8.2 Eventos de ratón y de movimiento de ratón...............................................................
- 8.2.1 Introducción
- 8.2.2 Eventos de ratón....................................................................................................
- 8.2.3 Eventos de movimiento de ratón
- 8.3 Eventos de teclado y de ventana..................................................................................
- 8.3.1 Introducción
- 8.3.2 Eventos de teclado.................................................................................................
- 8.3.3 Eventos de ventana................................................................................................
- 8.4 Eventos de acción, enfoque y elemento......................................................................
- 8.4.1 Introducción
- 8.4.2 Eventos de acción..................................................................................................
- 8.4.3 Eventos de enfoque...............................................................................................
- 8.4.4 Eventos de elemento.............................................................................................
- CAPÍTULO 9: APLICACIONES DE EJEMPLO
- 9.1 Ejemplo: calculadora
- 9.1.1 Definición del ejemplo
- 9.1.2 Diseño del interfaz gráfico de usuario
- 9.1.3 Implementación del interfaz gráfico de usuario
- 9.1.4 Diseño del tratamiento de eventos......................................................................
- 9.1.5 Implementación de las clases de tratamiento de eventos................................
- 9.1.6 Diseño del control................................................................................................. XII JAVA A TRAVÉS DE EJEMPLOS JESÚS BOBADILLA SANCHO ([email protected])
- 9.1.7 Implementación del control.................................................................................
- 9.2 Ejemp lo: editor................................................................................................................
- 9.2.1 Definición del ejemplo
- 9.2.2 Estructura de la aplicación...................................................................................
- 9.2.3 Propiedades de la clase.........................................................................................
- 9.2.4 Constructores..........................................................................................................
- 9.2.5 Método PreparaMenus..........................................................................................
- 9.2.6 Método PreparaZonaInferior...............................................................................
- 9.2.7 Clase Colores
- 9.2.8 Tratamiento de las opciones de menú................................................................
- 9.2.9 Tratamiento de las opciones “Buscar” y “Reemplazar”
- 9.2.10 Tratamiento de los botones de radio “Color texto” y “Color fondo”.........
- 9.2.11 Tratamiento a las pulsaciones de los botones de colores.............................
- A: CUESTIONES DE AUTOEVALUACIÓN APÉNDICES
- ÍNDICE ALFABÉTICO
CAPÍTULO 1
TOMA DE CONTACTO, VARIABLES,
TIPOS DE DATOS Y OPERADORES
1.1 INSTALACIÓN DEL ENTORNO DE DESARROLLO
Para poder realizar programas en lenguaje Java es necesario disponer de un mínimo de herramientas que nos permitan editar, compilar e interpretar el código que diseñamos. Para escribir físicamente los programas podemos utilizar cualquier editor de texto (por ejemplo el bloc de notas , el WordPad , etc.). Para compilar y ejecutar los programas existen dos opciones:
- Utilizar un entorno integrado de desarrollo (por ejemplo JBuilder de Borland , Visual J++ de Microsoft , etc.)
- Emplear el software básico de desarrollo (SDK) de Sun Microsystems
La primera opción resulta especialmente interesante para afrontar la creación de aplicaciones de manera eficiente, puesto que estos entornos facilitan enormemente el diseño, escritura y depuración de los programas. La segunda opción es mucho más adecuada para aprender a programar en Java, porque no existe la generación automática de código que incorporan los entornos integrados de desarrollo.
El SDK de Sun Microsystems puede ser obtenido de forma gratuita (es un software de libre distribución) en la dirección www.sun.com; una vez que se dispone del fichero con el SDK (por ejemplo j2sdk-1_4_0-win.exe ) basta con ejecutarlo para conseguir que el software se instale en su ordenador.
En primer lugar se descomprime automáticamente la información:
BOBADILLA CAPÍTULO 1: CONCEPTOS BÁSICOS, VARIABLES, TIPOS DE DATOS Y OPERADORES 3
Sun Microsystems proporciona, además, ayuda en línea sobre las características del lenguaje y las clases más comunes para el desarrollo de aplicaciones. Escribiendo programas en Java resulta necesario instalar esta ayuda para poder consultar los métodos y clases disponibles. La ayuda puede ser obtenida en Internet a través del sitio Web de Sun ( www.sun.com ). Una vez instalada, se accede a ella a través de su página principal ( index.html ).Para escribir programas en Java, el enlace más importante de esta página es: Java 2 Platform API Specification , correspondiente al apartado API & Language Documentation.
El software de desarrollo SDK funciona en modo texto sobre una ventana de consola del sistema operativo. En Windows, para acceder a la consola se debe pulsar sobre el símbolo de MS-DOS (habitualmente accesible a través del botón de Inicio ). Una vez en la consola, dirigirse al directorio de trabajo (en el ejemplo C:\CursoJava\Introducción ), tal y como aparece en la siguiente figura:
Podemos configurar la consola en cuanto al tamaño con el que aparece, memoria que utiliza, fuentes que emplea, etc. Para realizar esta configuración basta con acceder al símbolo de MS-DOS y, en lugar de pulsar con el botón izquierdo del ratón, hacerlo con el derecho y seleccionar Propiedades.
4 JAVA A TRAVÉS DE EJEMPLOS JESÚS BOBADILLA SANCHO ([email protected])
En concreto, nos interesa seleccionar la solapa Programa y variar el valor del campo de texto Carpeta de trabajo , introduciendo el directorio sobre el que solemos trabajar, con ello conseguimos que la consola se abra directamente en ese directorio. En nuestro ejemplo, hemos introducido el valor C:\CursoJava\Introducción.
Como veremos en el siguiente apartado, el fichero javac.exe es el compilador de java. Se encuentra en el directorio c:\j2sdk1.4.0\bin (hacia donde hemos apuntado la variable PATH ). Si todo se encuentra correctamente al invocar el compilador sin parámetros nos indica la forma de uso correcta, tal y como aparece en la siguiente figura:
6 JAVA A TRAVÉS DE EJEMPLOS JESÚS BOBADILLA SANCHO ([email protected])
situada en la línea 4. Únicamente contiene la instrucción situada en la línea 3, que imprime el literal (texto) que aparece entre comillas y como parámetro de la llamada al método println. Obsérvese el carácter ‘;’ que se debe utilizar obligatoriamente para separar instrucciones.
El sangrado de cada una de las líneas no es necesario, pero resulta muy conveniente para hacer más legible los programas. Su función principal es facilitar la identificación visual de cada bloque de código.
3 Grabar el código en el fichero HolaMundo.java y con formato de texto
Es absolutamente necesario que la extensión sea .java , que el fichero este grabado con formato de texto y que el nombre de la clase coincida EXACTAMENTE con el nombre del fic hero (en nuestro caso HolaMundo ). Finalmente, en el WordPad nos quedará una ventana similar a la siguiente:
4 Compilar el programa
En la ventana de MS-DOS, en el directorio donde hemos grabado el fichero HolaMundo.java , debemos ejecutar el compilador ( javac ) poniendo como argumento el nombre del fichero CON LA EXTENSIÓN .java ( javac HolaMundo.java ). Si existen errores, se obtendrá un listado de los mismos. Si no los hay, como en nuestro caso, no aparece nada:
BOBADILLA CAPÍTULO 1: CONCEPTOS BÁSICOS, VARIABLES, TIPOS DE DATOS Y OPERADORES 7
Tras la compilación con éxito del programa, obtenemos el fichero objeto HolaMundo.class :
5 Ejecutar el programa En el directorio en el que estamos trabajando, ejecutar el intérprete de java ( java ) suministrando como parámetro el nombre de la clase ( HolaMundo ) SIN la extensión .class ( java HolaMundo ). Nos aparecerá el texto “Hola Mundo” correspondiente a la impresión de datos por consola que codificamos en la línea 3 de nuestro programa:
1.3 VARIABLES Y TIPOS DE DATOS
1.3.1 Variables
Las variables se utilizan para almacenar datos asociados a nombres. Cada variable tiene un nombre que sirve de referencia para introducir datos o acceder a los
BOBADILLA CAPÍTULO 1: CONCEPTOS BÁSICOS, VARIABLES, TIPOS DE DATOS Y OPERADORES 9
$Ganado → identificador correcto
public → identificador incorrecto, public es un nombre reservado por el lenguaje
Los identificadores deben intentar ser representativos de los datos que albergan, de esta manera ValorAcumulado, NumeroAlumnos, CantidadEuros, Edad, Potencia son variables que determinan de forma adecuada el significado de sus contenidos, mientras que los nombres Variable, Valor, V1, V2 , no son representativos de sus contenidos.
La longitud de los identificadores no debe ser excesivamente larga, para no dificultar la legibilidad de las instrucciones, por ejemplo resulta mucho más legible Stock = LibrosEditados – LibrosVendidos , que StockTotalDeLibrosEnAlmacen = LibrosEditadosEnElAñoEnCurso – LibrosVendidosYSacadosDelAlmacen.
Los identificadores en mayúsculas se suelen reservar para nombres (normalmente cortos) de constantes, de esta manera las instrucciones (basadas mayoritariamente en operaciones con variables) son más legibles, al utilizarse minúsculas. Compárese Stock = LibrosEditados – LibrosVendidos con STOCK = LIBROSEDITADOS – LIBROSVENDIDOS.
1.3.2 Tipos de datos
Las variables albergan datos de diferentes tipos (numérico decimal, numérico entero, caracteres, etc.). Para indicar el tipo de dato que contendrán las variables debemos “declarar” las mismas, indicando sus tipos. Este mecanismo permite que el traductor (compilador) realice comprobaciones estáticas de validez, como por ejemplo que no empleamos en el programa una variable que no ha sido declarada, que no asignemos un carácter a una variable de tipo numérico, que no sumemos un carácter a un valor numérico, etc.
A continuación se establece una relación de los tipos de datos primitivos (los que proporciona el lenguaje):
TIPOS PRIMITIVOS Nombre del tipo Tamaño en bytes Rango Tipos numéricos enteros byte 1 -128 a 127
10 JAVA A TRAVÉS DE EJEMPLOS JESÚS BOBADILLA SANCHO ([email protected])
short 2 -32768 a 32767 int 4 -2^31 a 2^31 long 8 -2^63 a 2^63 Tipos numéricos decimales float 4 -3.4x10^38 a 3.4x10^38 double 8 -1.7x10^308 a 1.7x10^308 Tipo carácter char 2 Conjunto de caracteres Tipo lógico (booleano) boolean 1 true, false
Para declarar una va riable se emplea la sintaxis: tipo identificador; tipo identificador [=valor]; tipo identificador1,identificador2,identificador3,etc.; tipo identificador1 = valor1,identificador2 = valor2, etc.;
Por ejemplo: byte EdadPedro = 60; short SueldoMensual; float PrecioEnEuros, Cateto1, Cateto2, Hipotenusa; boolean Adquirido = false, Finalizado = true;
1.3.3 Tipos numéricos enteros
A continuación se proporcionan diversos programas comentados que muestran la manera de utilizar los tipos numéricos enteros:
En el primer ejemplo TiposNumericos1 , se declaran las variables de tipo byte EdadJuan y EdadPedro (líneas 3 y 4) y las variables de tipo short SueldoBase y Complementos (líneas 6 y 7). La línea 9 muestra, a modo de ejemplo, el valor de SueldoBase , que es 1980.
Obsérvese que se ha seleccionado el tipo byte para albergar edades, por lo que asumimos que nunca tendremos que introducir un valor superior a 127; del mismo modo empleamos el tipo short para contener sueldos (en euros), por lo que no podremos pasar de 32767, lo que puede ser válido si nos referimos a sueldos
