FunLenProJav PDF

FUNDAMENTOS DEL LENGUAJE DE
PROGRAMACIÓN JAVA - ADSI
FAVA - Formación en Ambientes Virtuales de Aprendizaje
SENA - Servicio Nacional de Aprendizaje. 1

Fundamentos del lenguaje de programación JAVA
ESTRUCTURA DE CONTENIDOS Pág.
Introducción ................................................................................................. 3
Mapa de contenido ..................................................................................... 4
Desarrollo de contenidos ............................................................................ 5
1. Generalidades de JAVA ............................................................................ 5
2. El lenguaje JAVA ..................................................................................... 7
2.1 Elementos basicos del lenguaje ............................................................. 7
2.2 Palabras reservadas ............................................................................. 7
2.3 Identificadores ....................................................................................... 8
2.4 Tipos de datos ...................................................................................... 9
2.5 Variables ............................................................................................. 13
2.6 Operadores ......................................................................................... 13
3 Objetos y clases ................................................................................... 17
3.1 Acceso a los objetos ......................................................................... 18
3.2 Cualidades de los objetos ................................................................. 22
4 Excepciones .......................................................................................... 29
5. Arreglos ................................................................................................ 31
5.1 Solucion al problema con el uso de arreglos .................................... 34
5.2 Declaracion, creacion y uso de arreglos .............................................. 37
5.3 Recorrido de un arreglo ....................................................................... 41
5.4 Arreglos de objetos ............................................................................. 43
5.5 Colecciones y generics ...................................................................... 45
5.5.1 Uso de la clase arraylist ................................................................. 47
5.5.2 Uso de la clase linkedlist ................................................................ 49
5.5.3 Uso de la clase hashset .................................................................. 51
5.5.4 Uso de la clase treeset .................................................................... 54
5.5.5 Los generics y las colecciones ...................................................... 56
Glosario ..................................................................................................... 62
Bibliografía ................................................................................................. 63
Control del documento .............................................................................. 64

FUNDAMENTOS DEL LENGUAJE DE PROGRAMACIÓN JAVA
Introducción
Este material busca que el aprendiz adquiera una fundamentación en cuanto al lenguaje de
programación en JAVA, para ello se toman como objetivos básicos los siguientes tópicos:
Fundamentos del lenguaje, Declaración y control de acceso, Operadores y asignaciones,
control de Flujo, Objetos, Clases, Manejo de Excepciones, Arreglos y colecciones. La
apropiación de estos conocimientos, además de facilitar el proceso de aprendizaje, le
permitirá aplicar este conocimiento en el proyecto de sistema de información propuesto.

Mapa de contenido
CONTIENE
ELEMENTOS BÁSICOS DEL LENGUAJE

COMO
PALABRAS RESERVADAS IDENTIFICADORES TIPOS DE DATOS VARIABLES Y OPERADORES OBJETOS Y CLASES EXCEPCIONES ARREGLOS
QUE UTILIZAN
SENA - Servicio Nacional de Aprendizaje.

ARRAYLIST LINKEDLIST HASHSET TREESET
4
Desarrollo de contenidos
1. Generalidades de JAVA
De acuerdo con lo visto en el material de introducción al lenguaje JAVA donde se trataron

términos como, Código fuente, compilador, Bytecode, API, JRE (Entorno de Ejecución) y
Al momento de diseñar el archivo fuente (java class), se debe tener en cuenta los
siguientes tres elementos de “primer nivel”:
Una declaración de paquete (opcional): un paquete contiene los enlaces con la toda la
información de las clases. Se reconoce su uso mediante la palabra reservada package.
Cualquier declaración de importaciones (opcional): esta importación se realiza con la

palabra import. Algunas de las clases importadas comúnmente son:
• java.lang
• java.awt
• java.applet
• java.net
• java.io
• java.util
También existen las librerías javax que incluyen clases mejoradas en la versión java
2.0 y otras funcionalidades como las de bases de datos y conexiones con diferentes
protocolos.
• javax.sql
• javax.lang
• javax.swing
• javax.tools
• javax.security
• javax.rmi
• javax.net
Estas clases se encuentran en una serie de bibliotecas estándar, reconocidas

comúnmente como el API (Application Programming Interface) de JAVA. Estas bibliotecas
van actualizándose en la medida que se lanza una nueva versión del JDK y son una
referencia para los programadores en JAVA.

Declaración de la clase o de la interface, normalmente se utiliza la declaración de la clase.
Ejemplo:
Figura 1. Declaración de clase

2. El lenguaje JAVA
2.1 Elementos básicos del lenguaje
del código construido, teniendo en cuenta los tres estilos permitidos por JAVA para los
comentarios:
• Comentarios de Una sola línea:

// comment on one line
• Comentarios de múltiples líneas:

/* comment on one or more lines */
• Comentarios para documentación Automática:

/** documenting comment */
2.2 Palabras reservadas
relaciona algunas de las palabras reservadas; es importante aclarar que dependiendo

de la versión de JAVA se tendrá el listado de palabras reservadas:
Figura 2. Palabras Reservadas

2.3 Identificadores
El nombre dado a una variable, clase o método se conoce como “Identificador”. En

el material de introducción a JAVA se trabajó este tópico y algunos ejemplos sobre la
declaración de ellos son:
identifier
username
user_name
_sys_var1
$change
En esta ocasión, se complementa la declaración de variables aplicando los modificadores

final y static. Estos modificadores se utilizan, para crear variables que no modifican su
valor durante la ejecución del programa.
Las constantes, también pueden ser de tipo numérico, boolean, carácter o String.
Un ejemplo de declaración de constante declarada puede ser:
Figura 3. Declaración de constante

2.4 Tipos de datos
En JAVA se manejan dos tipos de datos, los primitivos y los referenciados.
Los tipos de datos primitivos son los siguientes:
Figura 4. Tipos de datos
Los tipos de datos referenciados son cualquier variable declarada de un tipo no primitivo.
Ejemplo de estos tipos de datos son: los arreglos, las clases y las interfaces.
Creación y declaración de una variable de tipo referenciado
Un ejemplo para la creación de este tipo de datos sería:
Dentro de la clase MiNacimiento
public class MiNacimiento {

int dia;
int mes;
int año;

Ahora, para declarar un tipo de dato Referenciado para la variable MiNacimiento,

inicialmente se utilizará el siguiente código:
Figura 5. Tipo de datos referenciados
Si se desea crear otra variable de este mismo tipo, la instrucción a utilizar sería
MiNacimiento otroCumple;
Acceso a una variable de tipo referenciado:
Como al crear una variable de tipo referenciado, se accede a las variables que tiene la
clase original (MiNacimiento), se puede acceder a las variables dia, mes, año y a cada
í
micumple.dia=12;
micumple.mes=4;
micumple.año=1980;
Para poder utilizar en todo momento los valores asignados a estas variables, se hace
necesario que el sistema las conozca, y para ello estas variables deben ser ubicadas en
un espacio de memoria.

Ejemplo:
Figura 6. Tipos de datos
Se actúa un momento como computadoras para el código que hemos trabajado hasta el
momento:
Código construido Comportamiento

del computador
public class MiNacimiento { MiNacimiento
int dia; dia
int mes; mes
int año; año
}
MiNacimiento miCumple MiCumple

micumple.dia=05; dia=05
micumple.mes=11; mes=11
micumple.año=1980; año=1980
Figura 7. Acceso a variables referenciadas

Ejemplo de Acceso y utilización de una variable de tipo referenciado
Figura 8. Ejemplo a variables referenciadas

2.5 Variables
Son aquellas que se definen dentro de un método y son llamadas variables locales,
automáticas, temporales o variables de stack. Se crean cuando el método es ejecutado y
se destruyen cuando se finaliza el método. Las variables deben ser inicializadas antes de
usarlas, porque de lo contrario ocurre un error en tiempo de compilación.
Figura 9. Variables
2.6 Operadores
Los operadores se utilizan para realizar operaciones entre objetos, datos, identificadores
y/o constantes, y devuelven un valor.
Los operadores en JAVA se pueden dividir en las siguientes categorías:
Operadores aritméticos: un operador aritmético es aquel que permite realizar

operaciones aritméticas como suma, resta, multiplicación y división entre otras.
Figura 10. Operadores aritméticos

Operadores relacionales: un operador relacional permite comparar dos valores y

determina la relación existente entre ellos. El resultado de su utilización es siempre un
valor lógico true o false.
Figura 11. Operadores relacionales
Operadores lógicos: el uso de los operadores lógicos radica en la manera como se

evalúe una condición compuesta. El comportamiento de los operadores lógicos básicos
se muestra en la siguiente tabla:
Figura 12. Operadores lógicos
Operadores de bit: El operador de asignación básico es el igual (=) y se utiliza para

asignar un valor a otro. Un ejemplo de este operador sería:
int num1=0; Inicializar la variable num1 en 0, el tipo de esta variable es entero.
El objetivo de los operadores de asignación es minimizar la escritura de código, y para

esto JAVA proporciona varios operadores. Mediante la utilización de estos operadores
se pueden realizar operaciones aritméticas, lógicas, de bit y de asignación con un único
operador.

En el siguiente ejemplo se necesita sumar un número a una variable y almacenar el

resultado en la misma variable, como a continuación, lo que en algoritmos conocimos
como acumulador:
acu = acu + 2;
En JAVA se puede abreviar esta sentencia con el operador de atajo +=, de la siguiente
manera:
acu += 2;
La siguiente tabla muestra los operadores de asignación y su expresión equivalente:
Operador Uso Expresión Equivalente Ejemplo

Para num1 = 3
+= op1 + = op2 op1 = op1 + op2
num1 + = 2
Para num2 = 4
-= op1 - = op2 op1 = op1 - op2
num2 - = 3
Para mul = 5
*= op1 * = op2 op1 = op1 * op2
mul* = 2
Para div = 10
/= op1 / = op2 op1 = op1 / op2
div/ = 2
Para mod = 5
%= op1 % = op2 op1 = op1 % op2
mod% = 2
Figura 13. Operadores de asignación

La siguiente pantalla muestra ejemplos para la codificación de estos operadores y el

resultado de las operaciones.
Figura 14. Codificación de operadores de asignación
Figura 15. Prueba del programa

3 Objetos y clases
Es necesario antes de entrar a programar objetos y clases aclarar los siguientes conceptos
de la programación orientada a objetos.
• Clase: en general, una clase es una representación abstracta de algo. En inglés, se

definiría como “is a template or model”. Un ejemplo de una clase sería “Carro”. En
otras palabras la clase es la representación o estructura del objeto que se quiere
modelar. Para crear una clase en JAVA se necesita un archivo que contenga la palabra
clave reservada class, seguía de un nombre permitido y un bloque delimitado por dos
llaves para el cuerpo de la clase.
Un ejemplo sería: public class ClsDefinitiva { }
Una clase consta de: campos, propiedades, métodos y eventos.
Los campos son similares a las variables debido a que se pueden leer o definir
directamente, un ejemplo de campos sería: color, marca, número de puertas, cilindraje,
entre otros.
En términos de nuestro día a día, los campos serían los datos que tienen en común la
mayoría de los carros.
Las propiedades se definen igual que los campos, y se implementan mediante los
procedimientos de las propiedades Get y Set.
Los métodos representan las acciones que puede realizar un objeto. En inglés, un
método se podría definir como “the operations for a class and Methods must belong
to a class.”
Por ejemplo, la clase “Carro” puede tener definidos los métodos “Arranque,” “Velocidad”
y “Parada”.
• Objeto: es un ejemplo utilizable de ese algo representado por la clase. En ingles se

podría definir como “An object is created based on that model”, es la instancia de la
clase.
Un ejemplo de un objeto sería: “MiCarro”

3.1 Acceso a los objetos
El operador punto(.): se utiliza para acceder a las variables de instancia y a los métodos
contenidos en un objeto, mediante su referencia a objeto.
Sintaxis:
referencia_a_objeto.nombre_de_variable_de_instancia
Un ejemplo de la codificación con el operador punto sería:
MiNacimiento micumple = new MiNacimiento micumple.dia = 12;
Referencia this: dentro de los valores por referencia, Java incluye uno especial llamado
“this”. El valor this se utiliza dentro de cualquier método, para referirse al objeto actual y
se refiere al objeto sobre el que ha sido llamado el método actual.
Se puede utilizar “this” siempre que se requiera una referencia a un objeto del tipo
de una clase actual.
Un ejemplo de este valor sería:
public void setNot1(double not1) {

this.not1=not1;
}
Para apropiar el tema de clases, objetos y para iniciarse en el manejo de métodos se

toma un ejemplo como referente denominado el mundo académico, donde normalmente
se calcula la definitiva de una materia a la cual se le aplican cuatro notas, Una propuesta
de este algoritmo sería:
Datos de entrada: nota1, nota2, nota3, nota4

Proceso: cálculo para la definitiva
Dato de Salida: definitiva

El Diagrama de flujo sería:
Figura 16. Flujo del programa

Con base al anterior diagrama de flujo se construye la siguiente imagen

Explicación Líneas de Código en JAVA

Línea Explicación
3 Explicación del Código
Declaración de Variables. Recordar que dependiendo del tipo de dato a utilizar se
5 al 9
declara la variable. Para este caso fue doublé porque los datos a recibir son decimales.
12 Declaración del método
13 Proceso a realizar en el método, para este caso el cálculo de la definitiva.
14 Presentación por pantalla del resultado de la operación.
15 Finalización del mètodo
Declaración del método main. Recordemos que el método main es aquel que
17
permite ejecutar la clase.
18 Creación del objeto. Para este caso el nombre del objeto es def
19 al 22 Asignación de valores a cada uno de los campos, es decir a los datos de
entrada del algoritmo.
Llamar al método, para que el sistema ejecute los procesos incluidos en él.
23
Para este caso líneas de código 13 y 14.
24 Finalización del método main.
25 Finalización de la clase.
La declaración de los métodos tiene la siguiente estructura:
[ ]: Argumentos opcionales (Parámetros por valor)
< >: Argumentos obligatorios (Parámetros por referencia)

<modiers> <return_type> <name> ([<argument_list>])
[throws <exception>] {
<block>
}
Ejemplo 1
def=(not1+not2+not3+not4)/4;
Este método no contiene argumentos porque los paréntesis que están después del
nombre del método están vacíos.
De igual manera este método no retorna ningún dato, porque es de tipo void. Solo visualiza
información.

Ejemplo 2
public double getNot1() {
return not1;
}
Este método retorna un dato de tipo double. Esto se sabe en el momento de la declaración
public “double”.
Este método No tiene argumentos.
NOTA: Todo método que maneje un <return_type> diferente de void, debe retornar algún
dato, es decir debe incluir la instrucción return.
3.2 Cualidades de los objetos
La verdadera programación orientada a objetos requiere que los objetos admitan tres
cualidades:
Herencia:
• Describe la capacidad de crear clases nuevas a partir de una clase existente.

• Cuando la clase hereda de UNA sola clase se llama “Herencia Simple”.
• La nueva clase hereda todos los atributos y métodos de la clase base, siempre y
cuando éstos se hayan declarados como heredables.
• La nueva clase también se puede personalizar con atributos y métodos adicionales.
• Para indicar que una clase deriva de otra, se usa el término extends.
• En nuestro día a día, la herencia se puede relacionar con las jerarquías.
Figura 19. Herencia en clases
Para dar un ejemplo se recuerda un caso de la vida diaria, las finanzas las manejamos
mediante diferentes tipos de cuentas, que pueden ser Corriente o de Ahorro, en este
ejemplo básico representemos la herencia.

Figura 20. Ejemplo de cuenta
Pensemos en los movimientos que se hacen con una cuenta: Consignar, Retirar, Consultar
Saldo.
Figura 21. Ejemplo de clase modelo

Figura 22. Explicación de cuenta
¿Qué es lo que hace diferente a una cuenta de ahorros y una cuenta corriente? Que a la
cuenta corriente le pueden asignar un sobregiro y también una chequera.
En eso orden de ideas, la clase cuentaCorriente, tendría acceso a todos los métodos de
la Clase cuenta (consignar, conSaldo, retirar) y la variable saldo que está en la misma
clase. Lo que se debería hacer crear un método sobregiro y uno chequera.
El método sobregiro necesitaría un argumento para el valor del Sobregiro y el método

chequera dos argumentos, uno para el numero inicial del cheque y otro para el número
final del cheque. Y ese es precisamente el objetivo de la herencia.
El código para implementar la clase cuentaCorriente, como clase hija de cuenta sería:
Figura 23. Clase cuenta corriente

Figura 24. Explicación de cuenta corriente
Polimorfismo:
• Habilidad de tener diferentes formas.

• Posibilidad de tener varias clases que se pueden usar de forma intercambiable.
• Permite usar elementos con los mismos nombres, sin importar qué tipo de objeto esté
en uso en ese momento.
• Un objeto tiene solo una forma.
• Una variable de referencia tiene muchas formas.
• Una variable de referencia puede referirse a objetos con diferentes formas.
Sobrescritura de un método
• Desde la clase hijo, modificar comportamientos heredados de la clase Padre

• Modificar el cuerpo de un método, para realizar una funcionalidad de diferente manera.
• En la clase hija se crea el mismo método con diferentes funcionalidades de la clase
padre. Este método debe tener el mismo nombre, el mismo tipo de retorno y la misma
cantidad de argumentos y tipo de los mismos.
Para este aspecto se toma como referencia la clase denominada Gerente que hereda
de la clase padre llamada empleado, esta clase empleado tiene los atributos nombre y
salario, así como un método llamado visualizaDatos, cuya función es visualizar los datos
de la clase padre.

La clase “padre” empleado tiene el siguiente código
Figura 25. Explicación de clase empleado
La clase “gerente” gerente tiene el siguiente código:
Figura 26. Clase gerente

Figura 27. Explicación de la clase gerente
Ahora para visualizar la información de cada una de las clases (padre e hijo) y para
reforzar la creación de objetos, se crea una clase con método main, recordando que las
clases que contienen método main, son aquellas que se pueden ejecutar, en donde se
crean dos objetos o variables de tipo referenciado, una que hace referencia a la clase
Empleado (padre) y otra que hace referencia a la clase Gerente (hijo).
El código de esta clase es el siguiente:
Método sobreescrito en el objeto
Figura 28. Explicación de la clase principal

En JAVA existe la palabra reservada super, cuya función es invocar el método de la clase
Figura 29. Sobrecarga de un método
Sobrecarga de un método
igual, pero la lista de argumentos es diferente, bien sea por su cantidad o por el tipo de
datos que recibe.
Un ejemplo de sobrecarga sería:
Encapsulamiento: oculta los campos implementados en la clase, esto implica el

tratamiento de los campos como una única unidad. Para que el usuario acceda a los
datos, obligatoriamente debe usar una interface. El mantenimiento del código se hace
más fácil.

4 Excepciones
Las excepciones son otra forma más avanzada de controlar el flujo de un programa, se
utilizan para asegurar el correcto funcionamiento del programa y en el caso de un posible
error se llamaría la excepción.
Estas son representadas por la clase Exception. Los problemas graves, que
normalmente se tratan como “fatal error”, son errores que se han dejado de tratar con
excepciones. El ejemplo más común de errores generados por falta de excepciones es el
“RuntimeException”. La API de JAVA presenta excepciones ya predefinidas que pueden
ser usadas en los diferentes métodos. Estas excepciones se pueden asimilar con un
condicional, solo que las palabras utilizadas para este proceso son try, catch.
Una excepción puede ocurrir cuando:
• El archivo que intenta abrir no existe

• La conexión de red se ha interrumpido
• Los operadores que se están utilizando están fuera del rango.
• No se encuentra la clase que está intentando cargar
Se revisa el siguiente código:
Figura 30. Generación de excepción

Al ejecutar el programa se genera este, y se debe a que no se implementó una excepción.

El código ideal sería el siguiente con manejo de excepciones (try, catch y finally).
Figura 31. Bloque de protección try catch

5. Arreglos
Los arreglos son estructuras de almacenamiento en memoria que permiten llevar a cabo
la lectura, el procesamiento o consulta de conjuntos de datos dentro de una aplicación
de software. Este recurso es de uso común entre los desarrolladores de software, pero
para entender mejor su utilidad, a continuación se presenta un enunciado de un problema
donde se requiere el uso de arreglos.
Problema: Los arreglos son estructuras de almacenamiento en memoria que permiten

llevar a cabo la lectura, el procesamiento o consulta de conjuntos de datos dentro de
una aplicación de software. Este recurso es de uso común entre los desarrolladores de
software, pero para entender mejor su utilidad, a continuación se presenta un enunciado
de un problema donde se requiere el uso de arreglos.
Fácilmente se puede deducir que el problema se debe descomponer en 2 partes:
• Se debe determinar cuántos empleados ganan un salario superior al salario promedio

anteriormente calculado.
• Se requiere calcular el salario promedio de los empleados de la empresa.
Figura 31. Estructura de programa sin arreglos

El programa anterior calcula correctamente el salario promedio de todos los empleados

de la empresa (punto 1 del análisis), pero ¿cómo determinar cuántos de esos empleados
ganan un salario superior al salario promedio? (punto 2 del análisis).
Primer intento
Se debe determinar cuántos empleados ganan un salario superior al salario promedio

anteriormente.
Figura 32. Solución primer intento
La solución propuesta es equivocada porque el salario de cada empleado es leído en

la misma variable salario en la línea 14 del programa, por lo tanto, en la línea 22 del
programa, el valor que se tiene en la variable salario es el salario del último empleado
solamente, los salarios de los empleados anteriores se han perdido.

Una pequeña prueba de escritorio muestra como el valor de la variable salario es

actualizado cada vez que se lee un nuevo salario.
Figura 33. Prueba de escritorio
Segundo intento
Se requiere calcular el salario promedio de los empleados de la empresa.
Figura 34. Segundo intento

La segunda solución propuesta incluye en la línea 26 un nuevo código que permite leer
el salario de cada empleado. Esta propuesta es equivocada porque el salario de cada
empleado ya había sido leído en la línea 14 del programa. Esta solución además del doble
trabajo que significa leer en 2 oportunidades el salario de cada empleado, es insegura,
ya que al volver a leer el salario de cada empleado, el usuario podría ingresar salarios
diferentes a los usados para calcular el salario promedio.
5.1 Solución al problema con el uso de arreglos
La segunda solución propuesta incluye en la línea 22 un nuevo código que permite leer
nuevamente el salario de cada empleado. Esta propuesta es equivocada porque el salario
de cada empleado ya había sido leído en la línea 14 del programa. Esta solución además
del doble trabajo que significa leer en 2 oportunidades el salario de cada empleado, es
insegura, ya que al volver a leer el salario de cada empleado, el usuario podría ingresar
salarios diferentes a los usados para calcular el salario promedio.
Figura 35. Explicación de la clase principal
Los arreglos permiten realizar el almacenamiento de un conjunto de valores en posiciones

de memoria diferentes para que cada valor pueda ser accedido en cualquier momento
durante la ejecución de un programa.
La solución al problema consiste en definir un arreglo para almacenar los diferentes

salarios de los empleados de la empresa, a partir de ellos calcular el salario promedio
y posteriormente acceder al arreglo de salarios para determinar cuántos de ellos son
superiores al salario promedio.

Solución final usando un arreglo
Figura 36. Solución utilizando un arreglo
Código fuente.
package arreglos;
import javax.swing.*;
public class Arreglos {
public static void main(String[] args) {

//1. Calcular el salario promedio de los empleados
double salario[];//Declaración del arreglo de Salarios
double sumSalario=0,salarioPromedio;
int totalEmpleados, cantEmplSalSuperior=0;
totalEmpleados=Integer.parseInt(JOptionPane.showInputDialog(null,”Ingrese cantidad de empleados”));
salario= new double[totalEmpleados];//Creación del arreglo de Salarios
for(int i=0;i<totalEmpleados;i++)
{
//Lectura de cada posición (i) del arreglo (en cada posición se almacena un salario diferente
salario[i]=Double.parseDouble(JOptionPane.showInputDialog(null,”Ingrese salario del empleado”));
sumSalario=sumSalario+salario[i];
}
salarioPromedio=sumSalario/totalEmpleados;
JOptionPane.showMessageDialog(null, “El salario promedio es “+salarioPromedio);
//2. Determinar cuántos empleados ganan un salario superior al promedio
for(int i=0;i<totalEmpleados;i++)
{
//Uso del arreglo de salarios, previamente cargado en la línea 18
if(salario[i] > salarioPromedio)
{
cantEmplSalSuperior++;
}
}
JOptionPane.showMessageDialog(null, “El numero de empleados con salario superior al promedi es “+cantEmplSalSuperior);

}

Ejecutando el programa
Figura 37. Ejecución del programa utilizando arreglos

5.2 Declaración, creación y uso de arreglos
La declaración de un arreglo es similar a la declaración de una variable, la sintaxis es la

siguiente:
Figura 38. Declaración de un arreglo
En el ejercicio anteriormente resuelto, se aprecia la declaración de un arreglo de tipo

doublé llamado salario:
Figura 39. Declaración del arreglo

Después de declarar un arreglo, este debe crearse, para ello se usa la palabra reservada
almacenamiento de valores.
Figura 40. Creación de un objeto arreglo
En el ejercicio anteriormente resuelto, se aprecia la creación de un arreglo llamado salario
Figura 41. Creación de un objeto arreglo
La primera posición de un arreglo en Java es la posición 0 y la última es n-1, donde n es

el tamaño del arreglo.

En Java también es posible declarar y crear un objeto en la misma línea de código,

ejemplo:
Figura 42. Creación de otros arreglos
El siguiente ejemplo muestra la declaración, creación, inicialización y consulta de un

arreglo llamado edad de 5 posiciones de tipo entero:
Figura 43. Ejemplo de creación de arreglos

Figura 44. Resultados del programa
También es posible inicializar un arreglo en la misma línea donde es declarado y creado.

El siguiente ejemplo declara, crea e inicializa en la misma línea de código un arreglo de 5
posiciones de tipo cadena con los nombres de 5 personas diferentes, posteriormente se
imprime el contenido del arreglo:
Figura 45. Creación e inicialización de un arreglo


5.3 Recorrido de un arreglo
Como se ha visto anteriormente, el recorrido de un arreglo requiere de un ciclo para pasar

por cada una de sus posiciones; en el programa anterior, se aprecia el uso del ciclo for
para acceder a todas las posiciones del arreglo nombres.
Pero ¿qué podría ocurrir al intentar acceder a una posición inexistente de un arreglo?.
Este es un error común en programación, véase en el siguiente ejemplo:
Figura 46. Ejemplo para la generación de la excepción
Figura 47. Generación de excepción

El arreglo anterior es de 5 posiciones, las cuales están comprendidas desde la posición 0

hasta la posición 4. Al intentar acceder la posición 5 del arreglo, se lanzará una excepción
de tipo.
Existe una forma más segura de recorrer un arreglo, esta es utilizando un ciclo especial
conocido como el ciclo for each.
Sintaxis:
Permite recorrer todas las posiciones del arreglo, a través de la variable
Recorre todas las posiciones del arreglo nombre a través de la variable x

El ejercicio anterior, puede ser modificado para realizar el recorrido del arreglo de manera
segura mediante el uso del ciclo for each:
Figura 48. Recorrido de una arreglo con for each

5.4 Arreglos de los objetos
De la misma manera como se declaran, crean, inicializan y acceden los arreglos de tipos
de datos primitivos se hace con los arreglos de objetos. De hecho el arreglo de tipo String
es un arreglo de objetos. Pero para entender mejor este aspecto, vamos a implementar
un programa que cree un arreglo de objetos asociados a una clase personalizada.
El siguiente es el código de la clase Alumno:
Figura 49. Clase Alumno

El siguiente programa, muestra la manera de crear un arreglo de objetos de la clase

Alumno y su respectivo procesamiento:
Figura 50. Ejemplo de recorrido for each
El programa 4, muestra la manera de crear un arreglo de objetos de la clase

Alumno y su respectivo procesamiento:
Línea 5 : Declaración y creación de un arreglo de 3 posiciones de tipo Alumno
Línea 6,7,8 : Declaración y creación de un arreglo de 3 posiciones de tipo Alumno
Línea 10 : Configuración del ciclo for each para recorrer todas las posiciones del arreglo
de tipo Alumno llamado estudiante a través de una variable llamada al.
Línea 12 : Acceso a los métodos de cada objeto almacenado en el arreglo

Al ejecutar el programa, se obtiene el siguiente resultado:
Figura 51. Recorrido de un arreglo con for each
5.5 Colecciones y generics
Los arreglos son una excelente herramienta de programación, principalmente cuando la

cantidad de posiciones del mismo se mantiene constante, sin embargo, al momento de
incluir más elementos dentro de un arreglo o al momento de querer eliminar posiciones
del mismo, los arreglos son ineficientes.
En JAVA existen otras estructuras de almacenamiento conocidas como colecciones. Una

colección permite almacenar información en memoria de manera dinámica, es decir,
permite el aumento o disminución del tamaño de la colección de acuerdo con la necesidad
de la aplicación.
Collection
List Set
ArrayList LinkedList HashSet TreeSet

Figura 52. Estructuras de objeto collection

Elemento Tipo Descripción

Collection Interface Define un conjunto de métodos comunes a las demás
interfaces o clases que se derivan de la interfaz
Collection.
List Interface Maneja de manera ordenada los elementos introducidos
de acuerdo con el orden de inserción. Permite elementos
duplicados.
Set Interface Colección desordenada de objetos. No permite elementos
duplicados.
ArrayList Clase Clase concreta que implementa la interfaz List, esta
clase se basa en un arreglo dinámico. Permite un acceso
rápido a los elementos de la colección, pero es lenta para
la inserción o eliminación de objetos.
LinkedtList Clase Clase concreta que implementa la interfaz List, esta clase
se basa en una lista enlazada. Es muy útil cuando la cantidad
de elementos de la colección es muy variable. El acceso a un
elemento particular de la colección es más lento.
HashSet Clase Clase concreta que implementa la interfaz Set. Los
elementos de esta clase no permiten duplicados y no se
almacenan en orden no determinado.
TreeSet Clase Clase concreta que implementa la interfaz Set. Los
elementos de esta clase no permiten duplicados y sus
elementos se ordenan de manera ascendente.
NOTA: para usar cualquier elemento de la API de Colecciones, se debe implementar el

paquete java.util

5.5.1 Uso de la clase Arraylist
Para comprender mejor el uso de la clase ArrayList, se presenta el siguiente ejemplo:

package colecciones;
import java.util.ArrayList;
public class Colecciones {
/**
* @param args the command line arguments
*/
// TODO code application logic here
//Crea, llena e imprime una lista con números
ArrayList listaNums= new ArrayList();
listaNums.add(8);
listaNums.add(3);
listaNums.add(5);
listaNums.add(2);
listaNums.add(3);
System.out.println(“Lista de numeros: “+listaNums);
//------------------------------------------
//Crea, llena e imprime una lista con nombres
ArrayList listaNombres= new ArrayList();
listaNombres.add(“Juan”);
listaNombres.add(“Pedro”);
listaNombres.add(“Carlos”);
listaNombres.add(“Daniel”);
System.out.println(“Lista de nombres:”+listaNombres);
//------------------------------------------
//Obtener un elemento particular de la lista
System.out.println(“Numero posicion 2:”+listaNums.get(2));
System.out.println(“Nombre posicion 0:”+listaNombres.get(0));
//Reemplazar un elemento de la lista
listaNums.set(0,15);
listaNombres.set(0,”Claudia”);
//Las listas quedan así:
La clase ArrayList está basada en un arreglo dinámico y permite gestionar su contenido a

través de posiciones específicas. Por implementar la interfaz List, el almacenamiento de
sus datos se da de acuerdo con el orden de inserción y permite los elementos repetidos.

Figura 53. Uso de la clase arraylist

5.5.2 Uso de la clase Linkedlist
Para comprender mejor el uso de la clase LinkedList, se presenta el siguiente ejemplo:

import java.util.LinkedList;
/**
*
* @author Usuario
*/
/**
*/
LinkedList listaNums= new LinkedList();
listaNums.add(8);
listaNums.add(3);
listaNums.add(5);
listaNums.add(2);
listaNums.add(3);
//Insertar un nuevo dato al inicio de la lista
listaNums.addFirst(10);
//------------------------------------------
LinkedList listaNombres= new LinkedList();
//Insertar un nuevo dato al inicio de la lista
listaNombres.addFirst(“Julian”);
//------------------------------------------
//Obtiene y remueve el primer elemento de la lista
System.out.println(“Elemento removido:”+listaNums.poll());
System.out.println(“Elemento removido:”+listaNombres.poll());

Figura 54. Uso de la clase linkedlist
La clase LinkedList está basada en una lista doblemente enlazada, en la que se conoce
cuál es el primer elemento y último elemento de la lista, por esta razón, se facilitan las
operaciones que se hacen al principio o al final de la lista como la inserción o eliminación
de elementos. Por implementar la interfaz List, el almacenamiento de sus datos se da de
acuerdo con el orden de inserción y permite los elementos repetidos.

5.5.3 Uso de la clase Hashset
Para comprender mejor el uso de la clase HashSet, se presenta el siguiente ejemplo:

import java.util.HashSet;
/**
*
* @author Usuario
*/
/**
*/
HashSet listaNums= new HashSet();
listaNums.add(8);
listaNums.add(3);
listaNums.add(5);
listaNums.add(2);
listaNums.add(3);
//------------------------------------------
HashSet listaNombres= new HashSet();
//------------------------------------------
//Remueve un elemento de la lista
listaNums.remove(5);
listaNombres.remove(“Pedro”);

Figura 55. Uso de la clase hashset
La clase HashSet basa la organización de sus elementos en un algoritmo especial,

mediante el cual, cada elemento posee una clave o identificador no manipulable a través
del cual se realiza el ordenamiento y búsqueda de los elementos de la colección. Por
esta razón el orden de los elementos almacenados en la colección es indeterminado.
Al implementar la interfaz Set, la clase HashSet tiene la característica de no permitir
elementos duplicados.

Figura 56. Salida uso de la clase hashset

5.5.4 Uso de la clase Treeset
Para comprender mejor el uso de la clase TreeSet, se presenta el siguiente ejemplo:

import java.util.TreeSet;
/**
*
* @author Usuario
*/
/**
*/
//Crea, llena e imprime un conjunto con números
TreeSet listaNums= new TreeSet();
listaNums.add(8);
listaNums.add(3);
listaNums.add(5);
listaNums.add(2);
listaNums.add(3);
//------------------------------------------
//Crea, llena e imprime un conjunto con nombres
TreeSet listaNombres= new TreeSet();
//------------------------------------------
//Elementos mayores a un elemento dado
System.out.println(“Numeros mayores o iguales a 3:”+listaNums.tailSet(3));
System.out.println(“Nombres mayores o iguales a Daniel:”+listaNombres.tailSet(“Daniel”));
//Se muestran los datos en orden descendente
System.out.println(“Numeros en orden descendente: “+listaNums.descendingSet());
System.out.println(“Nombres en orden descendente:”+listaNombres.descendingSet());

Figura 56. Uso de la clase treeset
La clase TreeSet mantiene siempre los elementos de la colección de manera ordenada.

Al implementar la interfaz Set, la clase TreeSet tiene la característica de no permitir
elementos duplicados. Posee un conjunto de métodos que permiten aprovechar la ventaja
de mantener siempre los datos ordenados.

5.5.5 Los generics y las colecciones
Los datos que se almacenan en una colección siempre son de tipo Object, esto significa
que teóricamente en una colección podemos almacenar cualquier dato. Esto aunque a
primera vista parece una ventaja, en la práctica presenta dificultades, en primer lugar por
la falta de seguridad en los datos almacenados y en segundo lugar, por la necesidad de
hacer casting o conversiones en los datos almacenados para pasarlos del tipo Object a
su tipo real.
Figura 57. Uso de la clase hashset
El programa anterior compila sin problemas, porque una colección recibe datos de cualquier
tipo, debido a que todos los datos al interior de la colección son tratados como datos de
tipo Object. Esta característica no le permite al programador tener un control en tiempo
de compilación sobre la integridad de los datos almacenados. Si se intenta recuperar la
información de la lista en diferentes variables, se generan errores de compilación, por
incompatibilidad de tipo de datos:

Figura 58. Error en la generación de colecciones
Las instrucciones anteriores generan error de compilación.
Para permitir recuperar los datos en su plenitud, es necesario hacer casting de datos, es
decir, realizar una conversión de datos entre el tipo Object (que es por defecto el tipo de
dato de cualquier elemento al interior de una colección) y el tipo de dato deseado.

Figura 59. Casting de datos en JAVA
Para tener mayor control sobre los datos que se almacenan en una colección y para
evitar la necesidad de realizar una gran cantidad de casting a la hora de trabajar con
colecciones, a partir de la versión 5 de Java se incluye el concepto de Generics. Los
generics permiten asignarle a una colección un tipo de dato predeterminado. La sintaxis
para la definición de una colección con Generics es la siguiente:

Figura 60. Error al no usar generics
En la línea 23 se define una colección y se especifica que solo almacenará datos de tipo
entero, usando Generics. En la línea 23 se intenta agregar un dato de otro tipo, con lo
cual se genera un error en tiempo de compilación:

package generics;
import java.util.ArrayList;
import java.util.LinkedList;
/**
*
* @author Usuario
*/
public class Generics {
/**
*/
//Se crea una colección de tipo entero para
//el almacenamiento y procesamiento de numeros
ArrayList<Integer> listaNums = new ArrayList<Integer>();
listaNums.add(2);
listaNums.add(7);
listaNums.add(5);
//Se crea una colección de tipo string para
//el almacenamiento y procesamiento de cadenas de caracteres
LinkedList<String> listaCiudades = new LinkedList<String>();
listaCiudades.add(“Manizales”);
listaCiudades.add(“Medellin”);
listaCiudades.add(“Cali”);
//Se crea una colección de tipo Alumno para
//el almacenamiento y procesamiento de Alumnos
ArrayList<Alumno> alumnos = new ArrayList<Alumno>();
alumnos.add(new Alumno(“Andres”,3.2));
alumnos.add(new Alumno(“Julian”,4.2));
alumnos.add(new Alumno(“Carlos”,4.9));
//Procesamiento de los datos almacenados en las colecciones
//sin necesidad de casting
int a=listaNums.get(0);
String b=listaCiudades.get(0);
Alumno c=alumnos.get(0);
System.out.println(“El primer numero es “+a);
System.out.println(“La primera ciudad es “+b);
System.out.println(“El alumno “+c.getNombre()+” obtuvo una nota de “+c.getNota());

Figura 61. Uso de generics

Glosario
Abstraction (abstracción): propiedad y/o técnica de software que oculta los detalles
de la implementación. Java soporta abstracción de clases y abstracción de métodos. La
abstracción de métodos se define separando el uso de un método sin conocer como está
implementado ese método. Si decide combinar la implementación, el programa cliente
será afectado. De modo similar la abstracción de clases oculta la implementación de la
clase del cliente.
Acoplamiento (coupling): medida del grado en el que un objeto o componente depende

de otro. Bajo acoplamiento minimiza las dependencias y es una indicación de un buen
diseño.
Agregación (aggregation): relación en la que un objeto se compone o está construido

de uno o más objetos, de modo que la colección completa representa un todo. Las
relaciones de agregación se especifican entre clases y se reflejan en instancias de objetos
Algoritmo (algorithm) Método que describe cómo se resuelve un problema en término de
las acciones que se ejecutan y especifica el orden en que se ejecutan estas acciones.
Los algoritmos ayudan al programador a planificar un programa antes de su escritura en
un lenguaje de programación.
Array (array, vector, lista): objeto contenedor que almacena una secuencia indexada de
los mismos tipos de datos. Normalmente los elementos individuales se referencian por el
valor de un índice. El índice es un valor entero que , suele comenzar, en 0 para el primer
elementos, 1 para el segundo y así sucesivamente.
Clase (clase): colección encapsulada de datos y operaciones que actúan sobre los
datos. El concepto de clase es fundamental en programación orientada a objetos. Una
clase consta de métodos y datos. Los métodos de una clase definen el conjunto de
operaciones permitidas sobre los datos de una clase (sus atributos). Una clase puede
tener muchas instancia de la clase u objetos.
Encapsulamiento, encapsulación (encapsulation): localización y protección de las

características internas y estructura de un objeto. Combinación de métodos y datos en
una única estructura de datos. En Java se conoce como clase.
Función (function): construcción matemática a la que se pueden aplicar valores y que

devuelve un resultado.
Herencia (inheritance): una relación entre clases en que una subclase se extiende
desde una superclase.
Mensaje (message): una petición enviada a un objeto que solicita ejecutar una operación
determinada. El mensaje incluye un nombre y una lista opcional de parámetros.

Bibliografía
Deitel, H. & Deitel, P. (2004). Como programar en JAVA. México: Pearson Educación.

Control del documento

FunLenProJav PDF

Caricato da

Informazioni sul documento

Titolo originale

Copyright

Formati disponibili

Condividi questo documento

Condividi o incorpora il documento

Opzioni di condivisione

Hai trovato utile questo documento?

Questo contenuto è inappropriato?

Copyright:

Formati disponibili

FunLenProJav PDF

Caricato da

Copyright:

Formati disponibili

FUNDAMENTOS DEL LENGUAJE DE

PROGRAMACIÓN JAVA - ADSI

FAVA - Formación en Ambientes Virtuales de Aprendizaje

SENA - Servicio Nacional de Aprendizaje. 1

ESTRUCTURA DE CONTENIDOS Pág.

FAVA - Formación en Ambientes Virtuales de Aprendizaje

SENA - Servicio Nacional de Aprendizaje. 2

FUNDAMENTOS DEL LENGUAJE DE PROGRAMACIÓN JAVA

FAVA - Formación en Ambientes Virtuales de Aprendizaje

SENA - Servicio Nacional de Aprendizaje. 3

ELEMENTOS BÁSICOS DEL LENGUAJE

SENA - Servicio Nacional de Aprendizaje.

De acuerdo con lo visto en el material de introducción al lenguaje JAVA donde se trataron

Cualquier declaración de importaciones (opcional): esta importación se realiza con la

Estas clases se encuentran en una serie de bibliotecas estándar, reconocidas

FAVA - Formación en Ambientes Virtuales de Aprendizaje

SENA - Servicio Nacional de Aprendizaje. 5

Declaración de la clase o de la interface, normalmente se utiliza la declaración de la clase.

Figura 1. Declaración de clase

FAVA - Formación en Ambientes Virtuales de Aprendizaje

SENA - Servicio Nacional de Aprendizaje. 6

2.1 Elementos básicos del lenguaje

• Comentarios de Una sola línea:

• Comentarios de múltiples líneas:

• Comentarios para documentación Automática:

2.2 Palabras reservadas

relaciona algunas de las palabras reservadas; es importante aclarar que dependiendo

Figura 2. Palabras Reservadas

FAVA - Formación en Ambientes Virtuales de Aprendizaje

SENA - Servicio Nacional de Aprendizaje. 7

El nombre dado a una variable, clase o método se conoce como “Identificador”. En

En esta ocasión, se complementa la declaración de variables aplicando los modificadores

Un ejemplo de declaración de constante declarada puede ser:

Figura 3. Declaración de constante

FAVA - Formación en Ambientes Virtuales de Aprendizaje

SENA - Servicio Nacional de Aprendizaje. 8

2.4 Tipos de datos

En JAVA se manejan dos tipos de datos, los primitivos y los referenciados.

Los tipos de datos primitivos son los siguientes:

Figura 4. Tipos de datos

Creación y declaración de una variable de tipo referenciado

Un ejemplo para la creación de este tipo de datos sería:

Dentro de la clase MiNacimiento

public class MiNacimiento {

FAVA - Formación en Ambientes Virtuales de Aprendizaje

SENA - Servicio Nacional de Aprendizaje. 9

Ahora, para declarar un tipo de dato Referenciado para la variable MiNacimiento,

Figura 5. Tipo de datos referenciados

Acceso a una variable de tipo referenciado:

FAVA - Formación en Ambientes Virtuales de Aprendizaje

SENA - Servicio Nacional de Aprendizaje. 10

Figura 6. Tipos de datos

Código construido Comportamiento

MiNacimiento miCumple MiCumple

FAVA - Formación en Ambientes Virtuales de Aprendizaje

SENA - Servicio Nacional de Aprendizaje. 11

Ejemplo de Acceso y utilización de una variable de tipo referenciado

Figura 8. Ejemplo a variables referenciadas

FAVA - Formación en Ambientes Virtuales de Aprendizaje

SENA - Servicio Nacional de Aprendizaje. 12

Los operadores en JAVA se pueden dividir en las siguientes categorías:

Operadores aritméticos: un operador aritmético es aquel que permite realizar

Figura 10. Operadores aritméticos