Programación Orientada a Objetos

Introducción a Java

Estructura básica de un programa.

La estructura de un programa de aplicación en Java se compone de una clase1
que contiene una función main, la cual permitirá la ejecución de la clase. Inicialmente
podemos considerar una clase como un contenedor de la lógica de un programa Java.
El nombre de la clase debe coincidir con el archivo de texto que contendrá al programa
fuente en el disco, en nuestro ejemplo se debe guardar el programa con el nombre
ClaseBasica.java.

/* Use nombres
Esto es una aplicación NO un applet … significativos
*/ para su clase,
class ClaseBasica { forme el
public static void main(String[] args) { nombre con
palabras sin
//Lógica del Programa espacios e
inicie cada
} // fin del main nombre con
} // fin de la clase mayúscula.

Ejemplo
/*
* Este programa despliega en la consola el mensaje “**Salida por Consola!!!”.
*/
class ClaseBasica {
public static void main(String[] args) {
int i;
//Despliega el mensaje cuatro veces
for (i = 0; i <4; i++){
System.out.println("** Salida por Consola!!!");
}
}
}

Comentario
Observe la similitud de las instrucciones con las del lenguaje C. En el programa
se utiliza el método println del objeto System.out. Lectura recomendada:
http://www.htmlpoint.com/guidajava/index.html

1
http://www.ibiblio.org/javafaq/books/jdr/examples/6/index.html

Diego Santimateo G. 1
Programación Orientada a Objetos

Uso del Compilador Java

En esta parte del curso centraremos nuestro esfuerzo en el uso básico del
lenguaje Java evitando distractores como los IDE (ambientes integrados de desarrollo)
que serán de utilidad una vez que se dominen los fundamentos de Java. En
consecuencia, utilizaremos el ambiente DOS o de líneas de comandos, al cual
entramos por inicio – ejecutar y escribimos el comando cmd. Posteriormente nos
apoyaremos en un IDE o ambiente de desarrollo integrado 2
(http://www.programacion.com/java/articulo/jap_eclip_1/ ).

Para evitar que el compilador no JDK o J2SE o SDK : es el ambiente en el

encuentre el programa fuente conviene cual es posible desarrollar cualquier
entrar en el directorio que contiene el
aplicación Java. Este ambiente o paquete
programa fuente, para ello usemos la
instrucción CD de DOS para cambiar de incluye: El API de Java, el compilador de
directorio: Java, así como el JVM "Java Virtual

Para colocarse en el directorio raíz Machine" de la plataforma correspondiente.
use cd\

Para cambiar de unidad use unidad: Vea estructura de directorios JDK.
(ejemplo…d:)

Para entrar en una carpeta use cd nombredecarpeta

Para salir de una carpeta use cd ..

Para ver el contenido de la carpeta use dir

Puede usar type nombre de archivo para ver el contenido de un archivo de
texto.

El prompt o indicador de entrada, tiene la forma c:\>_.

Si la carpeta que contiene su programa se denomina infobjeto en el disco d,
entonces deberá usar el comando cd hasta obtener el prompt d:\infobjeto>. A
continuación escriba: java –version
Así puede verificar si su compilador esta debidamente instalado. Como respuesta se
muestra la versión del compilador (java version “1.6.0”).

Para invocar al compilador escriba javac ClaseBasica.java al lado del prompt

d:\infobjeto>, si no hay errores se creará el archivo de bytecodes ClaseBasica.class,
que puede ser ejecutado si escribimos java ClaseBasica , al lado de d:\infobjeto>.
Obsérvese que no se usa la extensión del archivo de bytecodes cuando va a ejecutar
su programa. Conviene recordar que el compilador Javac genera un programa en
código intermedio conocido como bytecode, que es traducido por la máquina virtual de
Java (JVM) en el código nativo (binario) del procesador que se esté utilizando para
hacer posible la ejecución.

Tipos de datos primitivos

En la siguiente tabla se presentan los tipos de datos primitivos de Java.
2
http://leepoint.net/notes-java/background/tools/10ide.html

Diego Santimateo G. 2
Programación Orientada a Objetos

Tipo de Observación
dato
int Entero de 4 bytes
short Entero de 2 bytes
long Entero de 8 bytes
byte Entero de 1 bytes
float Punto flotante de 4 byte
double Punto flotante de 8 byte
char Representa carácter Unicote de 2
bytes
boolean Sus posibles valores son false y
true.

A diferencia del lenguaje C las cadenas de caracteres en Java constituyen la

clase predefinida String y en consecuencia, no son del tipo char. Por otra parte, el tipo
booleano no debe confundirse con enteros como en el lenguaje C. Para declarar
constantes se usa la palabra reservada final, por ejemplo:
final float CTE = 100.05

Variables
Java tiene tres tipos de variables que son: de instancia, de clase y locales.
Las variables de instancia, se usan para guardar los atributos de un objeto
particular, se declaran en la clase pero fuera de los métodos, estas variables se crean
cuando el objeto es creado y permanecen durante la vida del objeto, están visibles para
los métodos y constructores de la clases que las contiene, usualmente se declaran
como privadas (private), lo que impide que otras clases puedan verlas o accederlas.
Las variables de clase se caracterizan porque sus valores son los mismos para
todos los objetos de una determinada clase, se declaran de la misma manera que las
de instancia, solo que son estáticas (static).
Las variables locales se declaran dentro de un método, constructor o bloque. En
el lenguaje Java, las variables locales se declaran en el momento en el que son
necesarias y no usan modificadores de acceso(public, private etc.)

Diego Santimateo G. 3
Programación Orientada a Objetos

Cadenas de caracteres
Java maneja las cadenas de caracteres como una clase, de manera que para
realizar operaciones con ellas se debe recurrir a los métodos de dicha clase, esto
significa que se utiliza el nombre de la variable, seguido de un punto, seguido del
método con sus respectivos parámetros, si existen. Las variables de cadenas no
son vectores como en C, pero cada carácter se asocia con una posición que inicia en
cero. Para acceder a una posición particular puede usar el método charAt().
Declarar una cadena es similar a la declaración de una variable de cualquier
tipo primitivo, veamos los siguientes ejemplos:

Declaraciones: Asignaciones:
int i, j, k; i = 9;
float Peso, Altura; Swt = true;
char Opcion; Opcion = ‘s’;
boolean Swt; Peso = 98.56;
String xx, Nombre; Nombre = “desconocido”

Instrucción Comentario
k = Nombre.length(); Longitud de la variable Nombre.
Nombre.equals(xx); Compara si las cadenas Nombre y xx son iguales.
System.out.println(“peso = ” + Peso); Concatena la cadena “peso =” con el valor 98.56.
Substrae de Nombre los caracteres desde la
xx = Nombre.substring(2, 5); posición 2 hasta la 4, es decir el valor de xx será
sco. Nótese que no incluye la posición 5.
El carácter d de la posición 9 de nombre será
Opcion = Nombre.charAt(i); asignado a la variable Opcion.

Para un manejo eficiente de cadenas de caracteres se recomienda consultar3:

java.util.StringBuilder. Adicionalmente revise la clase String
del Paquete java.lang.

Arreglos
Un arreglo es un objeto que almacena una colección de valores del mismo tipo,
los cuales se pueden acceder por medio de un índice o posición, tal y como se procede
en otros lenguajes orientados a procedimientos como Pascal o C. La primera posición
de un arreglo es cero y el valor usado como índice no debe ser negativo, Java verifica
automáticamente si el índice está fuera del rango permitido, según la cantidad de
posiciones declaradas para el arreglo. Los elementos de un arreglo pueden ser de un
tipo primitivo o también pueden ser objetos y siempre deben inicializarse para ser
luego utilizados. Si los elementos son números, el arreglo se inicializa con ceros, si

3
http://leepoint.net/notes-java/summaries/summary-stringbuilder.html

Diego Santimateo G. 4
Programación Orientada a Objetos

son objetos con null, si son caracteres se inicializa con /u0000 y si son boléanos con
false. La inicialización se logra al crear una instancia, como en los siguientes ejemplos:
int[] arreglox = new int[54]
boolean[][] matrizx = new boolean [10][3]
String[] nombre = new String[100];

Nótese que se ha creado un objeto de tipo entero, cuyas cuatros posiciones

quedarán con el valor cero y un arreglo de dos dimensiones o matriz de elementos
booléanos, así como un vector de cadenas. El operador new asigna la memoria
necesaria para cada objeto creado. La inicialización puede ser explícita como en el
siguiente caso:

String[] diasSemana = {“domingo”, “lunes”, “martes”, “miércoles”, “jueves”}

Como los arreglos también son objetos, podemos utilizar métodos para
manejarlos o conocer sus propiedades, por lo que recomendamos revisar la clase
java.util.Arrays.

Instrucción Comentario
k = arrreglox.length(); Cantidad de elementos de arreglox.
Se utiliza el método sort de la clase Arrays
Arrays.sort(arreglox); para ordenar el vector arreglos.
Con el método arraycopy de la clase System
podemos copiar elementos de un vector a
otro. En este caso copiamos del arreglo
System.arraycopy(vector, 3, vector2, 5, 6) ; vector, 6 elementos a partir de su posición 3,
en el arreglo vector2 iniciando en la posición
5. ¿qué puede decir de los arreglos vector y
vector2?

Diego Santimateo G. 5
Programación Orientada a Objetos

Las variables tipo arreglos son referencias (apuntadores) a arreglos, de manera

que si asignamos un arreglo a otro, será equivalente a asignar un apuntador a otro. Por
ejemplo;

Como vector1 ha sido inicializado, entonces

int[] vector1 = new int [20];
int[] vector2;
vector1 apunta al área asignada cuando se creó el
objeto con new, mientras que vector2 es NULL.
Si usamos vector2 = vector1; entonces
vector2 apunta a la misma área que vector1, por
lo tanto, cualquier cambio de elementos en uno
de ellos también se realizará en el otro. Es decir
si hacemos vector2[5]=10, vector1[5] también
quedará con el valor 10, ya que nos estamos
refiriendo a la misma área de memoria.

Jerarquía
Uno de los conceptos fundamentales en la programación orientada a objetos es la
herencia, que permite relacionar las clases de manera jerárquica; una clase padre o superclase
sobre otras clases hijas o subclases. La siguiente figura ayuda a visualizar la relación de jerarquía.

Las clases descendientes heredan de sus padres las variables, constructores y

métodos. Ellas adoptan un comportamiento particular o específico cuando le
adicionamos métodos y/o variables de instancias que la hacen diferente de su clase
padre. En consecuencia, la herencia permite definir nuevas clases basados en otras ya
existentes. En Java, la raíz del árbol de jerarquía es la clase Object de la cual derivan
todas las demás clases. ¿Qué variables y métodos tiene Object?

En el ejemplo que se desarrolla a continuación, la clase Estudiante2 es la clase

padre de la cual deriva la clase EstudianteFac . Para indicar que EstudianteFac es
una subclase de Estudiante2 se usa la palabra reservada extends en la línea que
define la clase: class EstudianteFac extends Estudiante2. La idea es que Estudiante2
agrupa a todos los estudiantes mientras que EstudianteFac se asocia con estudiantes
de una facultad y se le adicionan variables particulares como el recibo de matrícula y la
facultad.

Se puede hacer referencia a constructores y métodos de la clase padre usando

la palabra reservada super como se aprecia en el ejemplo. El ejemplo también muestra
la sobrecarga del método toString.

Diego Santimateo G. 6
Programación Orientada a Objetos

/* Ejemplo de uso de Herencia, la clase base es Estudiante2 y

* la subclase es EstudianteFac
* Aquí se detallan aspectos particulares del estudiante
*/
import java.lang.String.*; Ver también
import javax.swing.*; http://www.jtech.ua.es/plj/docs/apuntes/tema01-apuntes.htm

class UsaJerarquiaEst { http://pisuerga.inf.ubu.es/lsi/Invest/Java/Tuto/II_6.htm

public static void main(String[] args) {

String datos;
String xnom = JOptionPane.showInputDialog("Indique Nombre");
String xced = JOptionPane.showInputDialog("Indique Cédula");
String xfac = JOptionPane.showInputDialog("Indique Facultad");
String xedad = JOptionPane.showInputDialog("Indique Edad");
String xrec = JOptionPane.showInputDialog("Indique Recibo");

int valor = Integer.parseInt(xedad);

EstudianteFac est= new EstudianteFac(xfac, xnom, xced, xrec, valor);

datos = est.toString(); // método de Estudiantefac que sobrecarga al de la clase super

if (est.pagoMatricula())
datos += "\n Recibo de pago:" + est.getRecibo();
else
datos += "\n ***Estudiante NO ha pagado matricula";

System.out.println("******** --------- *********");

System.out.println("\n"+datos);
System.out.println("\n******** --------- *********");
System.exit(0);

}
}

/* Esta clase se usa como superclase */

class Estudiante2{

private String cedula;

private String nombre;
public Estudiante2(String cip, String nom){ //Constructor
this.cedula = cip;
this.nombre = nom;
}

public String toString() {

return ("Cedula:" + cedula + "\n Nombre: " + nombre +"\n C.R.U.V.");
}

}// fin Estudiante2

Diego Santimateo G. 7
Programación Orientada a Objetos

class EstudianteFac extends Estudiante2 {

/* ejemplo de uso de herencia con constructor en la clase padre Estuiante2*/
private String facultad;
private int edad;
private String recibo;

public EstudianteFac (String fac, String n, String cip, String rec, int ed)
{
super(cip, n); //invoca constructor de la super clase
this.edad = ed;
this.facultad = fac;
this.recibo = rec;
}

public boolean pagoMatricula()

{
if (recibo.equals(""))
return(false);

else
return(true);
}

public String getRecibo()

{
return(recibo);
}

public String toString() //sobrecarga y además usa método de la super clase

{
String s = super.toString();
s = s + "\n Facultad: " + facultad;
return s;
}
}

Sistema de Entrada y Salida

Existe una gran variedad de recursos con los cuales un programador puede desear
establecer una comunicación, por ejemplo un archivo, la consola, conexiones de red, etc.
Paralelamente existen diversas formas de comunicarse, por ejemplo; secuencial, acceso aleatorio,
binario, por carácter, por líneas, por palabras, etc. Esto trae como consecuencia que exista
cualquier cantidad de clases Java destinadas a facilitar el manejo de las entradas y salidas.

Java engloba todo el sistema de entrada y salida del paquete java.io bajo el concepto de
flujo (stream), esto implica un tratamiento común a la transmisión de data, sin importar que
recurso la envía o recibe. El flujo es una especie de transporte de datos desde un origen a un
destino, no obstante, el recurso que da origen al flujo se conoce como flujo de entrada,
mientras que el destino se denomina flujo de salida, especificados en las clases InputStream y
OutputStream respectivamente. Para el manejo de la codificación Unicode(dos bytes por caracter)

Diego Santimateo G. 8
Programación Orientada a Objetos

Java posee una jerarquía de clases separadas, se trata de las clases abstractas Reader y Writer,
que atienden aspectos de internacionalización.

Lectura desde el teclado

Si en una entrada o captura de datos se reciben valores inesperados el programa puede
terminar abruptamente, este error en tiempo de ejecución se denomina excepción (exception) en
Java. Java provee mecanismos especiales para manejar excepciones, la forma más simple de
estos consiste en adicionar la cláusula “throws IOException” a la declaración del método main(),
como se muestra en el siguiente ejemplo. Un aspecto importante es considerar la importación del
paquete java.io.* que permitirá al compilador examinar la librería java.io en busca de las
definiciones de las clases IOException, InputStream-Reader y BufferedReader del ejemplo.

Ejemplo

import java.io.*;
import java.util.*;

public class CapturaTeclado

{
public static void main(String args[])throws IOException
{
//Creación del flujo para leer datos
InputStreamReader isr=new InputStreamReader(System.in);

//Creación del filtro para optimizar la lectura de datos

BufferedReader br=new BufferedReader(isr);
System.out.print("Teclea el primer numero: ");

//Lectura de datos mediante el método readLine()

String texto1=br.readLine();

//Conversión a int de la String anterior para poder sumar

int num1=Integer.parseInt(texto1);

System.out.print("Teclea el segundo numero: ");

texto1=br.readLine();
int num2=Integer.parseInt(texto1);

//Sumar los dos enteros

System.out.println("Suma de "+num1+" y "+num2+" es "+(num1+num2));

}
}

Obsérvese que System.in y System.out son objetos definidos en la clase System, mientras
que los objetos isr, br, y texto1 son objetos definidos en el programa que usamos de ejemplo; isr
es asociado a System.in, en consecuencia es el conducto que transporta datos desde el teclado al
programa pero en forma de byte, por otra parte, br es una instancia de BufferedReader asociada
al objeto isr, que transforma cada byte de isr en caracteres(tipo char), esto significa que puede
acceder a los datos de entrada según convenga al programador, por ejemplo con su método

Diego Santimateo G. 9
Programación Orientada a Objetos

readLine() captura una línea entera de caracteres que provienen del teclado y los transforma en
una cadena, que en nuestro caso queda almacenada en el objeto texto1.

Lectura de archivo de texto

Nos basamos en la clase abstracta Reader con las subclases FileReader para asociar el
archivo físico al objeto que luego se usa en el constructor de la clase BufferedReader que provee
los métodos necesarios para leer el archivo de texto. La siguiente secuencia nos habilita para usar
el método readLine() que permite leer cada línea o registro del archivo.

FileReader arch1 = new FileReader(nombreArchivo);

BufferedReader in = new BufferedReader(arch1);
Ejemplo

/* Captura nombre de archivo y lee archivo de texto por línea.

* Usa la clase abstracta Reader
*/
import java.io.*;
import javax.swing.*;
public class LeeconReader {
public static void main(String[] args) {

String archivoName;
archivoName = JOptionPane.showInputDialog(null, "Indique nombre de archivo:");
try {
//BufferedReader in = new BufferedReader(new FileReader("datos1.txt"));
FileReader arch1 = new FileReader(archivoName);
BufferedReader in = new BufferedReader(arch1);
String s = new String();

while((s = in.readLine())!= null) //lectura del archivo

System.out.println("\nRegistro: "+ s);

try {
in.close();
}
catch ( IOException e )
{
System.err.println( "El archivo no se pudo cerrar correctamente" );
System.exit( 1 );
}

System.exit(0); //cierra hilo abierto por ventana de diálogo

}
catch (Exception e)
{
System.err.println("***Error al leer o abrir el archivo...\n" +e);
}

} //fin main
} // fin de LeeconReader

Diego Santimateo G. 10
Programación Orientada a Objetos

Grabación en archivo de texto

Utilizaremos la clase abstracta Writer con la subclase FileWriter para asociar el nombre
físico del archivo con el objeto que se emplea en el constructor de la subclase PrintWriter que
provee los métodos para grabar en el archivo de texto.

FileWriter arch1 = new FileWriter(nombreArchivo, true);

PrintWriter out = new PrintWriter(arch1);

Si al constructor de FileWriter le pasamos el parámetro true entonces el archivo de salida será

considerado append, es decir, los nuevos registros se adicionarán al final.
Ejemplo

* Se usa la clase abstracta Writer. Se emplea try ... catch para

* captar posibles errores en el manejo del archivo.
*/
import java.io.*;
import javax.swing.*;
public class GrabaconWriter {
public static void main(String[] args) {
String sigue, linea, archivoName;
archivoName = JOptionPane.showInputDialog(null, "Indique nombre de archivo:");

try {
// FileWriter con true permite adicionar registros al final...append
FileWriter arch1 = new FileWriter(archivoName, true);
PrintWriter out = new PrintWriter(arch1);
sigue = "s";
while (sigue.equals("s"))
{
linea = JOptionPane.showInputDialog(null, "Indique nuevos datos");
out.println(linea); //graba en el archivo
sigue = JOptionPane.showInputDialog(null, "Entre s para continuar");
}

try {
out.close();
}
catch (Exception e )
{
System.err.println( "El archivo no se pudo cerrar correctamente" );
System.exit( 1 );
}
System.exit(0);
}
catch (Exception e)
{
System.err.println("*** error en apertura o lectura del archivo:\n" +e);
}

} // fin main

} //fin de GrabaLeeFile

Los procesos de entrada y salida pueden provocar excepciones o errores por lo que el
programador debe controlarlos por medio del try … catch.

Diego Santimateo G. 11
Programación Orientada a Objetos

Referencias
1. Libro muy recomendado para aprendizaje de Java. Bruce Eckel's Thinking in Java
http://www.codeguru.com/java/tij/tij0107.shtml
2. Elliotte Rusty Harold. Repositorio de códigos fuentes. http://www.ibiblio.org/javafaq/books/jdr/examples/
3. MIT. Apuntes de Java. http://leepoint.net/notes-java/index.html
4. John Zukowski. The historical collection classes – Arrays. http://www-128.ibm.com/developerworks/library/j-
arrays/index.html
5. Fred Swartz: Java Notes. http://www.leepoint.net/notes-java/index.html
6. Eckel Bruce: Thinking in Java. Libro disponible en línea en Internet. http://www.zone.org/eckel/javabook.htm.
7. JavaSoft de Sun: Tutoriales en línea en Internet. http://www.javasoft.com/products/jdk/1.1/index.html
8. Naughton, Patrick y Schildt, Herbert: Java: The Complete Reference (Complete Reference Series). Osborne
McGraw-Hill, 1996.
9. Campione, Mary y Walrath, Kathy: The Java Tutorial: Object-Oriented Programming for the Internet (Java
Series). Addison-Wesley Pub Co, 1997.
10. Roberto Zoia. Apuntes de Programación java. http://www.zoia.org/blog/category/java/ .2006.[consulta: agosto
2007]
11. ADRFormación. http://www.adrformacion.com/cursos/java/java.html#3 .[consulta: agosto 2007]
12.Java. Tools and Utilities. http://java.sun.com/javase/6/docs/technotes/tools/index.html .[consulta: agosto 2007]
13. Los elementos del Lenguaje Java.
http://www.sc.ehu.es/sbweb/fisica/cursoJava/fundamentos/introduccion/indice_intro.htm .[consulta: agosto 2007]

Diego Santimateo G. 12