Curso Java2 Basico

32

Click here to load reader

description

Manual del curso de Java Básico en SolucionJava.comPDF actualizado disponible en http://solucionjava.com/manuales_gratis.php

Transcript of Curso Java2 Basico

Page 1: Curso Java2 Basico

Curso de programación en Java

(Versión 6, JDK 1.6.0)

Nivel básicoManual del alumno

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

 Solu

cionJ

ava.com  Ing. C

edric Simon – T

el: 2268 0974 – Cel: 8888 2387 – E

mail:  ce

dric@

solu

cion

jav

a.co

m – W

eb: ww

w.solucionjava.com

Page 2: Curso Java2 Basico

Curso de programación en Java – Nivel básico Pagina 2 / 32

1 Índice1 Í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 

Page 3: Curso Java2 Basico

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 

Page 4: Curso Java2 Basico

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 

Page 5: Curso Java2 Basico

Curso de programación en Java – Nivel básico Pagina 5 / 32

2 Introducción al curso2.1 Objetivo de este curso   En este curso vamos a ver las bases del lenguaje Java. Esta base les va a servir por cualquier tipo de aplicación que desea realizar: aplicación independiente, applet, pagina web en Java…

2.2 Manual del alumno   Este manual del alumno es una ayuda para el alumno, para tenga un recuerdo del curso. Este manual contiene un resumen de las materias que se van a estudiar durante el curso, pero el alumno debería de  tomar notas personales para completas este manual.

2.3 Ejercicios prácticos   Para captar mejor la teoría, se harán muchos ejercicios con los alumnos, para probar la teoría y verificar la integración de la materia. También, el alumno podrá copiar sus códigos en un disquete al fin del curso para llevarse, con fin de seguir la práctica en su hogar. 

2.4 Requisitos para atender a este curso   No hay requisitos para atender a este curso, pero el conocimiento de otro lenguaje de programación, y especialmente el C++, le ayudaran a entender mas rápidamente el lenguaje Java. 

Si el alumno tiene dificultades en un u otro capitulo, el debe sentirse libre de pedir explicaciones adicionales al profesor.

2.5 Soporte despues del curso   Si tienes preguntas sobre la materia del curso en tus ejercicios prácticos, puedes escribir tus preguntas a [email protected].

Para informaciones sobre otros cursos, visita el sitio web www.solucionjava.com.

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

Page 6: Curso Java2 Basico

Curso de programación en Java – Nivel básico Pagina 6 / 32

3 Introducción al Java3.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 

Nombre de plataforma Java 2 Platform Standard Edition 6.0 

J2SE 6.0 

Productos trabajando bajo la plataforma

J2SE Development Kit 6.0  JDK 6.0 J2SE Runtime Environment 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 

Page 7: Curso Java2 Basico

Curso de programación en Java – Nivel básico Pagina 7 / 32

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.

 

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

Page 8: Curso Java2 Basico

Curso de programación en Java – Nivel básico Pagina 8 / 32

4 Instalación del Java4.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 

Page 9: Curso Java2 Basico

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 

Page 10: Curso Java2 Basico

Curso de programación en Java – Nivel básico Pagina 10 / 32

5 Primera aplicación5.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 principalSystem.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!’.

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

Page 11: Curso Java2 Basico

Curso de programación en Java – Nivel básico Pagina 11 / 32

6 Características del lenguaje Java6.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 continue for new switchassert*** default goto* package synchronizedboolean do if private thisbreak double implements protected throwbyte else import public throwscase enum**** instanceof return transientcatch extends int short trychar final interface static voidclass finally long strictfp** volatileconst* 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

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

Page 12: Curso Java2 Basico

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 

Page 13: Curso Java2 Basico

Curso de programación en Java – Nivel básico Pagina 13 / 32

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

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 miChar='A';

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

Page 14: Curso Java2 Basico

Curso de programación en Java – Nivel básico Pagina 14 / 32

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

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

Page 15: Curso Java2 Basico

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 of7. ==   !=8. &9. |10. &&11. ||12. ?:13. =  *=  /=  %=  +=  ­=  >>=  >>>=  <<= &=   |=

6.10 Conversiones entre tipos   Las conversiones pueden ser automáticas o explicitas.

6.10.1 Conversión automática   Cuando expresiones utilizan varios tipos de datos operando entre ellos, Java intenta realizar conversiones automáticas de tipos. Las conversiones automáticas son posibles solamente de un tipo hasta otra que tenga igual o más grande precisión.

Las conversiones automáticas son posibles en el siguiente sentido

    char          int long float  double

   byte short

6.10.2 Conversión explicita   Cuando se precisa un estrechamiento de tipo, es necesario convertir de manera explicita los tipos de datos. Si no, se podrían generar un error de compilación, u obtener un resultado con demasiada precisión.

Las conversiones explicitas entre enteros y reales se hacen indicando en tipo deseado delante el número a convertir.

Cuidado que cuando el numero convertido es más grande que el tamaño posible para el tipo deseado (por ejemplo cambiar 123546 a tipo byte), el resultado puede ser bien extraño...

Ejemplo:float miFloat = 1.999f;int miInt = (int) miFloat;

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

Page 16: Curso Java2 Basico

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

Page 17: Curso Java2 Basico

Curso de programación en Java – Nivel básico Pagina 17 / 32

7 Cadenas de caracteres y fechas7.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 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>), ...

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

Page 18: Curso Java2 Basico

Curso de programación en Java – Nivel básico Pagina 18 / 32

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 paquetejava.util no se carga por defecto, hay que importarlo. Solo tiene dos constructores: uno sinargumento, que asigna la fecha y hora actual, y uno con un argumento long que contiene elnú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 ladocumentación Java.

Existe también un objeto Date en el paquete java.sql que se utiliza para manejar fechasdurante 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)); // 1System.out.println(cal.get(Calendar.MONTH)); // 11System.out.println(cal.get(Calendar.YEAR)); // 1996

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

Page 19: Curso Java2 Basico

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 mespos = month.length();month = month.substring(pos - 2, pos);String year = "" + cal.get(Calendar.YEAR);String currdate = day + "/" + month + "/" + year; // 01/12/1996return currdate;

}

public static void main(String[] args) { // metodo principalSystem.out.println(new GregorianCalendar().getTime());new TestFecha();

}// fin de metodo Main}

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

Page 20: Curso Java2 Basico

Curso de programación en Java – Nivel básico Pagina 20 / 32

8 Arreglos8.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, inicializado con valores "Carta 8.5 x 11", "Prescripcion US", "Prescripcion BE"};

int miArregloInt [] = new int [9]; // arreglo de 9 líneas, inicializado con ceroint 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 arregloint miNumero = miArregloInt [0]; // miNumero será igual a 5System.out.println(miArreglo2[0][0]); // imprime 1System.out.println(miArreglo2[0][2]); // imprime 3System.out.println(miArreglo2[1][2]); // imprime 6System.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 

Page 21: Curso Java2 Basico

Curso de programación en Java – Nivel básico Pagina 21 / 32

9 Decisiones y bucles9.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 

Page 22: Curso Java2 Basico

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

Page 23: Curso Java2 Basico

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 Ternarioint edad=5;String tipo = ((edad<=18) ? "Joven” : "Adulto”);

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

Page 24: Curso Java2 Basico

Curso de programación en Java – Nivel básico Pagina 24 / 32

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

Page 25: Curso Java2 Basico

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

Page 26: Curso Java2 Basico

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 calculoreturn númeroDado+5;

}// fin de metodopublic 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 

Page 27: Curso Java2 Basico

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 constructorpublic 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 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 interfacesinternas 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 

Page 28: Curso Java2 Basico

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 

Page 29: Curso Java2 Basico

Curso de programación en Java – Nivel básico Pagina 29 / 32

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

Page 30: Curso Java2 Basico

Curso de programación en Java – Nivel básico Pagina 30 / 32

12 Tratamiento de excepcionesExisten 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 

Page 31: Curso Java2 Basico

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 

Page 32: Curso Java2 Basico

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

13 Ejercicios1) Crear, compilar, y ejecutar la 'primera aplicación2) 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 operadores6) 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 divididopor cero (5/0). Ejecutarla y atrapar la error.

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