Curso Java2 Basico

SolucionJava.
com
Reproducción prohibida
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
Manual del alumno

(Versión 6, JDK 1.6.0)
Nivel básico
en Java
Versión 2.0
©Copyright Cédric Simon, 2009
Curso de programación en 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.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, 2009 Versión 2.0 Reproducción prohibida

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.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.......................................................................................................................................................................................................19
8.2 Tipos de arreglos y uso......................................................................................................................................................................19
9 Decisiones y bucles.....................................................................................................................................................................................20
9.2 if ... else................................................................................................................................................................................................20
9.3 Comparación de objetos....................................................................................................................................................................20
9.4 Condiciones múltiples (AND y OR)..................................................................................................................................................20
9.5 switch...................................................................................................................................................................................................21
9.6 while.....................................................................................................................................................................................................21
9.7 do ... while...........................................................................................................................................................................................21
9.8 for.........................................................................................................................................................................................................21
9.9 break....................................................................................................................................................................................................22
9.10 continue.............................................................................................................................................................................................22
9.11 Operador ternario............................................................................................................................................................................22
10 Paquetes, clases, y métodos......................................................................................................................................................................23
10.1 Objetivo del capitulo........................................................................................................................................................................23
10.2 Paquetes............................................................................................................................................................................................23
10.2.1 Uso.............................................................................................................................................................................................23
1.1.1 Importación de paquetes ..............................................................................................................................................................23
10.3 Clases.................................................................................................................................................................................................24
10.3.1 Declaración y uso.......................................................................................................................................................................24
10.4 Constructores...................................................................................................................................................................................24

10.5 Métodos.............................................................................................................................................................................................24
10.5.1 Declaración y uso.......................................................................................................................................................................24
10.6 Modificadores de acceso..................................................................................................................................................................25
10.6.1 Acceso por defecto.....................................................................................................................................................................25
10.6.2 private.........................................................................................................................................................................................25
10.6.3 public..........................................................................................................................................................................................25
10.6.4 protected.....................................................................................................................................................................................25
11 Polimorfismo, encapsulamiento, y herencia...........................................................................................................................................26
11.2 Polimorfismo.....................................................................................................................................................................................26
11.3 Encapsulamiento..............................................................................................................................................................................26
11.3.1 Clases internas............................................................................................................................................................................26
11.3.2 Clases abstractas.........................................................................................................................................................................28
11.3.3 Interfaces....................................................................................................................................................................................28
11.4 Herencia............................................................................................................................................................................................28
12 Tratamiento de excepciones.....................................................................................................................................................................29
12.2 Errores de compilación....................................................................................................................................................................29
12.3 Errores de lógica..............................................................................................................................................................................29
12.4 Errores de ejecución........................................................................................................................................................................29
12.4.1 throws.........................................................................................................................................................................................29
12.4.2 try ..............................................................................................................................................................................................30
12.4.3 catch...........................................................................................................................................................................................30
12.4.4 finally.........................................................................................................................................................................................30
13 Ejercicios...................................................................................................................................................................................................31

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
cedric@solucionjava.com.
Para informaciones sobre otros cursos, visita el sitio web www.solucionjava.com.

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 Abreviación
Java 2 Platform Standard
Nombre de plataforma J2SE 6.0
Edition 6.0
J2SE Development Kit 6.0 JDK 6.0
Productos trabajando bajo la
J2SE Runtime Environment
plataforma JRE 6.0
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.

3.5.1 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.

4 Instalación del Java
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 2:
• La edición estándar de Java 2 (J2SE). Es la que vamos a utilizar.
• La edición de empresa de Java 2 (J2EE). Es una versión más amplia, para hacer aplicaciones (web) muy
grandes.
• La edición micro de Java 2 (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 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.

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 y 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)
● Jbuilder (¡versión disponible en español!) (www.borland.com/jbuilder)

5 Primera aplicación
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 static void
main(String[] args)).
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 Test. En la consola debe aparecer ‘Estoy
en main!’.

6 Características del lenguaje Java
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 continue for new switch

assert*** default goto* package synchronized
boolean do if private this
break double implements protected throw
byte else import public throws
case enum**** instanceof return transient
catch extends int short try
char final interface static void
class finally long strictfp** volatile
const* float native super while
* not used
** added in 1.2
*** added in 1.4
**** added in 5.0
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

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.

6.7.1 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. A los double,
la letra ‘d’.
float testFloat = 1.771f;
double testDouble = 1.221d;
6.7.2.1 float
El float puede contener valores decimales entre 3,4E38 y 3,4E38.
6.7.2.2 double
El double puede contener valores decimales entre 1,7E308 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';

6.7.3.1 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 Boléanos
6.7.4.1 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
Negación (unitario), resta (binario)
++ Incremento
Decremento
= Asignación
== Igualdad
!= Desigualdad
< Menos que
<= Menos o igual que
>= Mayor o igual que
> Mayor que
+ Suma
* Multiplicación
/ División
% Modulo
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
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;

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 Math.abs(<exp>)
Máximo entre 2 exp Math.max(<exp1>,<exp2>)
Número aleatorio Math.random()
Sinus Math.sin(<exp>)
Log natural Math.log(<exp>)
El entero igual o superior Math.ceil(<exp>)
El entero igual o inferio 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.

7 Cadenas de caracteres y fechas
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 miTexto = "Hola Nicaragua!";
7.3.2 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>), ...

7.3.5 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

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;
}

System.out.println(new GregorianCalendar().getTime());
new TestFecha();
}

8 Arreglos
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.
String paginaList []= {"Formato A4", // arreglo de 4, inicializado con valores
"Carta 8.5 x 11",
"Prescripcion US",
"Prescripcion BE"};
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[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:
…
System.out.println(args[0]); // imprime “Uno”
System.out.println(args[1]); // imprime “y dos”
}
…
java Test Uno "y dos"

9 Decisiones y bucles
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 cumplo’, 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 U ).
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 U, 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 ");

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 1");
case 10 : System.out.println(" Igual a 10");
break;
case 20 : System.out.println(" Igual a 20");
default : System.out.println(" Igual 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
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.

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
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”);

10 Paquetes, clases, y métodos
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 {...}

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.

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
Test miTest = new Test();
int resultado = miTest.calculo(12);
System.out.println(resultado);
} // 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.

11 Polimorfismo, encapsulamiento, y
herencia
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
TestPoli miTest= new TestPoli(Integer.parseInt(args[0]));
System.out.println("Constructon con (int). numeroGeneral = "+numeroGeneral);
TestPoli miTest2= new TestPoli();
System.out.println("Constructon con (int). numeroGeneral = "+numeroGeneral); }// fin de metodo main
} // fin de clase
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.

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.

11.3.2 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; }
TestHerenciaExt miTest = new TestHerenciaExt ();
System.out.println("Valor inicial de numeroGeneral = " +
miTest.numeroGeneral);
miTest.adjunta_100();
System.out.println("Valor de numeroGeneral = " +
miTest.adjunta_50();
System.out.println("Valor de numeroGeneral = " +
} // fin de metodo main
}

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
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.

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);
}

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.

Curso Java2 Basico

Uploaded by

Document Information

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Curso Java2 Basico

Uploaded by

Copyright:

Available Formats

SolucionJava.

Manual del alumno

©Copyright Cédric Simon, 2009 Versión 2.0 Reproducción prohibida

©Copyright Cédric Simon, 2009 Versión 2.0 Reproducción prohibida

©Copyright Cédric Simon, 2009 Versión 2.0 Reproducción prohibida

©Copyright Cédric Simon, 2009 Versión 2.0 Reproducción prohibida

©Copyright Cédric Simon, 2009 Versión 2.0 Reproducción prohibida

©Copyright Cédric Simon, 2009 Versión 2.0 Reproducción prohibida

©Copyright Cédric Simon, 2009 Versión 2.0 Reproducción prohibida

©Copyright Cédric Simon, 2009 Versión 2.0 Reproducción prohibida

©Copyright Cédric Simon, 2009 Versión 2.0 Reproducción prohibida

abstract continue for new switch

©Copyright Cédric Simon, 2009 Versión 2.0 Reproducción prohibida

©Copyright Cédric Simon, 2009 Versión 2.0 Reproducción prohibida

©Copyright Cédric Simon, 2009 Versión 2.0 Reproducción prohibida

©Copyright Cédric Simon, 2009 Versión 2.0 Reproducción prohibida

System.out.println(i++ +" y "+ --i ); // imprime 2 y 2

©Copyright Cédric Simon, 2009 Versión 2.0 Reproducción prohibida

©Copyright Cédric Simon, 2009 Versión 2.0 Reproducción prohibida

Ejemplo: String miTexto = "Hola Nicaragua!";

Por ejemplo: length(), charAt(int <indice>),substring (int <inicio>,int <final>), ...

©Copyright Cédric Simon, 2009 Versión 2.0 Reproducción prohibida

Existe también un objeto Date en el paquete java.sql que se utiliza para manejar fechas

public class TestFecha {

public String getCurrDate() {

public String getTestDate() {

©Copyright Cédric Simon, 2009 Versión 2.0 Reproducción prohibida

public static void main(String[] args) { // metodo principal

©Copyright Cédric Simon, 2009 Versión 2.0 Reproducción prohibida

©Copyright Cédric Simon, 2009 Versión 2.0 Reproducción prohibida

©Copyright Cédric Simon, 2009 Versión 2.0 Reproducción prohibida

©Copyright Cédric Simon, 2009 Versión 2.0 Reproducción prohibida

©Copyright Cédric Simon, 2009 Versión 2.0 Reproducción prohibida

La primera instrucción de un archivo de una clase que permanece a un paquete es: package <nombre del paquete>;

©Copyright Cédric Simon, 2009 Versión 2.0 Reproducción prohibida

©Copyright Cédric Simon, 2009 Versión 2.0 Reproducción prohibida

El método main (public static void main(String[] args)) es un método especial que esta llamado por la JVM al iniciar

©Copyright Cédric Simon, 2009 Versión 2.0 Reproducción prohibida

©Copyright Cédric Simon, 2009 Versión 2.0 Reproducción prohibida

©Copyright Cédric Simon, 2009 Versión 2.0 Reproducción prohibida

©Copyright Cédric Simon, 2009 Versión 2.0 Reproducción prohibida

©Copyright Cédric Simon, 2009 Versión 2.0 Reproducción prohibida

©Copyright Cédric Simon, 2009 Versión 2.0 Reproducción prohibida

©Copyright Cédric Simon, 2009 Versión 2.0 Reproducción prohibida

You might also like