Documentos de Académico
Documentos de Profesional
Documentos de Cultura
AP07 OA FunLenProJava
AP07 OA FunLenProJava
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
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.
CONTIENE
COMO
PALABRAS RESERVADAS IDENTIFICADORES TIPOS DE DATOS VARIABLES Y OPERADORES OBJETOS Y CLASES EXCEPCIONES ARREGLOS
QUE UTILIZAN
4
Fundamentos del lenguaje de programación JAVA
Desarrollo de contenidos
1. Generalidades de JAVA
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.
• 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
Ejemplo:
2. El lenguaje JAVA
del código construido, teniendo en cuenta los tres estilos permitidos por JAVA para los
comentarios:
2.3 Identificadores
identifier
username
user_name
_sys_var1
$change
Las constantes, también pueden ser de tipo numérico, boolean, carácter o String.
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.
Si se desea crear otra variable de este mismo tipo, la instrucción a utilizar sería
MiNacimiento otroCumple;
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:
Se actúa un momento como computadoras para el código que hemos trabajado hasta el
momento:
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.
acu = acu + 2;
En JAVA se puede abreviar esta sentencia con el operador de atajo +=, de la siguiente
manera:
acu += 2;
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.
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”.
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
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.
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”.
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.
La verdadera programación orientada a objetos requiere que los objetos admitan tres
cualidades:
Herencia:
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.
Pensemos en los movimientos que se hacen con una cuenta: Consignar, Retirar, Consultar
Saldo.
¿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 código para implementar la clase cuentaCorriente, como clase hija de cuenta sería:
Polimorfismo:
Sobrescritura de un método
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.
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).
En JAVA existe la palabra reservada super, cuya función es invocar el método de la clase
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.
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.
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.
Primer intento
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.
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.
Código fuente.
package arreglos;
import javax.swing.*;
public class Arreglos {
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++;
}
}
Ejecutando el programa
Después de declarar un arreglo, este debe crearse, para ello se usa la palabra reservada
almacenamiento de valores.
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:
Existe una forma más segura de recorrer un arreglo, esta es utilizando un ciclo especial
conocido como el ciclo for each.
Sintaxis:
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.
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.
List Set
/**
* @param args the command line arguments
*/
public static void main(String[] args) {
// 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”);
listaNombres.add(“Carlos”);
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í:
System.out.println(“Lista de numeros: “+listaNums);
System.out.println(“Lista de nombres:”+listaNombres);
/**
* @param args the command line arguments
*/
public static void main(String[] args) {
// TODO code application logic here
//Crea, llena e imprime una lista con números
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);
System.out.println(“Lista de numeros: “+listaNums);
//------------------------------------------
//Crea, llena e imprime una lista con nombres
LinkedList listaNombres= new LinkedList();
listaNombres.add(“Juan”);
listaNombres.add(“Pedro”);
listaNombres.add(“Carlos”);
listaNombres.add(“Daniel”);
listaNombres.add(“Carlos”);
//Insertar un nuevo dato al inicio de la lista
listaNombres.addFirst(“Julian”);
System.out.println(“Lista de nombres:”+listaNombres);
//------------------------------------------
//Obtiene y remueve el primer elemento de la lista
System.out.println(“Elemento removido:”+listaNums.poll());
System.out.println(“Elemento removido:”+listaNombres.poll());
//Las listas quedan así:
System.out.println(“Lista de numeros: “+listaNums);
System.out.println(“Lista de nombres:”+listaNombres);
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.
/**
* @param args the command line arguments
*/
public static void main(String[] args) {
// TODO code application logic here
//Crea, llena e imprime una lista con números
HashSet listaNums= new HashSet();
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
HashSet listaNombres= new HashSet();
listaNombres.add(“Juan”);
listaNombres.add(“Pedro”);
listaNombres.add(“Carlos”);
listaNombres.add(“Daniel”);
listaNombres.add(“Carlos”);
System.out.println(“Lista de nombres:”+listaNombres);
//------------------------------------------
//Remueve un elemento de la lista
listaNums.remove(5);
listaNombres.remove(“Pedro”);
//Las listas quedan así:
System.out.println(“Lista de numeros: “+listaNums);
System.out.println(“Lista de nombres:”+listaNombres);
/**
* @param args the command line arguments
*/
public static void main(String[] args) {
// TODO code application logic here
//Crea, llena e imprime una lista con números
//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);
System.out.println(“Lista de numeros: “+listaNums);
//------------------------------------------
//Crea, llena e imprime un conjunto con nombres
TreeSet listaNombres= new TreeSet();
listaNombres.add(“Juan”);
listaNombres.add(“Pedro”);
listaNombres.add(“Carlos”);
listaNombres.add(“Daniel”);
listaNombres.add(“Carlos”);
System.out.println(“Lista de nombres:”+listaNombres);
//------------------------------------------
//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());
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.
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:
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.
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:
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 {
/**
* @param args the command line arguments
*/
public static void main(String[] args) {
//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());
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.
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.
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.