(Versión 6, JDK 1.6.

0)

 Reproducción prohibida

Versión 2.0

©Copyright Cédric Simon, 2009

 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
en Java

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

Versión 2.0

Reproducción prohibida 

Curso de programación en 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.......................................................................................................................................................................................................19
8.1 Objetivo del capitulo..........................................................................................................................................................................19
8.2 Tipos de arreglos y uso......................................................................................................................................................................19
9 Decisiones y bucles.....................................................................................................................................................................................20
9.1 Objetivo del capitulo..........................................................................................................................................................................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
©Copyright Cédric Simon, 2009

Versión 2.0

Reproducción prohibida 

Curso de programación en Java – Nivel básico

Pagina 4 / 32

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.1 Objetivo del capitulo........................................................................................................................................................................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.1 Objetivo del capitulo........................................................................................................................................................................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

©Copyright Cédric Simon, 2009

Versión 2.0

Reproducción prohibida 

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

©Copyright Cédric Simon, 2009

Versión 2.0

Reproducción prohibida 

Curso de programación en 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, 2009

Versión 2.0

Reproducción prohibida 

Curso de programación en 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, 2009

Versión 2.0

Reproducción prohibida 

Curso de programación en 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 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. 
©Copyright Cédric Simon, 2009

Versión 2.0

Reproducción prohibida 

Curso de programación en 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 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)

©Copyright Cédric Simon, 2009

Versión 2.0

Reproducción prohibida 

Curso de programación en 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, 2009

Versión 2.0

Test.

En la consola debe aparecer ‘Estoy 

Reproducción prohibida 

Curso de programación en 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, 2009

Versión 2.0

Reproducción prohibida 

Curso de programación en 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, 2009

Versión 2.0

Reproducción prohibida 

Curso de programación en 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. A los double, 
la letra ‘d’.
Ejemplos de declaración: 
float testFloat = 1.771f;
double testDouble = 1.221d;

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
©Copyright Cédric Simon, 2009

miChar='A';

Versión 2.0

Reproducción prohibida 

Curso de programación en 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 

­
++
­­
=
==
!=
<
<=
>=
>
+
*
/
%

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

©Copyright Cédric Simon, 2009

Versión 2.0

Reproducción prohibida 

Curso de programación en Java – Nivel básico

Pagina 15 / 32

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 
   byte short

6.10.2

        

int long float  double

 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, 2009

Versión 2.0

Reproducción prohibida 

Curso de programación en Java – Nivel básico

Pagina 16 / 32

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, 2009

Versión 2.0

Reproducción prohibida 

Curso de programación en 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, 2009

Versión 2.0

Reproducción prohibida 

Curso de programación en 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, 2009

Versión 2.0

Reproducción prohibida 

Curso de programación en 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, 2009

Versión 2.0

Reproducción prohibida 

Curso de programación en 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, 2009

Versión 2.0

Reproducción prohibida 

Curso de programación en 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 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 ");

©Copyright Cédric Simon, 2009

Versión 2.0

Reproducción prohibida 

Curso de programación en 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, 2009

Versión 2.0

Reproducción prohibida 

Curso de programación en 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, 2009

Versión 2.0

Reproducción prohibida 

Curso de programación en 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, 2009

Versión 2.0

Reproducción prohibida 

Curso de programación en 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, 2009

Versión 2.0

Reproducción prohibida 

Curso de programación en 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, 2009

Versión 2.0

Reproducción prohibida 

Curso de programación en 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 con (int). 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, 2009

Versión 2.0

Reproducción prohibida 

Curso de programación en 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, 2009

Versión 2.0

Reproducción prohibida 

Curso de programación en 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, 2009

Versión 2.0

Reproducción prohibida 

Curso de programación en 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, 2009

Versión 2.0

Reproducción prohibida 

Curso de programación en 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, 2009

Versión 2.0

Reproducción prohibida 

Curso de programación en 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, 2009

Versión 2.0

Reproducción prohibida 

Sign up to vote on this title
UsefulNot useful