Download Manual del curso de Java básico

(Versión 6, JDK 1.6.0)
Reproducción prohibida
Versión 2.2
©Copyright Cédric Simon, 2005­2012
SolucionJava.com
Nivel básico
Manual del alumno
Ing. Cedric Simon – Tel: 2268 0974 – Cel: 8888 2387 – Email: c e d r i c @ s o l u c i o n j a v a . c o m – Web: www.solucionjava.com
Curso de programación
con Java
Curso de programación con Java – Nivel básico
Pagina 2 / 32
1 Índice
1 Índice.............................................................................................................................................................................................................2
2 Introducción al curso................................................................................................................................................................................... 5
2.1 Objetivo de este curso..........................................................................................................................................................................5
2.2 Manual del alumno.............................................................................................................................................................................. 5
2.3 Ejercicios prácticos..............................................................................................................................................................................5
2.4 Requisitos para atender a este curso..................................................................................................................................................5
2.5 Soporte despues del curso....................................................................................................................................................................5
3 Introducción al Java.....................................................................................................................................................................................6
3.1 Objetivo del capitulo............................................................................................................................................................................6
3.2 Historia del Java...................................................................................................................................................................................6
3.3 Las versiones de Java...........................................................................................................................................................................6
3.4 Uso del Java..........................................................................................................................................................................................6
3.5 Características del Java.......................................................................................................................................................................6
3.5.1 Simple.............................................................................................................................................................................................7
3.5.2 Orientado objetos........................................................................................................................................................................... 7
3.5.3 Distribuido......................................................................................................................................................................................7
3.5.4 Interpretado.................................................................................................................................................................................... 7
3.5.5 Seguro.............................................................................................................................................................................................7
3.5.6 Multihilo.........................................................................................................................................................................................7
4 Instalación del Java......................................................................................................................................................................................8
4.1 Objetivo del capitulo............................................................................................................................................................................8
4.2 Cual versión?........................................................................................................................................................................................8
4.3 Instalación de Java bajo Suse Linux..................................................................................................................................................8
4.4 Verificación de la instalación..............................................................................................................................................................8
4.5 Entornos de desarrollo (IDE)..............................................................................................................................................................9
5 Primera aplicación..................................................................................................................................................................................... 10
5.1 Objetivo del capitulo..........................................................................................................................................................................10
5.2 Estructura del código.........................................................................................................................................................................10
5.2.1 Declaración de la clase.................................................................................................................................................................10
5.2.2 Declaración de método.................................................................................................................................................................10
5.3 Compilación del código......................................................................................................................................................................10
5.4 Ejecución de la aplicación................................................................................................................................................................. 10
6 Características del lenguaje Java...............................................................................................................................................................11
6.1 Objetivo del capitulo..........................................................................................................................................................................11
6.2 Palabras reservadas...........................................................................................................................................................................11
6.3 Sensibilidad.........................................................................................................................................................................................11
6.4 Identificadores....................................................................................................................................................................................11
6.5 Reglas de nombramiento...................................................................................................................................................................11
6.6 Declaración de variables....................................................................................................................................................................12
6.6.1 Variable de clase vs. Variable de método....................................................................................................................................12
6.7 Tipos simples ( o primitivos).............................................................................................................................................................12
6.7.1 Enteros..........................................................................................................................................................................................13
©Copyright Cédric Simon, 2005­2012
Versión 2.2
Reproducción prohibida Curso de programación con Java – Nivel básico
Pagina 3 / 32
6.7.2 Reales...........................................................................................................................................................................................13
6.7.3 Carácter........................................................................................................................................................................................ 13
6.7.4 Boléanos.......................................................................................................................................................................................14
6.8 Constantes...........................................................................................................................................................................................14
6.9 Operadores......................................................................................................................................................................................... 14
6.9.1 Principales operadores sobre enteros y reales..............................................................................................................................14
6.9.2 Prioridad de operadores................................................................................................................................................................15
6.10 Conversiones entre tipos..................................................................................................................................................................15
6.10.1 Conversión automática...............................................................................................................................................................15
6.10.2 Conversión explicita...................................................................................................................................................................15
6.11 La clase Math................................................................................................................................................................................... 16
6.12 Comentarios......................................................................................................................................................................................16
7 Cadenas de caracteres y fechas..................................................................................................................................................................17
7.1 Objetivo del capitulo..........................................................................................................................................................................17
7.2 Introducción ...................................................................................................................................................................................... 17
7.3 String...................................................................................................................................................................................................17
7.3.1 Declaración...................................................................................................................................................................................17
7.3.2 Caracteres especiales....................................................................................................................................................................17
7.3.3 Concatenación de cadenas............................................................................................................................................................17
7.3.4 Otros métodos de String...............................................................................................................................................................17
7.3.5 Conversión de String a enteros o reales y contrario.....................................................................................................................18
7.4 Date......................................................................................................................................................................................................18
7.5 Calendar.............................................................................................................................................................................................18
8 Arreglos.......................................................................................................................................................................................................20
8.1 Objetivo del capitulo..........................................................................................................................................................................20
8.2 Tipos de arreglos y uso...................................................................................................................................................................... 20
8.3 public static void main (String [] args).............................................................................................................................................20
9 Decisiones y bucles.....................................................................................................................................................................................21
9.1 Objetivo del capitulo..........................................................................................................................................................................21
9.2 if ... else................................................................................................................................................................................................21
9.3 Comparación de objetos....................................................................................................................................................................21
9.4 Condiciones múltiples (AND y OR)..................................................................................................................................................21
9.5 switch...................................................................................................................................................................................................22
9.6 while.....................................................................................................................................................................................................22
9.7 do ... while........................................................................................................................................................................................... 22
9.8 for.........................................................................................................................................................................................................22
9.9 break....................................................................................................................................................................................................23
9.10 continue.............................................................................................................................................................................................23
9.11 Operador ternario............................................................................................................................................................................23
10 Paquetes, clases, y métodos......................................................................................................................................................................24
10.1 Objetivo del capitulo........................................................................................................................................................................24
10.2 Paquetes............................................................................................................................................................................................ 24
10.2.1 Uso............................................................................................................................................................................................. 24
1.1.1 Importación de paquetes ..............................................................................................................................................................24
10.3 Clases.................................................................................................................................................................................................25
10.3.1 Declaración y uso.......................................................................................................................................................................25
©Copyright Cédric Simon, 2005­2012
Versión 2.2
Reproducción prohibida Curso de programación con Java – Nivel básico
Pagina 4 / 32
10.4 Constructores................................................................................................................................................................................... 25
10.5 Métodos.............................................................................................................................................................................................25
10.5.1 Declaración y uso.......................................................................................................................................................................25
10.6 Modificadores de acceso..................................................................................................................................................................26
10.6.1 Acceso por defecto.....................................................................................................................................................................26
10.6.2 private.........................................................................................................................................................................................26
10.6.3 public..........................................................................................................................................................................................26
10.6.4 protected.....................................................................................................................................................................................26
11 Polimorfismo, encapsulamiento, y herencia........................................................................................................................................... 27
11.1 Objetivo del capitulo........................................................................................................................................................................27
11.2 Polimorfismo.....................................................................................................................................................................................27
11.3 Encapsulamiento..............................................................................................................................................................................27
11.3.1 Clases internas............................................................................................................................................................................27
11.3.2 Clases abstractas.........................................................................................................................................................................29
11.3.3 Interfaces....................................................................................................................................................................................29
11.4 Herencia............................................................................................................................................................................................29
12 Tratamiento de excepciones.....................................................................................................................................................................30
12.1 Objetivo del capitulo........................................................................................................................................................................30
12.2 Errores de compilación....................................................................................................................................................................30
12.3 Errores de lógica.............................................................................................................................................................................. 30
12.4 Errores de ejecución........................................................................................................................................................................ 30
12.4.1 throws.........................................................................................................................................................................................30
12.4.2 try .............................................................................................................................................................................................. 31
12.4.3 catch........................................................................................................................................................................................... 31
12.4.4 finally......................................................................................................................................................................................... 31
13 Ejercicios...................................................................................................................................................................................................32
©Copyright Cédric Simon, 2005­2012
Versión 2.2
Reproducción prohibida Curso de programación con Java – Nivel básico
Pagina 5 / 32
2 Introducción al curso
2.1 Objetivo de este curso En este curso vamos a ver las bases del lenguaje Java. Esta base les va a servir por cualquier tipo de aplicación que desea realizar: aplicación independiente, applet, pagina web en Java…
2.2 Manual del alumno Este manual del alumno es una ayuda para el alumno, para tenga un recuerdo del curso. Este manual contiene un resumen de las materias que se van a estudiar durante el curso, pero el alumno debería de tomar notas personales para completas este manual.
2.3 Ejercicios prácticos Para captar mejor la teoría, se harán muchos ejercicios con los alumnos, para probar la teoría y verificar la integración de la materia.
También, el alumno podrá copiar sus códigos en un disquete al fin del curso para llevarse, con fin de seguir la práctica en su hogar. 2.4 Requisitos para atender a este curso No hay requisitos para atender a este curso, pero el conocimiento de otro lenguaje de programación, y especialmente el C++, le ayudaran a entender mas rápidamente el lenguaje Java. Si el alumno tiene dificultades en un u otro capitulo, el debe sentirse libre de pedir explicaciones adicionales al profesor.
2.5 Soporte despues del curso Si tienes preguntas sobre la materia del curso en tus ejercicios prácticos, puedes escribir tus preguntas a [email protected].
Para informaciones sobre otros cursos, visita el sitio web www.solucionjava.com.
©Copyright Cédric Simon, 2005­2012
Versión 2.2
Reproducción prohibida Curso de programación con Java – Nivel básico
Pagina 6 / 32
3 Introducción al Java
3.1 Objetivo del capitulo Al fin de este capitulo, el alumno tendrá una vista general de la historia del Java, así como de sus características generales.
3.2 Historia del Java Java fue desarrollado por Sun Microsystems. La primera versión salió en 1995. El objetivo era de tener un lenguaje de programación que pueda funcionar sobre cualquier equipo, de manera independiente del hardware y del sistema operativo.
Java conoció un gran interés de parte de los desarrolladores gracias al Internet. Los ‘applets’ desarrolladas en Java podían ser interpretadas y ejecutadas por cualquier cliente web, que sea un PC, un Mac, Linux. Fue primero gracias a su portabilidad que Java estuvo (¡y está!) tan popular.
3.3 Las versiones de Java La primera versión de Java fue la versión 1.0. Siguieron la versión 1.1, 1.2, 1.3, 1.4, 1.5, y ahora 1.6.
A partir de la versión 1.2, se habla de ‘Java 2’, para diferenciar de las versiones anteriores.
Sun Microsystems utiliza dos números de versiones para sus productos Java: el número de versión de producto, y el número de versión de desarrollo.
Así hablando del producto o plataforma se hablara de la versión 6.0, cuando el desarrollador hablara de la versión 1.6.0
Ejemplo de productos de Sun Microsystems:
Nombre completo Java 2 Platform Standard Nombre de plataforma
Edition 6.0 J2SE Development Kit 6.0 Productos trabajando bajo la J2SE Runtime Environment plataforma
6.0 Abreviación J2SE 6.0 JDK 6.0 JRE 6.0
Los dos primeros dígitos del número de versión permiten identificar su versión mayor. Así la versión 1.4.2_01 es una subversión 2, revisión 01, del Java 2, versión 1.4.
3.4 Uso del Java Java tiene varias utilidades. Puede servir a desarrollar aplicaciones autónomas (100% Java), applets parra el Internet (pequeñas aplicaciones descargadas y ejecutando sobre el cliente), o ser mezclado con otro lenguaje como HTML (Java script, Java Server Pages,...).
3.5 Características del Java La difusión rápida del Java ha sido posible gracias a sus importantes características. Aquí son las características principales del Java.
©Copyright Cédric Simon, 2005­2012
Versión 2.2
Reproducción prohibida Curso de programación con Java – Nivel básico
3.5.1
Pagina 7 / 32
Simple Aun que el lenguaje orientado objeto (OO) no es fácil ni sencillo, Java es reconocido como más fácil que otros lenguajes como el C++.
3.5.2
Orientado objetos La programación orientada objeto modela las cosas del mundo real, o los conceptos, como un objeto. Así el objeto ‘carro’ puede servir a construir carros rojos, como carros azules, a partir del mismo objeto ‘carro’.
3.5.3
Distribuido Java permite interacciones entre varias computadoras conectadas en redes, para distribuir el trabajo o los recursos.
3.5.4
Interpretado Java es un lenguaje interpretado, eso significa que necesita un interprete para poder ser ejecutado. Este intérprete es la maquina virtual de Java (JVM).
Java esta compilado en un código binario, que la maquina virtual interpreta. Así el código puede ser compilado de manera independiente del sistema de destino. La maquina virtual de Java es específica al sistema operativo de destino, no al código.
3.5.5
Seguro El lenguaje Java se utiliza en el Internet en muchos sitios web que necesitan una grande seguridad, como bancos, comercio electrónico,...
Java tiene muchas opciones para gestionar la seguridad de ejecución de la aplicación.
También el código Java descargado del Internet y ejecutado el la maquina del cliente, no produce daños en la maquina del cliente.
3.5.6
Multihilo Java permite ejecutar tareas según varios hilos de ejecución, es decir ejecutar varias tareas en paralelo.
©Copyright Cédric Simon, 2005­2012
Versión 2.2
Reproducción prohibida Curso de programación con Java – Nivel básico
Pagina 8 / 32
4 Instalación del Java
4.1 Objetivo del capitulo Al fin de este capitulo, el alumno tendrá las herramientas de Java instalado en su computadora. Este es un requisito para poder cumplir los ejercicios prácticos.
4.2 Cual versión? Existen tres plataformas de Java 6:
• La edición estándar de Java 6 (J2SE). Es la que vamos a utilizar.
• La edición de empresa de Java 6 (J2EE). Es una versión más amplia, para hacer aplicaciones (web) muy grandes.
• La edición micro de Java 6 (J2ME). Es una versión para hacer aplicaciones para aparatos electrónicos (móviles, beeper, MP3,...)
En la plataforma estándar, hay dos productos principales:
• El ambiente de ejecución (JRE), que contiene la maquina virtual, y que es necesario para ejecutar un código Java.
• El ambiente de desarrollo (JDK), que contiene las fuentes y códigos necesarios para compilar un código Java ‘texto’ en código Java binario, listo para ser ejecutado.
Existen otras versiones de Java que la de Sun, así por ejemplo el OpenJDK, o la maquina virtual Java de Microsoft. Pero para más estabilidad, y para estar todos utilizando la misma cosa, vamos a quedarnos utilizando las versiones de Java de Sun.
Nosotros, para poder desarrollar en Java, necesitamos descargar la versión de desarrollo (JDK) que corresponde al sistema operativo sobre el cual vamos a trabajar.
El JDK (y el JRE) se pueden descargar gratuitamente de desde el sitio http://java.sun.com
4.3 Instalación de Java bajo Suse Linux Para instalar la version 1.6 de Java JDK vamos primero a entrar como el usuario Root (o usar su).
Luego abrimos una ventana de consola, introducemos el CD del curso, y vamos a instalar la version de Java que estaen el CD lanzando desde el CD la instrucción: rpm
-ivh jdk-6u4-linux-i586.rpm
Ahora el Java esta disponible en sistema bajo /usr/java/jdk1.6.0_04 pero el Java por defecto es todavia la version 1.5 que venia con Suse 10.3. Se puede verificar ejecutando java -version
Para que la version por defecto sea la version 1.6 hay que cambiar algunos enlaces debajo de / etc/alternatives. Para eso, ejecuta desde el CD '. modifySuseJDK16.sh'. Si sale un error de que javac no existe, ignorala. 4.4 Verificación de la instalación Una vez el archivo descargado e instalado, verificamos que el Java esta bien instalado abriendo una ventana de ejecución y ejecutando lo siguiente: java -version y javac
Si no contesta que la version de Java es 1.6.0, es que Java 1.6.0 no esta instalado correctamente, o que no se han cambiado corectamente los atajos de /etc/alternatives. ©Copyright Cédric Simon, 2005­2012
Versión 2.2
Reproducción prohibida Curso de programación con Java – Nivel básico
Pagina 9 / 32
Si no reconoce el javac, hay que configurar variables de ambiente (path). Debajo de /etc modificar el archivo profile
adjuntando el camino /usr/share/java/bin en la variable PATH.
Bajo Windows, el camino hacia la carpeta bin de Java debe estar incluido en la variable de entorno Path. Bajo XP y Windows 2000, click derecho sobre Mi PC... Propiedades... Opciones avanzadas... Variables de entorno... Variables
de sistema. Editar la variable path e incluir al final entre doble comillas el camino hacia Java (por ejemplo "C.\Archivos de Programa\Java\jdk1.6.0_04\bin).
4.5 Entornos de desarrollo (IDE) Si para programar en Java, no se necesita más que un editor de texto (y el Java instalado...), existen varias aplicaciones que ayudan en la programación, identificando las palabras reservadas, proponiendo la sintaxis, formateando el código, etc...
Para este curso, vamos a utilizar un simple tratamiento de texto, porque es el mas simple, y o requiere manual de usuario, como ciertos entornos de desarrollo. Para su información, aquí están unos entornos de desarrollo para Java que proponen una versión gratis, y que son disponibles para Windows como para Linux: ● Eclipse (www.eclipse.org)
● NetBeans (www.netbeans.org)
● Jdeveloper de Oracle (www.oracle.com)
©Copyright Cédric Simon, 2005­2012
Versión 2.2
Reproducción prohibida Curso de programación con Java – Nivel básico
Pagina 10 / 32
5 Primera aplicación
5.1 Objetivo del capitulo Al fin de este capitulo, el alumno hará creado y ejecutado su primer código Java.
Esta primera aplicación servirá de base para poner en práctica y probar la teoría que vamos a ver en los próximos capítulos.
5.2 Estructura del código Para poder ser ejecutado, un código Java necesita al menos una clase, y que esta clase contiene una método, la método main.
Aquí esta un ejemplo de una aplicación que imprima en la consola ‘Estoy en main’:
class Test {
public static void main(String[] args) { // metodo principal
System.out.println("Estoy en main!");
}// fin de metodo Main
} // fin de clase
5.2.1
Declaración de la clase La clase tiene que ser declarada con la palabra reservada ‘class’, y seguido de un espacio y del nombre de la clase (aquí ‘Test’).
La clase tiene que ser guardada en un archivo que tenga el mismo nombre que la clase, y la extensión .java
El inicio y el final de la clase están marcados con { y } respectivamente. Ahora teneos un objeto (clase) que se llama ‘Test’.
5.2.2
Declaración de método El método principal, que esta llamada cuando se inicia la aplicación Java es el método main (public
main(String[] args)).
static void
El inicio y el final del método están marcados con { y } respectivamente. Este método hace solamente una acción: imprima en la consola el texto ‘Estoy en main!’).
Para mas informaciones sobre las clases y métodos, ver el capitulo ‘Paquetes, clases, y métodos’.
5.3 Compilación del código Una vez el código guardado (Test.java), lo podemos compilar ejecutando la instrucción siguiente: javac
Test.java
Esta instrucción va a compilar el código y, si la compilación sale con éxito, crear un archivo Test.class
5.4 Ejecución de la aplicación Para ejecutar el código de nuestra aplicación, llamamos a la instrucción java
en main!’.
©Copyright Cédric Simon, 2005­2012
Versión 2.2
Test.
En la consola debe aparecer ‘Estoy Reproducción prohibida Curso de programación con Java – Nivel básico
Pagina 11 / 32
6 Características del lenguaje Java
6.1 Objetivo del capitulo Al fin de este capitulo, el alumno será capaz de elegir el tipo de variable necesaria para un cierto tipo de datos, y podrá declarar variables y constantes en Java.
El podrá también poner comentarios en su código, convertir datos de un tipo a otro, y hacer operaciones sobre variables.
6.2 Palabras reservadas Hay palabras que son ‘reservadas’ porque tienen un significado especial dentro del lenguaje Java. Así no se pueden utilizar para otra cosa que su uso predefinido. Todas las palabras reservadas estan en minúsculas.
Lista de palabras reservadas del Java 1.6.0:
abstract
assert***
boolean
break
byte
case
catch
char
class
const*
continue
default
do
double
else
enum****
extends
final
finally
float
*
**
***
****
not used
added in 1.2
added in 1.4
added in 5.0
for
goto*
if
implements
import
instanceof
int
interface
long
native
new
package
private
protected
public
return
short
static
strictfp**
super
switch
synchronized
this
throw
throws
transient
try
void
volatile
while
6.3 Sensibilidad Java es sensible a las mayúsculas y las minúsculas. Así ‘try’ es una palabra reservada, pero ‘Try’ no.
6.4 Identificadores Los identificadores son los nombres que se dan para identificar a las clases, paquetes, interfaces, métodos, y variables.
El nombre de un identificador tiene que cumplir con ciertas reglas:
• Debe tener un o mas caracteres (sin longitud máxima)
• No puede contener operadores (+,­,>...)
• No puede ser igual a una palabra reservado (if, void, ...). Ver la lista de palabra reservadas arriba.
• El primer carácter tiene que ser una letra, el carácter ‘$’ o el carácter ‘_’ (subrayado).
• Las letras que pueden ser utilizadas son las del alfabeto Unicode, con mayúsculas y minúsculas (¡cuidado que Java hace diferencias entre mayúsculas y minúsculas!).
6.5 Reglas de nombramiento Para tener un código más estándar, existen règlas de nombramiento de los paquetes, clases, métodos, variables, y constantes.
Los nombres de paquetes están normalmente en minúsculas. Ej: paquete test
©Copyright Cédric Simon, 2005­2012
Versión 2.2
Reproducción prohibida Curso de programación con Java – Nivel básico
Pagina 12 / 32
Los nombres de clases están normalmente en minúsculas, con la primera letra en mayúscula, así como la primera letra de case nombre interno. Ej: clase TestJava
Los nombres de métodos y variables están normalmente en minúsculas, con la primera letra en minúscula, y la primera letra de case nombre interno en mayúscula. Ej: método getNombre, variable edadEmpleado, ... Los nombres de constantes están normalmente en mayúsculas. Ej: constante PREF_TEL;
Aún que no seguir estas reglas de nombramiento no provoca errores en Java, pero al trabajar en equipo, al utilizar código de otra persona, o al querer utilizar ciertas opciones de herramientas para generar parte de código de manera automática, el seguimiento de estas reglas es muy importante.
6.6 Declaración de variables Las variables permiten almacenar datos de entrada, de salida, o intermedios.
La sintaxis básica de declaración de variable es: <tipo de dato> <nombre de variable>;
int miNumero;
En la declaración se puede declarar a la vez varias variables de un mismo tipo, separando los nombres de variables con una coma. <tipo de dato> <nombre de variable 1>,<nombre de variable 2>;
int miNumero, tuNúmero;
En la declaración se puede también inicializar la variable, asignándole un valor. El valor se asigna con el signo igual y la valor inicial.
<tipo de dato> <nombre de variable> = <valor inicial>;
int miNumero = 1;
Una variable está disponible solamente a dentro del bloque de código a donde está declarado (delimitado por {}). Los diferentes niveles on clase, método, y bloque a dentro de un método.
6.6.1
Variable de clase vs. Variable de método Una variable declarada al nivel de la clase se inicializa por defecto a cero (enteros y reales), false (bolean), o a nulo (otros tipos). Las variables de clase son disponible de desde cualquier método de la clase.
Una variable declarada en un método debe ser inicializada de manera explicita para poder ser utilizada.
Si un variable de método tiene el mismo nombre que un variable de clase, a dentro de este método la variable de método sobre escribe la variable de clase, a menos que se menciona 'this.' Antes el nombre de la variable (para utilizar la variable de clase).
Una variable de método no puede ser sobre escrita por otra. Es decir, los nombre de variable deben ser únicos a dentro de un método.
6.7 Tipos simples ( o primitivos) Los tipos simples son tipos que no son orientados objetos. Se subdividen entre enteros, reales, carácter, y boléanos.
©Copyright Cédric Simon, 2005­2012
Versión 2.2
Reproducción prohibida Curso de programación con Java – Nivel básico
6.7.1
Pagina 13 / 32
Enteros Hay cuarto tipos de enteros: byte, short, int y long. Todos pueden ser positivos o negativos, y tienen una capacidad de 8, 16, 32 o 64 bits.
Cuando se asigna un valor numérico a un long, hay pegarle la letra ‘l’ para indicar a Java que es un long. Por defecto, un valor entero esta considerado como un int. Ejemplos de declaración: int miNumero = 1;
byte testByte = 17;
short testShort = 12357;
long testLong = 122132135l;
6.7.1.1
byte El byte puede contener valores enteras entre ­128 y 127.
6.7.1.2
short El short puede contener valores enteras entre ­32768 y 32767.
6.7.1.3
int El int puede contener valores enteras entre ­2147483648 y 2147483647.
6.7.1.4
long El long puede contener valores enteras entre ­9223372036854775808 y 9223372036854775807. 6.7.2
Reales Los reales contienes valores con coma flotante, que permite almacenar números muy grandes o muy pequeños con grande precisión.
Los reales se dividen entre float y double. Los float tienen precisión ‘simple’ (6 o 7 dígitos máximo) y los double tienen precisión ‘doble’ (14 o 15 dígitos). Por defecto, un valor real esta considerado como un doble. Cuando se asigna un valor numérico a un float, hay pegarle la letra ‘f’ para indicar a Java que es un float. Ejemplos de declaración: float testFloat = 1.771f;
double testDouble = 1.221;
6.7.2.1
float El float puede contener valores decimales entre 3,4E­38 y 3,4E38.
6.7.2.2
double El double puede contener valores decimales entre 1,7E­308 y 1,7E308.
6.7.3
Carácter El carácter (char) puede contener solo un carácter. Las cadenas de caracteres serán vistos en otro capitulo.
Ejemplo de declaración: char
miChar='A';
©Copyright Cédric Simon, 2005­2012
Versión 2.2
Reproducción prohibida Curso de programación con Java – Nivel básico
6.7.3.1
Pagina 14 / 32
char El tipo carácter (char) puede contener un (y solo un) carácter Unicode. El Unicode permite utilizar un carácter de cualquier idioma. El carácter se declara entre simple comillas:
6.7.4
6.7.4.1
Boléanos boolean Los boléanos pueden tomar exclusivamente el valor true o false (verdadero o falso).
Ejemplo de declaración: boolean
miBoolean=true;
6.8 Constantes Las constantes son datos cuyo valor no puede cambiar durante la ejecución del programa.
Las constantes utilizan los mismos tipos que las variables, y se declaran de la misma manera a la exception que se pone ‘final’ antes el tipo de dato.
La sintaxis básica de declaración de variable es: final <tipo de dato> <nombre de variable>;
final int MI_CONSTANTE;
6.9 Operadores Los operadores se utilizan para hacer operaciones sobre las variables. Permiten combinar, modificar, o evaluar las variables.
6.9.1
Principales operadores sobre enteros y reales ­
++
­­
=
==
!=
<
<=
>=
>
+
*
/
%
!
Resta
Incremento
Decremento
Asignación
Igualdad
Desigualdad
Menos que
Menos o igual que
Mayor o igual que
Mayor que
Suma
Multiplicación
División
Modulo
Negación lógica
Los operadores de incremento (++) y decremento (­­) se pueden utilizar antes o después de la variable, pegado a ella.
Si se utilizan antes, la variable se incrementa o decrementa directamente. Si se utiliza después, la variable se incrementa o decrementa justo después de haber sido utilizada.
Ejemplo de declaración: int i = 0;
System.out.println(++i); // imprime 1
System.out.println(i); // imprime 1
System.out.println(i++);// imprime 1
©Copyright Cédric Simon, 2005­2012
Versión 2.2
Reproducción prohibida Curso de programación con Java – Nivel básico
Pagina 15 / 32
System.out.println(i); // imprime 2
System.out.println(i++ +" y "+ --i ); // imprime 2 y 2
6.9.2
Prioridad de operadores Como en la matemática, en Java existen prioridades entre los operadores. Los paréntesis tienen la más grande prioridad, se pueden utilizar para forzar un orden de evaluación, así como para facilitar la lectura del código.
Prioridad des los operadores:
1. ( ) [ ]
2. ! ++ ­­
3. new (tipo)
4. * / %
5. + ­
6. > >= <= < instance of
7. == !=
8. &
9. |
10. &&
11. ||
12. ?:
13. = *= /= %= += ­= >>= >>>= <<= &= |=
6.10 Conversiones entre tipos Las conversiones pueden ser automáticas o explicitas.
6.10.1
Conversión automática Cuando expresiones utilizan varios tipos de datos operando entre ellos, Java intenta realizar conversiones automáticas de tipos. Las conversiones automáticas son posibles solamente de un tipo hasta otra que tenga igual o más grande precisión.
Las conversiones automáticas son posibles en el siguiente sentido
char int long float  double
byte short
6.10.2
Conversión explicita Cuando se precisa un estrechamiento de tipo, es necesario convertir de manera explicita los tipos de datos. Si no, se podrían generar un error de compilación, u obtener un resultado con demasiada precisión.
Las conversiones explicitas entre enteros y reales se hacen indicando en tipo deseado delante el número a convertir.
Cuidado que cuando el numero convertido es más grande que el tamaño posible para el tipo deseado (por ejemplo cambiar 123546 a tipo byte), el resultado puede ser bien extraño...
Ejemplo:
float miFloat = 1.999f;
int miInt = (int) miFloat;
©Copyright Cédric Simon, 2005­2012
Versión 2.2
Reproducción prohibida Curso de programación con Java – Nivel básico
Pagina 16 / 32
System.out.println("36.98 * 100 -> Float="+Float.parseFloat("36.98")*100+" Double="+Double.parseDouble("36.98")*100);
System.out.println("(long) (36.98 * 100) -> Float="+ (long)(Float.parseFloat("36.98")*100)+" - Double="+ (long)
(Double.parseDouble("36.98")*100));
System.out.println("Math.round(36.98 * 100) -> Float="+Math.round(Float.parseFloat("36.98")*100)+" Double="+Math.round(Double.parseDouble("36.98")*100));
6.11 La clase Math La clase Math del Java contiene la mayoría de las operaciones matemáticas que se hacen sobre enteros o reales. Para la lista completa de métodos, ver la documentación Java.
Incluye entre otros: El valor absoluto
Máximo entre 2 exp
Número aleatorio
Sinus
Log natural
El entero igual o superior
El entero igual o inferio
Math.abs(<exp>)
Math.max(<exp1>,<exp2>)
Math.random()
Math.sin(<exp>)
Math.log(<exp>)
Math.ceil(<exp>)
Math.floor(<exp>)
6.12 Comentarios En el código Java se pueden meter comentarios. Los comentarios de una sola línea se sígnala con ‘//’. Los comentarios de una o varias líneas se sígnala con ‘/*’ al inicio, y ‘*/’ al final.
Ejemplos:
/* Este
es un comentario
de varias líneas */
int miNumero2;
int miNumero = 1; // Este es una muestra de comentario de una línea
Los comentarios de una o varias líneas que tienen como objetivo de participar en la creación de la documentación Java (Javadoc) se sígnala con ‘/**’ al inicio, y ‘*/’ al final.
©Copyright Cédric Simon, 2005­2012
Versión 2.2
Reproducción prohibida Curso de programación con Java – Nivel básico
Pagina 17 / 32
7 Cadenas de caracteres y fechas
7.1 Objetivo del capitulo Al fin de este capitulo, el alumno será capaz de utilizar y manejar cadenas de caracteres y fechas.
7.2 Introducción En Java, existen variables (objetos) que pueden contener cadenas de caracteres o fechas, que no son tipos primitivos de Java, si no objetos utilizados como tipo, y que tienen sus propios métodos para ser modificadas.
7.3 String El objeto mas utilizado para contener cadenas de caracteres es el tipo objeto String. Este tipo permite guardar una cadena de caracteres sin limitación, si no la limitación de la memoria de la computadora.
7.3.1
Declaración Las cadenas de caracteres se declaran como las variables, y el valor se menciona entre doble cuotas. Ejemplo: String
7.3.2
miTexto = "Hola Nicaragua!";
Caracteres especiales Para insertar ciertos caracteres especiales a dentro de una cadena de caracteres, hay que mencionarlos detrás de una contra barra (\). Para mencionar una doble comilla: \" Para mencionar una tabulación: \t Para mencionar una nueva línea: \n Para mencionar un regreso a la línea: \r Para mencionar un carácter Unicode: \uxxxx a donde xxxx es el valor hexadecimal del carácter
O \xxx a donde xxx es el valor octal del carácter (0 a 7)
7.3.3
Concatenación de cadenas Para concatenar dos cadenas de caracteres, se puede utilizar el método concat o el signo ‘+’.
Ejemplo:
String miTexto = "Hola!";
miTexto += "Una prueba.";
Hay que tener cuidado con las concatenaciones, porque con el objeto String, cada concatenación crea un nuevo objeto, lo que consume memoria. Si Usted necesita hacer muchas concatenaciones, utiliza mejor la clase StringBuilder.
7.3.4
Otros métodos de String Existen muchos métodos del objeto String para hacer operaciones sobre cadena de caracteres. Para la lista completa de métodos, ver la documentación Java.
Por ejemplo: length(),
charAt(int <indice>),substring (int <inicio>,int <final>), ...
©Copyright Cédric Simon, 2005­2012
Versión 2.2
Reproducción prohibida Curso de programación con Java – Nivel básico
7.3.5
Pagina 18 / 32
Conversión de String a enteros o reales y contrario Para convertir una cadena de caracteres (que contiene solo un número) a enteros o reales o contrario, hay que utilizar métodos especiales. Ejemplos:
int miNumero = Integer.parseInt("1234");
float miFloat = Float.parseFloat("123.566");
String miConvertido = String.valueOf(miFloat);
7.4 Date La clase Date del paquete java.util se utiliza para guardar fechas y horas. Como el paquete
java.util no se carga por defecto, hay que importarlo. Solo tiene dos constructores: uno sin
argumento, que asigna la fecha y hora actual, y uno con un argumento long que contiene el
número de milisegundos que hay que incrementar a la fecha del 1/1/1970.
La clase Date tiene métodos, entre otras para cambiar la fecha, extraer el día, mes, año...
formatear la fecha o convertirla en String. Pero muchos de sus métodos están despreciadas,
y se tiene que utilizar la clase Calendar. Para la lista completa de métodos, ver la
documentación Java.
Existe también un objeto Date en el paquete java.sql que se utiliza para manejar fechas
durante las conexiones a bases de datos.
Ejemplo:
import java.util.Date;
public class TestDate{
Date miFecha = new Date();
…}
7.5 Calendar La clase Calendar, y su subclase GregorianCalendar, permite manejar fechar según el calendario Gregoriano.
Con este clase podemos gradar datos de fecha y manejarlas haciendo, entre otros, sumas y diferencias de fechas.
Ejemplo:
import java.util.*;
public class TestFecha {
public TestFecha() {
System.out.println(getCurrDate());
System.out.println(getTestDate());
}
public String getCurrDate() {
Calendar cal = new GregorianCalendar();
String day = "0" + cal.get(Calendar.DATE);
int pos = day.length();
day = day.substring(pos - 2, pos);
String month = "0" + (cal.get(Calendar.MONTH) + 1);
pos = month.length();
month = month.substring(pos - 2, pos);
String year = "" + cal.get(Calendar.YEAR);
String currdate = day + "/" + month + "/" + year;
return currdate;
}
public String getTestDate() {
Calendar cal = new GregorianCalendar();
cal.set(1996, 11, 1); // cuidado que el mes empieza con 0 y no 1 (0->11)
System.out.println(cal.get(Calendar.DATE)); // 1
System.out.println(cal.get(Calendar.MONTH)); // 11
System.out.println(cal.get(Calendar.YEAR)); // 1996
©Copyright Cédric Simon, 2005­2012
Versión 2.2
Reproducción prohibida Curso de programación con Java – Nivel básico
}
}
Pagina 19 / 32
String day = "0" + cal.get(Calendar.DATE);
int pos = day.length();
day = day.substring(pos - 2, pos);
String month = "0" + (cal.get(Calendar.MONTH) + 1); // +1 para corregir el mes
pos = month.length();
month = month.substring(pos - 2, pos);
String year = "" + cal.get(Calendar.YEAR);
String currdate = day + "/" + month + "/" + year; // 01/12/1996
return currdate;
public static void main(String[] args) { // metodo principal
System.out.println(new GregorianCalendar().getTime());
new TestFecha();
}// fin de metodo Main
©Copyright Cédric Simon, 2005­2012
Versión 2.2
Reproducción prohibida Curso de programación con Java – Nivel básico
Pagina 20 / 32
8 Arreglos
8.1 Objetivo del capitulo Al fin de este capitulo, el alumno será capaz de utilizar y manejar una colección de datos.
8.2 Tipos de arreglos y uso En Java existen variables que pueden contener una colección de datos del mismo tipo. Los arreglos a una dimensión contienen una lista de valores, un arreglo bidimensional contendrá una tabla de datos.
Así, se puede guardar una tabla de datos en un solo variable.
Los arreglos pueden ser de tipo simple como de objetos.
Se declaran con ‘[ ]’ detrás del tipo para una dimensión, y ‘[ ] [ ]’ para doble dimensión.
Cuando se crea un arreglo, sus elementos están inicializados por defecto a cero para arreglos de enteros y reales, una cadena vacía para char, false para boléanos, y null para los objetos.
Los índices de un arreglo empiezan con 0 y se incrementan por unidad.
Una vez inicializado, el tamaño del arreglo no puede cambiar mas.
Ejemplos de declaración:
String paginaList []= {"Formato A4", // arreglo de 4,
"Carta 8.5 x 11",
"Prescripcion US",
"Prescripcion BE"};
inicializado con valores
int miArregloInt [] = new int [9]; // arreglo de 9 líneas, inicializado con cero
int miArreglo2 [] [] = {{1,2,3},{2,4,6}}; // arreglo de 2 líneas y 3 columnas, inicializado con valores.
Ejemplos de utilización:
miArregloInt [0]=5; // asigna el valor 5 al primer miembro del arreglo
int miNumero = miArregloInt [0]; // miNumero será igual a 5
System.out.println(miArreglo2[0][0]); // imprime 1
System.out.println(miArreglo2[0][2]); // imprime 3
System.out.println(miArreglo2[1][2]); // imprime 6
System.out.println(miArreglo2[2][3]); // esta línea genera un error java.lang.ArrayIndexOutOfBoundsException
8.3 public static void main (String [] args) El método public
static void main (String [] args) accepta como parametro de entrada un arreglo de String.
Para pasar los valores en parametro, se mencionan después del nombre de la clase, separados por espacios. Si un valor contiene espacios, hay que ponerla entre doble comillas.
Ejemplo:
…
public static void main(String[] args) { // metodo principal
System.out.println(args[0]); // imprime “Uno”
System.out.println(args[1]); // imprime “y dos”
}
…
java Test Uno "y dos"
©Copyright Cédric Simon, 2005­2012
Versión 2.2
Reproducción prohibida Curso de programación con Java – Nivel básico
Pagina 21 / 32
9 Decisiones y bucles
9.1 Objetivo del capitulo Al fin de este capitulo, el alumno será capaz de crear esquema de decisiones en su código, así como crear y manejar bucles.
9.2 if ... else El if se utiliza para crear esquema de decisiones. Se puede utilizar con el else, pero es facultativo.
El if, que significa ‘si’ permite probar una o varias condiciones. El resultado de cada condición siempre es si o no. Las condiciones siempre están entre paréntesis.
Después del if viene la instrucción que será realizada en caso que el resultado de la(s) condición(es) sale verdadero.
El else, que se puede traducir por ‘si no se cumplio’, la instrucción que será realizada en caso que el resultado de la(s) condición(es) del if salió falso.
Si hay mas que una instrucción que ejecutar tras el if o el else, hay que utilizar un bloque de instrucciones, conteniendo las instrucciones entre { y } .
Ejemplo:
int licencia = 0;
if (licencia==1) System.out.println("!Yo tengo la licencia!”);
else {System.out.println("!No tengo licencia!”);
System.out.println("Pero la voy a comprar pronto...”);
}
9.3 Comparación de objetos Para hacer comparaciones entre dos objetos, es siempre mas seguro utilizar en método equals, porque el uso de ‘==’ hará la comparación basada en los objetos, y no en su contenido.
Ejemplo:
String miTexto = "Hola!";
if (miTexto.equals("Hola!")) System.out.println("OK");
9.4 Condiciones múltiples (AND y OR) Para mencionar condiciones múltiples se utilizan los símbolos | y &.
Para que cumple con una Y otra condiciones, se utiliza el & (significa Y ).
Para que cumple con una U otra condiciones, se utiliza el | (significa O ).
Para que evalúa solamente las condiciones necesarias (en caso de Y, si la primera no cumple, no evalúa las otra, en caso de O, si la primera cumple, no evalua las otras), se dobla el si no (|| o &&). Para mejor rendimiento se dobla siempre.
Ejemplo:
int licencia = 0;
if (licencia > 10 || licencia == 5) System.out.println("!Yo tengo la licencia 5 o > 10!");
else if (licencia < 10 || licencia > 5) System.out.println("!Tengo licencia entre 5 y 10!");
else System.out.println("!Tengo licencia < 5 ");
©Copyright Cédric Simon, 2005­2012
Versión 2.2
Reproducción prohibida Curso de programación con Java – Nivel básico
Pagina 22 / 32
9.5 switch El switch se utiliza para crear esquema de decisiones. El switch permite de tener varias alternativas, en contra del if...else que solo tiene dos alternativas.
Primera se declara, entre paréntesis, cual variable se va a evaluar. Solo char, byte, short o int peden ser evaluados. Siguiendo, para cada alternativa, se menciona la palabra case con la valor correspondiendo a la valor de la alternativa, y el código que hay que ejecutar. Si no se termina la alternativa con la palabra break, el código de las alternativas siguiente se van a ejecutar también, mismo si el valor de la variable evaluada no corresponde al case. Por fin, la palabra default se utiliza para mencionar acciones a realizar en caso que ninguna alternativa salió verdadera. Como para el case, debería terminar con break para que no se ejecutaría otro código siguiendo.
Si hay mas que una instrucción que ejecutar tras el case o el default, hay que utilizar un bloque de instrucciones, conteniendo las instrucciones entre { y } .
Ejemplo:
int test=1;
switch (test) {
case 1 : System.out.println("Igual a
case 10 : System.out.println(" Igual
break;
case 20 : System.out.println(" Igual
default : System.out.println(" Igual
1");
a 10");
a 20");
a otro valor");
}
9.6 while El ‘while...’ se utiliza para crear bucles, es decir repetir una acción por tanto que se cumple a una condición.
La condición que hay que cumplir se menciona detrás de la palabra while, entre paréntesis.
Las acciones que hay que ejecutar se mencionan detrás del while. Si hay mas que una instrucción que ejecutar, hay que utilizar un bloque de instrucciones, conteniendo las instrucciones entre { y } .
9.7 do ... while El ‘do ... while’ se utiliza para crear bucles, es decir repetir una acción por tanto que se cumple a una condición.
La condición que hay que cumplir se menciona detrás de la palabra while, entre paréntesis, y termina con punto coma ';'.
Las acciones que hay que ejecutar se mencionan detrás del do. Si hay mas que una instrucción que ejecutar, hay que utilizar un bloque de instrucciones, conteniendo las instrucciones entre { y } .
La cláusula do se puede mencionar antes de la cláusula while. En este caso, el código de la cláusula do se ejecutara una primera vez antes de verificar la condición del while, y se repetirá hasta que la condición sea falsa.
Ejemplo:
int miNumero = 1;
do {System.out.println("El número actual es "+ ++miNumero);
while (miNumero < 5);
}
9.8 for El for se utiliza para crear bucles un número fijo de veces.
©Copyright Cédric Simon, 2005­2012
Versión 2.2
Reproducción prohibida Curso de programación con Java – Nivel básico
Pagina 23 / 32
La condición que hay que cumplir se menciona detrás de la palabra for, entre paréntesis, y tiene tres diferente partes, separadas por ‘;’. Cada parte es opcional, pero el ‘;’ tiene que ser mencionado mismo si la parte esta vacía.
La primera parte sirve a declarar un variable (usualmente un int) y/o asignarle un valor original.
La segunda parte contiene la condición de ejecución. Usualmente la variable inicializada > o < que otro int o valor fija.
La tercera parte se utiliza para mencionar el incremento o decremento eventual.
Las acciones que hay que ejecutar se mencionan detrás del for. Si hay mas que una instrucción que ejecutar, hay que utilizar un bloque de instrucciones, conteniendo las instrucciones entre { y } .
Ejemplo:
for (int i = 0; i < 3; i++) { System.out.println(i);}
Existe un for 'simplificado' para recorer arreglos, que funciona así:
String a [] = {“uno”,”dos”,”tres”};
for (String s : a) { System.out.println(s);}
9.9 break La instrucción break permite de salir de una bucle o de abandonar las sentencias de ejecución de un switch. Ejemplo:
int ii = 5;
for (int i = 0; i < 10; i++) {
if (i>ii) break;
System.out.println(i);}
9.10 continue La instrucción continue solo se puede usar en bucles, y permite de saltar directamente a la bucle siguiente, sin ejecutar el resto del código de la bucle corriente.
Ejemplo:
int ii = 5;
for (int i = 0; i < 10; i++) {
if (i==ii) continue;
System.out.println(i); } 9.11 Operador ternario Otro operador condicional es el operador "?:" (o ternario).
Ejemplo:. Asignación de un valor predeterminado
// Ejemplo de uso de: el Operador Ternario
int edad=5;
String tipo = ((edad<=18) ? "Joven” : "Adulto”);
©Copyright Cédric Simon, 2005­2012
Versión 2.2
Reproducción prohibida Curso de programación con Java – Nivel básico
Pagina 24 / 32
10 Paquetes, clases, y métodos
10.1 Objetivo del capitulo Al fin de este capitulo, el alumno será capaz entender el uso y de crear paquetes, clases, constructores, y métodos, y de definirles los derechos de acceso necesarios.
10.2 Paquetes 10.2.1
Uso Los paquetes se utilizan para reunir clases que pertenecen a una misma aplicación, o que tienen algunas característica juntas.
Por ejemplo, se puede crear un paquete para las clases específicas de una aplicación, y otros paquetes para clases generales, como útiles, conexión a la base de datos, etc...
El nombre del paquete tiene que corresponder con el nombre de la carpeta en la cual la clase del paquete esta guardada. Un paquete puede contener varios niveles. Por ejemplo, el paquete itc.nica se encontrara bajo la capeta ‘itc’, que se encontrara bajo la carpeta ‘nica’.
Por defecto, las clases de un mismo paquete tienen acceso a todas las clases de este mismo paquete. Este derecho de acceso puede ser modificado, utilizando modificadores de acceso, para permitir el uso de una clase por clases de otros paquetes, o restringir el uso de una clase. Veremos los modificadores de acceso más adelante.
La primera instrucción de un archivo de una clase que permanece a un paquete es: package
<nombre del paquete>;
Para compilar un paquete, hay que estar en la raiz de la aplicación, y compilar con javac nombre_del_paquete/NombreDeLaClase.java
Para llamar a una clase de un paquete hay que estar en la raiz de la aplicación y llamar a java nombre_del_paquete.NombreDeLaClase
1.1.1
Importación de paquetes Cuando se requiere un objeto de otro paquete, se necesita poner el nombre entero del paquete delante el nombre del objeto, separado con ‘.’.
Por ejemplo, para llamar al objeto Mitest del paquete test : test.Mitest
Para no tener que marcar siempre el nombre del paquete delante el objeto, hay que importar el paquete.
Para importar un paquete, hay que mencionar la palabra import y el nombre del paquete mas ‘;’. La importación solo se puede hacer entre la declaración del paquete del código (si pertenece a un paquete) y la declaración de la clase principal del código.
Ejemplo:
package dbaccess;
import java.sql.*;
public class Readdb {...}
©Copyright Cédric Simon, 2005­2012
Versión 2.2
Reproducción prohibida Curso de programación con Java – Nivel básico
Pagina 25 / 32
10.3 Clases 10.3.1
Declaración y uso La clase es la unidad principal del Java. Una clase sirve para definir un objeto, y contiene sus constructores y sus métodos.
Son los constructores y métodos que permitirán inicializar y manejar el objeto.
La clase puede tener variable o constantes que serán accesibles por todos los constructores y métodos de la clase.
Una clase tiene derechos de acceso que se pueden modificar. Los derechos de accesos estarán explicados mas adelante en este capitulo.
Una clase tiene que ser guardadas bajo un archivo que tenga el mismo nombre que la clase.
Ejemplo:
class Test {
private int miNumero; //variable de clase
public Test (){ // constructor
miNumero=1;
}
public void método_1 (){ // metodo
miNumero+=10;
...
}
}
10.4 Constructores El constructor es la parte de la clase que permite inicializar la clase. Por defecto una clase tiene un constructor sin argumento y sin acción.
El constructor se puede definir y sobre definir para ejecutar ciertas acciones y/o para aceptar parámetros (argumentos) al inicializar la clase.
El constructor se define como un método que tiene el mismo nombre que la clase, y que no puede regresar valores ni extender otro método.
Una misma clase puede tener varios constructores.
Ejemplo:
class Test {
int miCampo; // variable de clase
public Test (int miNumero){ // mi constructor
miCampo = miNumero; // variable de clase inicializada
}
}
10.5 Métodos 10.5.1
Declaración y uso Un método es una característica de una clase. Un método permite ejecutar acciones sobre el objeto (class).
Son los métodos que hacen todas las acciones de una aplicación, así que contienen la mayoría del código.
©Copyright Cédric Simon, 2005­2012
Versión 2.2
Reproducción prohibida Curso de programación con Java – Nivel básico
Pagina 26 / 32
Un método tiene, como la clase, derecho de acceso que se pueden modificar, y también se necesita indicar si el método regresa alguna valor o no, y cual es el tipo de valore regresada.
Los métodos pueden aceptar cero, uno, o varios parámetros de entrada, y pueden ser sobre definida, es decir tener un mismo nombre con diferentes números o tipos de parámetros. El método main (public static void main(String[] args)) es un método especial que esta llamado por la JVM al iniciar una aplicación. El método main puede aceptar cero, uno, o varios parámetros, que son cadenas de caracteres.
Ejemplo:
class Test {
public int calculo (int númeroDado){ // metodo de calculo
return númeroDado+5;
}// fin de metodo
public static void main(String[] args) { // metodo principal
Test miTest = new Test();
int resultado = miTest.calculo(12);
System.out.println(resultado);
}// fin de metodo Main
} // fin de clase
10.6 Modificadores de acceso 10.6.1
Acceso por defecto Por defecto, una clase, método, o dato es visible en este paquete.
10.6.2
private El método, o dato es visible solo en esta clase.
10.6.3
public La clase, método, o dato es visible en todo el universo.
10.6.4
protected La clase, método, o dato es visible en este paquete y las subclases de esta clase en cualquier paquete.
©Copyright Cédric Simon, 2005­2012
Versión 2.2
Reproducción prohibida Curso de programación con Java – Nivel básico
Pagina 27 / 32
11 Polimorfismo, encapsulamiento, y herencia
11.1 Objetivo del capitulo Al fin de este capitulo, el alumno será capaz de entender, identificar situaciones que necesitan, y utilizar el polimorfismo, el encapsulamiento, y la herencia.
11.2 Polimorfismo El polimorfismo es la capacidad que tiene Java de diferenciar métodos que tiene un mismo nombre gracias a sus parámetros, o de inicializar una clase utilizando en constructor correspondiente a los parámetros pasados.
Ejemplo:
public class TestPoli {
static int numeroGeneral;
public TestPoli() {
numeroGeneral=5;
} // fin constructor
public TestPoli(int inicializaNo) {
numeroGeneral=inicializaNo;
} // fin constructor
public static void main(String[] args) { // metodo principal
TestPoli miTest= new TestPoli(Integer.parseInt(args[0]));
System.out.println("Constructon con (int). numeroGeneral = "+numeroGeneral);
TestPoli miTest2= new TestPoli();
System.out.println("Constructon sin argumento. numeroGeneral = "+numeroGeneral);
} // fin de clase
}// fin de metodo main
11.3 Encapsulamiento El encapsulamiento permite de esconder la estructura interna de un objeto, y solo enseñar lo necesario.
El encapsulamiento se hace utilizando modificadores de acceso, paquetes, clases internas, clase abstractas, y/o interfaces.
11.3.1
Clases internas Una clase interna es una clase definida dentro de otra clase, llamada clase contenedora. 11.3.1.1 Clases e inerfaces internas static Se conocen también como clases anidadas (nested clases). Las clases e interfaces
internas static sólo pueden ser creadas dentro de otra clase al máximo nivel, es decir directamente en el bloque de definición de la clase contenedora y no en un bloque más interno. Este tipo de clases internas se definen utilizando la palabra static. Todas las interfaces internas son implícitamente static.
En cierta forma, las clases internas static se comportan como clases normales en un package. Para utilizar su nombre desde fuera de la clase contenedora hay que precederlo por el nombre de la clase contenedora y el operador punto (.) Este tipo de relación entre clases se puede utilizar para agrupar varias clases dentro de una clase más general.
©Copyright Cédric Simon, 2005­2012
Versión 2.2
Reproducción prohibida Curso de programación con Java – Nivel básico
Pagina 28 / 32
11.3.1.2 Clases internas miembro Las clases internas miembro o simplemente clases internas, son clases definidas al máximo nivel de la clase contenedora (directamente en el bloque de diminución de dicha clase), sin la palabra static. Se suelen llamar clases internas miembro o simplemente clases internas. No existen interfaces internas de este tipo.
Otras clases diferentes de las clases contenedora e interna pueden utilizar directamente los objetos de la clase interna, sin cualificarlos con el objeto o el nombre de la clase contenedora. Las clases internas pueden también ser private y protected (las clases normales sólo pueden ser public y package). Esto permite nuevas posibilidades de encapsulación.
Los métodos de las clases internas acceden directamente a todos los miembros, incluso private, de la clase contenedora.
También la clase contenedora puede acceder –si dispone de una referencia­ a todas las variables miembro (incluso private) de sus clases internas.
Una clase interna puede acceder también a los miembros (incluso private) de otras clases internas definidas en la misma clase contenedora.
11.3.1.3 Clases internas locales Las clases internas locales o simplemente clases locales no se declaran dentro de otra clase al máximo nivel, sino dentro de un bloque de código.
Las principales características de las clases locales son las siguientes:
1. Como las variables locales, las clases locales sólo son visibles y utilizables en el bloque de código en el que están definidas. Los objetos de la clase local deben ser creados en el mismo bloque en que dicha clase ha sido definida. De esta forma se puede acercar la definición al uso de la clase.
2. Las clases internas locales tienen acceso a todas las variables miembro y métodos de la clase contenedora. Pueden ver también los miembros heredados, tanto por la clase interna local como por la clase contenedora.
3. Las clases locales pueden utilizar las variables locales y argumentos de métodos visibles en ese bloque de código, pero sólo si son final5 (en realidad la clase local trabaja con sus copias de las variables locales y por eso se exige que sean final y no puedan cambiar).
4. Un objeto de una clase interna local sólo puede existir en relación con un objeto de la clase contenedora, que debe existir previamente.
5. La palabra this se puede utilizar en la misma forma que en las clases internas miembro, pero no las palabras new y super.
Restricciones en el uso de las clases internas locales:
1. No pueden tener el mismo nombre que ninguna de sus clases contenedoras.
2. No pueden definir variables, métodos y clases static.
3. No pueden ser declaradas public, protected, private o package, pues su visibilidad es siempre la de las variables locales, es decir, la del bloque en que han sido definidas.
Las clases internas locales se utilizan para definir clases Adapter en el AWT.
11.3.1.4 Clases anónimas Las clases anónimas son muy similares a las clases internas locales, pero sin nombre. En las clases internas locales primero se define la clase y luego se crean uno o más objetos. En las clases anónimas se unen estos dos pasos: Como la clase no tiene nombre sólo se puede crear un único objeto, ya que las clases anónimas no pueden definir constructores. Las clases anónimas se utilizan con mucha frecuencia en el AWT para definir clases y objetos que gestionen los eventos de los distintos componentes de la interface de usuario. No hay interfaces anónimas.
©Copyright Cédric Simon, 2005­2012
Versión 2.2
Reproducción prohibida Curso de programación con Java – Nivel básico
11.3.2
Pagina 29 / 32
Clases abstractas Una clase abstracta es una clase que contiene una o más métodos abstractas, los cuales no son implementados. Una clase abstracta no se puede instanciar.
Las clases abstractas tienen que ser implementadas utilizando la herencia. Ellas sirven de superclase a las clases (o interfaces) concretos. Las clases concretas sobredefine los metodos, implementándolos.
11.3.3
Interfaces Una interfaz es una clase de las cuales todos los métodos son abstractos.
Por defecto, todos los miembros de una interfaz son públicos, abstractos, static y final.
Como las clases abstractas, las interfaces tiene que ser implementadas utilizando la herencia.
11.4 Herencia Las clases pueden tener herencia de otra clase, lo que permite de recuperar ciertas características (métodos y datos) de un objeto, y modificar o agregar otras. Los constructores no de hereden y deben ser definidos de nuevo en la clase, pero pueden llamar al constructor de la clase madre con la palabra 'super'. Por defecto, el constructor llama al constructor sin argumento de la clase madre, a menos que se llama a otro constructor explicitamente.
Entonces:
● Cuando no tengo constructor de la clase hija definido, el constructor sin argumento de la clase madre esta llamado en primer lugar, si existe (si no, error de compilacion).
● Cuando un constructor de la clase hija no llama a ningun constructor de la clase madre, el constructor sin argumento de la clase madre esta llamado en primer lugar, si existe .
● Cuando llamo de un constructor de la clase hija hacia un constructor otro que el sin argumento de la clase madre, el constructor sin argumento de la clase madre no esta llamado
Así se puede crear subclases que extienden la clase de base.
La herencia se utiliza mucho en Java, y especialmente en el web (servlets) y el GUI (AWT, Swing).
La clase de base puede ser una clase fundadora de Java (Java Foundation Class) o una clase personal.
Ejemplo:
package test;
public class TestHerencia {
int numeroGeneral;
TestHerencia () {numeroGeneral = 5;}
public void adjunta_100() {numeroGeneral += 100; }
} // fin de clase TestHerencia
package test;
public class TestHerenciaExt extends TestHerencia{
public TestHerenciaExt () {super();}
public void adjunta_50() {numeroGeneral += 50;
}
public static void main(String[] args) { // metodo principal
TestHerenciaExt miTest = new TestHerenciaExt ();
System.out.println("Valor inicial de numeroGeneral = " +
miTest.numeroGeneral);
miTest.adjunta_100();
System.out.println("Valor de numeroGeneral = " +
miTest.numeroGeneral);
miTest.adjunta_50();
System.out.println("Valor de numeroGeneral = " +
miTest.numeroGeneral);
} // fin de metodo main
}
©Copyright Cédric Simon, 2005­2012
Versión 2.2
Reproducción prohibida Curso de programación con Java – Nivel básico
Pagina 30 / 32
12 Tratamiento de excepciones
Existen tres categorías de errores en Java. Los errores de compilación, los errores de ejecución, y los errores de lógica. Los errores de ejecución 12.1 Objetivo del capitulo Al fin de este capitulo, el alumno será capaz identificar los tipos de errores que se pueden encontrar en un código en Java, y tratarlos con éxito.
12.2 Errores de compilación Los errores de compilación son las errores de sintaxis. Al compilar el código, Java detecta los errores que no respetan la sintaxis del Java, así como errores de conversión de tipos, uso de variables no declaradas, etc...
Estas errores no permiten que se creara el archivo .class, el código compilado, porque este código nunca podría funcionar.
12.3 Errores de lógica Los errores de lógica son errores debido a un diseño incorrecto del código. Por ejemplo, un bucle que nunca termina, una falta de ortografía en un texto, una formula de cálculo equivocada,...
12.4 Errores de ejecución Los errores de ejecución son excepciones que Java no pudo detectar al compilar el código. Por ejemplo, un número dividido por cero, o llamar a una base de datos que no existe, etc...
Existen dos clases de excepciones: la clase Error y la clase Exception. Las excepciones de la clase Error abarcan fallos graves que el programa no va a poder recuperar y, por tanto, no pueden ser captadas.
Las excepciones de la clase Exception son excepciones que Java puede capturar. Existen varias subclases, como Runtime
Exception, IOException, InterruptedException,...
Las excepciones de la clase Excepcion pueden ser atrapada a dentro del código, para tomar acción correctiva y así evitar que la error sea fatal para la aplicación. Para poder atrapar un error, hay que utilizar un bloque try en conjunto con uno o varios bloques catch y/o un bloque finally.
12.4.1
throws Todos los errores que se pueden originar en un método, excepto los errores del tipo Error y RuntimeException tienen que ser capturadas o declarada en una cláusula throws al declarar el método. Todas las errores, afuera de las de tipo RuntimeError tienen que ser capturados en el código, o descartadas utilizando throws.
La cláusula throws permite descarta las errores, es decir no capturarlas. Este es el comportamiento por defecto de Java, pero en caso que Java espera que una error sea atrapada de manera explicita (por ejemplo cuando se usa el SQL), la cláusula throws permite ignorar la error y compilar el código.
©Copyright Cédric Simon, 2005­2012
Versión 2.2
Reproducción prohibida Curso de programación con Java – Nivel básico
Pagina 31 / 32
Ejemplo: public Readdb() throws Exception {
Class.forName("org.firebirdsql.jdbc.FBDriver");
...
}
12.4.2
try El código de ejecución en el cual se podría producir una error de ejecución se pone en un bloque try. Este es el código de ejecución normal, en caso que no sucede errores.
Un bloque try nunca puede salir solo. Siempre tiene que se acompañado de un bloque catch y/o finally, mismo si el bloque finally esta vacío.
Ejemplo:
try
12.4.3
{
.....
}
catch El bloque catch permite atrapar errores que podrían suceder en el bloque previo try.
Un bloque try puede tener varios bloque catch para atrapar varias errores. En este caso, las errores mas especifica tienen que estar mencionadas en primer lugar. Las errores generales en ultimo lugar.
Ejemplo:
catch (ArithmeticException e){
...
}
catch (Exception e){
...
}
12.4.4
finally El bloque finally se utiliza para colocar instrucciones que el código tendrá que realizar después del try y el catch. No importa si ocurrió excepción o no, el bloque finally siempre se va a realizar (con excepciones cuando se trabaja con hilos de ejecuciones y daemon).
Ejemplo:
int miResultado = 0;
try {
miResultado = 12/0;
}
catch (ArithmeticException e){
System.out.println(e);
}
catch (Exception e){
System.out.println("Otro error");
}
finally {
miResultado+=1;
System.out.println(miResultado);
}
©Copyright Cédric Simon, 2005­2012
Versión 2.2
Reproducción prohibida Curso de programación con Java – Nivel básico
Pagina 32 / 32
13 Ejercicios
1) Crear, compilar, y ejecutar la 'primera aplicación
2) Declarar variable de los diferente tipo, asignarles valor e imprimir el valor.
3) Declarar una constante e imprimir el valor. Probar de cambiar su valor luego y ver que es lo que pasa.
4) Declara un entero, incrementarlo, decrementarlo, hacer operaciones con el.
5) Probar la prioridad de operadores
6) Probar la conversión implícita y explicita.
7) Declarar un float con valor=10152466.25. Declara un byte que es igual a 5 + el float.
8) Probar métodos del objeto Math y consultar la documentación del objeto.
9) Adjuntar comentario de una y de varias líneas un su código.
10) Imprimir la fecha y hora del sistema.
11) Imprimir el numero de segundas de la hora corriente del sistema.
12) Crear un arreglo conteniendo los numeros de 1 a 10, e imprimir los números 5 y 10 utilizando el arreglo.
13) Crear un arreglo de String con nombre, apellido, y fecha de nacimiento de 3 empleados. Imprimir los nombres y fecha de nacimiento del tercer empleado.
14) Declarar une entero y asignarle un valor. Si el valor < 5 imprimir "Pequeño", si no imprimir "Grande".
15) Declarar une entero y asignarle un valor. Si el valor = 1 imprimir "no", = 2 imprimir "Dos", =3 imprimir "3", si no imprimir "Ni uno, ni dos, ni tres".
16) Declarar un entero = 0. Mientras el entero <5, imprimir su valor y incrementarlo de uno.
17) Declarar un entero = 10. Mientras el entero >5, imprimir su valor y decrementarlo de uno, pero imprime por lo menos una vez su valor.
18) Crear una bucle que se ejecuta 10 veces utilizando un entero que va de 10 a 19 incrementándose. Imprimir en cada bucle el valor del entero, menos cuando es igual a 15.
19) Crear un objeto Auto con atributo privados de marca, modelo, y color. Crear los métodos para cambiar y leer los valores de los atributos. Crear tres instancias de Auto. Cambiarles sus atributos y imprimirlos.
20) Crear un paquete 'personal' que contiene:
o Una clase 'Persona', con variables privadas para contener el nombre, apellido, sexo, fecha de nacimiento, y metodos para asignar o recuperar el valor de las variables, asi como para imprimir los valores con formalidad.
- Una clase 'Empleado', que extiende 'Persona', y que le adjunta variables privadas: funccion, salario, si tiane contrato temporal o no, y metodos para asignar o recuperar el valor de las variables, asi como para imprimir todas los valores con formalidad.
Crear un paquete 'Empresa' que contiene:
- Una clase 'main' que va a crear tres empleados, y imprimir sus datos. 21) Crear una clase Prueba con método main que declara un entero igual a cinco dividido
por cero (5/0). Ejecutarla y atrapar la error.
©Copyright Cédric Simon, 2005­2012
Versión 2.2
Reproducción prohibida