Apuntes de Programación en JAVA

7/21/2019 Apuntes de Programación en JAVA

http://slidepdf.com/reader/full/apuntes-de-programacion-en-java-56dbabd9a4df5 1/50

DOI-019 Vigencia 11/13

UNIVERSIDAD AUTÓNOMA DE NUEVO LEÓN DIRECCIÓN GENERAL DE INFORMÁTICA

Módulo de Programación en JAVA: Básico e Intermedio 1

Elaboró: Miguel Angel Salazar Santillán Autorizó: M.A. José Juan González González

Apuntes de Programaciónen JAVA

Módulo Básico e Intermedio





Módulo de Programación en JAVA: Básico e Intermedio 2Elaboró: Miguel Angel Salazar Santillán Autorizó: M.A. José Juan González GonzálezReviso: Joel Guerrero Pérez Fecha de actualización: 13 Enero 2014

Contenido1.- Introducción a JAVA ................................................................................................................................ 4

1.1.- El lenguaje de programación JAVA .................................................................................................. 4

1.2.- La Plataforma Java ........................................................................................................................... 5

1.3.- ¿Qué es la JVM? .............................................................................................................................. 51.4.- ¿Qué es la API de Java? .................................................................................................................. 6

2.- Introducción a las aplicaciones en JAVA ................................................................................................. 7

2.1.- Identificadores ................................................................................................................................... 7

2.2.- Palabras reservadas ......................................................................................................................... 8

2.3.- Tipos de datos primitivos .................................................................................................................. 8

2.3.1.- Tipos de datos Enteros .............................................................................................................. 9

2.3.2.- Tipos en coma flotante............................................................................................................... 9

2.3.3.- Caracteres ................................................................................................................................. 9

2.3.4.- Booleanos ................................................................................................................................ 10

2.4.- Declaración de variables................................................................................................................. 10

2.5.- Conceptos de memoria básicos ..................................................................................................... 11

2.6.- Operadores ..................................................................................................................................... 12

2.6.1.- Operadores aritméticos............................................................................................................ 12

2.6.2.- Precedencia de operadores ..................................................................................................... 12

2.6.3- Operadores de igualdad y relacionales: Toma de decisiones .................................................. 13

3.- Estructuras de Control ........................................................................................................................... 13

3.1.- Algoritmos ....................................................................................................................................... 133.2.- Seudocódigo ................................................................................................................................... 14

3.3.- Condicionales ................................................................................................................................. 14

3.3.1.- Instrucción de selección simple (if) .......................................................................................... 14

3.3.2.- Instrucción de selección doble (if...else) .................................................................................. 15

Operador condicional .......................................................................................................................... 16

Instrucciones if...else anidadas ........................................................................................................... 16

3.3.3.- Instrucción de selección múltiple (switch) ................................................................................ 17

3.4.- Ciclos .............................................................................................................................................. 183.4.1.- While ........................................................................................................................................ 19

3.4.2.- For ............................................................................................................................................ 20

3.4.3.- Do - While ................................................................................................................................ 21

3.5.- Instrucciones break y continue ....................................................................................................... 22

3.5.1.- Instrucción break ...................................................................................................................... 22






3.5.2.- Instrucción continue ................................................................................................................. 23

4.- Introducción a la programación orientada a objetos .............................................................................. 24

4.1.- Clases ............................................................................................................................................. 24

4.2.- Objetos ............................................................................................................................................ 24

4.3.- Métodos .......................................................................................................................................... 254.4.- Declaración de una clase................................................................................................................ 25

4.5.- Declaración de un objeto ................................................................................................................ 26

4.6.- Declaración y definición de métodos .............................................................................................. 26

4.7.- Constructores .................................................................................................................................. 27

4.8.- Modificadores de acceso ................................................................................................................ 28

5.- Arreglos .................................................................................................................................................. 29

5.1.- Arreglos de una dimensión ............................................................................................................. 29

5.2.- Arreglos de dos dimensiones ......................................................................................................... 30

5.3.- Manipulación de Arreglos ............................................................................................................... 31

6.- Archivos y flujos ..................................................................................................................................... 32

6.1.- Creación y escritura de archivos .................................................................................................... 32

6.2.- Lectura de archivos......................................................................................................................... 34

6.3.- Métodos de la clase File ................................................................................................................. 36

7.- Programación orientada a objetos: un análisis más detallado .............................................................. 38

7.1.- Sobrecarga de métodos.................................................................................................................. 38

7.2.- Sobrecarga de constructores .......................................................................................................... 39

7.3.- Clases y métodos estáticos ............................................................................................................ 417.4.- Herencia .......................................................................................................................................... 42

7.4.1.- Acceder a miembros mediante la palabra super ..................................................................... 43

7.5.- Polimorfismo ................................................................................................................................... 43

8.- Manejo de excepciones ......................................................................................................................... 44

8.1.- Try y catch ...................................................................................................................................... 45

8.2.- Throw .............................................................................................................................................. 48

8.3.- Finally .............................................................................................................................................. 49

8.4.- Excepciones comunes .................................................................................................................... 50






1.- Introducción a JAVA

1.1.- El lenguaje de programación JAVA

Java es un lenguaje de programación de alto nivel y de propósito general caracterizadoprincipalmente por lo siguiente*:

Lenguaje simple Orientado a Objetos Distribuido Multiproceso Portable Robusto

Seguro

* A white paper - James Gosling, Henry McGilton, May 1996

La sintaxis de éste lenguaje deriva principalmente de los lenguajes C y C++, sinembargo la misma naturaleza de JAVA hace que tenga menos facilidades de bajo nivelque los lenguajes mencionados. Es esto mismo que, como se mencionó, lo convierteen un lenguaje potente para propósito general.

En el lenguaje JAVA, todos los archivos de código fuente que podamos construirestarán en un archivo de texto plano con extensión .java. Todos estos archivos, soncompilados en un archivo secundario con extensión .class por el compilador javac. Sise utiliza un IDE() en particular, se utilizará el compilador del IDE elegido. En el caso deEclipse (utilizado en el texto actual, se apoya del ECJ (Eclipse Compiler for JAVA).

Éste último archivo, .class, no contiene código nativo en JAVA generado por nosotrosmismos, a diferencia, contiene bytecodes. Éste último no es un lenguaje que puedaentender el procesador de nuestro CPU, es el lenguaje máquina de la Máquina Virtualde Java.

http://www.oracle.com/technetwork/java/langenv-140151.html









1.2.- La Plataforma Java

Una plataforma refiere al entorno de hardware o software en el cual un programa seejecuta. en el caso de Java, la plataforma se compone de dos principales pilares:- La Máquina Virtual de Java (JVM)- La Interfaz de programación de aplicaciones Java (Java API)

1.3.- ¿Qué es la JVM?

La Máquina Virtual de Java (JVM por sus siglas en inglés, Java Virtual Machine ) es unamaquina virtual de proceso nativo que, como su nombre lo indica, es capaz deejecutarse en una plataforma específica y con lo cual se obtiene la capacidad deinterpretar y ejecutar instrucciones expresadas en un código binario (bytecode), el cuales generado por el compilador de Java.

Dado que la JVM se encuentra disponible en diferentes sistemas operativos, el mismoarchivo .class tiene la capacidad de ser ejecutado en las mismas plataformas, talescomo: Microsot Windows, Solaris OS, distribuciones de Linux o Mac OS.






1.4.- ¿Qué es la API de Java?

La API de Java es un una larga colección de componentes de software que proveen unconjunto de funcionalidades y capacidades para desarrollar toda una solución desoftware basada en Java. Es decir, es un grupo de librerías de clases relacionadas einterfaces para construir componentes de software.






2.- Introducción a las aplicaciones en JAVA

2.1.- Identificadores

Los identificadores son nombres que representan a una variable, método, clase ointerface de un programa.

Para formar un identificador, debemos considerar las siguientes reglas:

Debe estar formado solo por letras, dígitos u otro carácter permitido (por ejemploel símbolo $ o el guión bajo _ )

El primer carácter debe ser una letra o un signo. No se puede usar una palabra reservada de Java para denotar un identificador. Java es sensible a mayúsculas y minúsculas. Es decir, una letra en mayúscula

es diferente a la misma letra en minúscula, por ejemplo, el identificador num, esdiferente al identificador NUM. Si se declaran, por ejemplo, dos variables conesos identificadores, java las considerará como dos variables totalmentediferentes.

Ejemplos de identificadores válidos:

numero

variable

$variable

numero_contador

_numero

Ejemplos de identificadores no válidos

2numero

/variable

En la práctica, lo ideal sería evitar variables con números o caracteres especiales.Esto le da una mayor legibilidad al programa y en consecuencia, un mantenimientorápido y flexible para modificaciones futuras.






2.2.- Palabras reservadasUna palabra reservada en java, refiere a una palabra que es utilizada por el mismolenguaje para denotar cierta instrucción. A continuación se muestran dichas palabras:

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

2.3.- Tipos de datos primitivos

Por su naturaleza y construcción, Java es un lenguaje de tipado fuerte, lo cual significaque no se permiten violaciones de los tipos de datos, es decir, dado el valor de unavariable de un tipo en concreto, no se podrá usar el valor de dicha variable como otrotipo. A excepción de que se haga una conversión explícita soportada por el lenguaje.

Dentro de los tipos de datos soportados por Java, en concreto, existen 8 tiposprimitivos. De los cuales, seis son numéricos (cuatro de tipo entero y dos de comaflotante), otro es el carácter y por último el booleano.

Dada la portabilidad que provee java, garantiza que todos los tipos de datos primitivostendrán el mismo tamaño independientemente de la plataforma donde se ejecute.






2.3.1.- Tipos de datos Enteros

Los datos de tipo entero son aquellos que pueden almacenar datos numéricos sinprecisión decimal, es decir, sin cifras decimales.

Tipo de dato Tamaño (bytes) Rango de Valoresbyte 1 -128 a 127short 2 -32768 a 32767

int 4 -2147483648 a2147483647

long 8 -9223372036854775808 a9223372036854775807

2.3.2.- Tipos en coma flotante

Los datos de tipo coma flotante nos permiten almacenar valores con cifras decimales.

Tipo de dato Tamaño Rango de Valoresfloat 4 ± 3.4x10-38 a ± 3.4x1038

double 8 ± 1.8x10-308 a ±1.8x10308

2.3.3.- Caracteres

El tipo de datos especializado en caracteres es el char. Java utilice el código Unicodede 16 bits a diferencia de la mayor parte de lenguajes clásicos, como tal es el caso deC y C++, que utilizan ASCII de 8 bits.

Por otro lado, se encuentran los caracteres de escape, los cuales proporcionan unaforma para generar una secuencia de diferentes tipos:

Código de escape Carácter\b Retroceso\t Tabulación\n Avance de línea\f Avance de papel






\r Retroceso de carro\" Comillas normales\' Comillas sencillas\\ Barra invertida

2.3.4.- BooleanosJava contiene el tipo de dato boolean, en el cual solo se pueden almacenar valores trueo false (verdadero o falso).

2.4.- Declaración de variables

Una variable es un espacio en memoria que puede almacenar algún valor, ya seanumérico, o alfanumérico.

Para declarar una variable es importante definir dos cosas, la primera es el tipo de datoque almacenara, y la segunda es el nombre o identificador que nos permitirá acceder aldato almacenado, después de especificar esto se puede o no inicializar las variable conalgún valor y se termina con " ; ".

Sintaxis :

Ejemplo :

boolean esVerdadero = false ;char valorCaracter ;

float promedio ; int numeroMaximo = 100 ;

tipoVariable identificadorVariable = valorInicial;






2.5.- Conceptos de memoria básicos

Los nombres de variables como num1 y num2, en realidad corresponden a ciertasubicaciones en la memoria de la computadora. Toda variable tiene un nombre , un tipo,un tamaño y un valor.Suponga que se tienen los siguientes valores para cada variable:

int num1 = 1;int num2 = 2;

La computadora coloca cada valor en una ubicación de memoria:

num1 -> 1num2 -> 2

Si creamos otra variable, se contendrá en una nueva ubicación de memoria:

num1 -> 1num2 -> 2Suma -> 3

Cada que actualicemos el valor de suma, ésta ubicación de memoria se reemplazará.Es decir, se perderá el valor anterior en dicho espacio en memoria.

Imagine la memoria como un archivero grande, donde se va colocando elementos cadaque van llegando en ese orden y piense, además, que para cada ubicación en elarchivo se tiene un índice. Es así, básicamente, como funciona la memoria.






2.6.- Operadores

2.6.1.- Operadores aritméticosLa mayoría de los programas realizan operaciones aritméticas. Los operadores seutilizan para realizar dichos operaciones, tales como: sumar, restar, multiplicar, dividir,

etc.

Nombre de operación OperadorSuma +Resta -

División /Multiplicación *

Módulo (Residuo de división) %

2.6.2.- Precedencia de operadoresJava aplica los operadores en expresiones aritméticas en una secuencia precisa,determinada por las siguientes reglas:

Operador(es) Operación(es) Orden de evaluación(precedencia)

* Multiplicación Se evalúan primero. Sihay varios operadores deeste tipo, se evalúan de

izquierda a derecha

/ División% Módulo o Residuo

+ Suma Se evalúan en segundolugar. Si hay varios

operadores de éste tipose evalúan de izquierda a

derecha.

- Resta






2.6.3- Operadores de igualdad y relacionales: Toma de decisionesUna condición es una expresión que puede ser verdadera o falsa. En java, existe lainstrucción if que permite que un programa tome una decisión bajo una condición dada.

Las condiciones en las instrucciones if pueden formarse utilizando los operadores de

igualdad (== y !=) y los operadores relacionales (>, <, >=, <=), sintetizados en lasiguiente tabla:

Operador estándar Operador enJava

Ejemplo Significado

Operadores de igualdad = == x == y X es igual a Y≠ != x != y X es diferente de Y

Operadores relacionales > > x > y X es mayor que Y< < x < y X es menor que Y≥ >= x >= y X es mayor o igual

a Y≤ <= x <= y X es menor o igual

a Y

3.- Estructuras de ControlPara la escritura de cualquier programa es necesario que se tenga una comprensióndetallada de todo el problema, además de un mapa detallado para resolverlo.Igualmente es importante comprender todos los bloques de instrucción disponibles, sucorrecta implementación y emplear las técnicas correctas.

Alguna de las herramientas básicas y bastante útiles para la resolución de problemas yluego su correcta implementación, es el uso de seudocódigo y algoritmos.

3.1.- AlgoritmosCualquier situación en computación puede resolverse ejecutando una serie de accionesen un orden específico. En general, un procedimiento para resolver un problema entérminos de:

1.- Las accion es a ejecutar

2.- El orden en el qu e se ejecutan estas acciones






Por ejemplo, consideremos el algoritmo para "Asistir al curso de JAVA":(1) Levantarse,(2) Bañarse, (3) Vestirse, (4) Transportarse al curso . Ahora, supongamos que el mismoalgoritmo, es decir, las mismas acciones las indicamos en diferente orden: (1)Levantarse, (2) Vestirse, (3) Bañarse, (4) transportarse al curso; obviamente estoproduciría un resultado inadecuado.

A este proceso, el de especificar el orden en que se ejecutan ciertas acciones en unprograma, se le conoce como control del programa. Las estructuras de control nosayudarán a mantener un correcto control de nuestros programas.

3.2.- SeudocódigoEl seudocódigo tiene como objetivo ser un lenguaje informal que ayuda a losprogramadores a desarrollar algoritmos sin tener que preocuparse por los estrictosdetalles se la sintaxis de los lenguajes de programación.

Por lo general, el seudocódigo, describe sólo las instrucciones que representan lasacciones que ocurren después de que un programador convierte un programa deseudocódigo a algún lenguaje de programación.

3.3.- Condicionales

3.3.1.- Instrucción de selección simple (if)Generalmente los programas utilizan instrucciones de selección para elegir haciadonde se dirigirá el control del programa.

Sintaxis:

Cuando se trata de una sola instrucción pueden omitirse las llaves. En el caso de quehaya más de una instrucción deberán especificarse las llaves forzosamente.Por ejemplo, suponga la siguiente condición en seudocódigo:

Si el promedio d el estudiante es menor a 80Entonces: Imprim ir "Reprobado"

Ésta instrucción determina si el estudiante obtuvo una calificación menor a 80, si estoes verdadero, se imprimirá "Reprobado", de lo contrario seguirá con el flujo delprograma.

if (condicion){

//TAREAS A REALIZAR}






La instrucción del seudocódigo anterior, puede escribirse en Java de la siguientemanera:

3.3.2.- Instrucción de selección doble (if...else)

A diferencia de la instrucción if simple, en donde solo se evaluaba si la condición eraverdadera, de lo contrario continuaba con el flujo del programa, con la selección dobleif..else, permite especificar una o más instrucciones cuando una acción es verdadera ytambién otra u otras distintas cuando es falsa.

Sintaxis :

Ejemplo, supongamos la siguiente condición en seudocódigo:

Si el promedio d el estudiante es menor a 80Entonces: Imprim ir "Reprobado"

En o t ro caso : Imprim ir "Aprobado"

Ésta última instrucción, puede escribirse en Java de la siguiente manera:if (promedio < 80)

System.out .println("Reprobado");else

System.out .println("Aprobado");

if (condicion){

//Tareas a realizar }else {

//Si la condición es falsa... }

if (promedio < 80)System.out.println( "Reprobado" );






Operador condicional Además de esto, Java cuenta con el operador condicional (?:), que en ocasiones puedeutilizarse en lugar de una instrucción if...else. Éste es el único operador ternario enJava; es decir, que utiliza tres operandos.

Por ejemplo, la instrucción:

resultado = (promedio < 80) ? "Reprobado" : "Aprobado";

Se asignara el texto "Reprobado" o "Aprobado" de acuerdo a la condición. Si lacondición resulta verdadera, se asignará el texto "Reprobado", de lo contrario seasignará el texto "Aprobado".

Instrucciones if...else anidadas

También pudiera darse la necesidad de tener if...else anidados. Por ejemplo,consideremos el siguiente seudocódigo:

Si la cal ificación del estu diante es mayo r o igu al a 90Imprimir “A”

de lo cont rar ioSi la cal ificación del estu diante es mayo r o igu al a 80

Imprimir “B” de lo cont rar io

Si la cal ificación del estud iante es mayor o igu al a 70Imprimir “C”

de lo cont rar ioSi la cal ificación del estu diante es mayo r o igu al a 60

Imprimir “D”






En java, se representaría de la siguiente manera:

if (calificacionEstudiante >= 90 )System.out .println("A" );

else if (calificacionEstudiante >= 80 )System.out .println("B" );else

if (calificacionEstudiante >= 70 )System.out .println("C" );

else if (calificacionEstudiante >= 60 )

System.out .println("D" );

3.3.3.- Instrucción de selección múltiple (switch)

Java cuenta con la instrucción de selección múltiple (switch) para realizar distintasacciones, en función de los posibles valores de una variable o expresión entera.

Sintaxis :

switch(<<variableAEvaluar>>){

case <<valor1>>:{

//tareas }break;case <<valor2>> :{

//tareas }break;...default:{

//tareas }break;

}

En cada case se especificará el valor que pudiera tomar la variable que se estáevaluando. Cada case lleva al final, la instrucción break, la cual se indica más adelanteen el documento; en éste caso funciona para interrumpir el switch y evitar seguirevaluando los demás case cuando ya se ha encontrado alguno.






La instrucción default, sirve para asegurar que en caso de que no se cumpla algúncase, por default se realice una acción.

Ejemplo :

switch(calificacion){

case 'A':{

System.out .println("FELICIDADES!!!");}break;case 'B':{

System.out .println("MUY BIEN. SIGUE ADELANTE.");

}break;case 'C':{

System.out .println("UN POCO MÁS DEESFUERZO. ÁNIMO!!!.");

}default:{

System.out .println("GRACIAS PORPARTICIPAR. SIGUE INTENTANDO.");}break;

}

3.4.- CiclosLas instrucciones de repetición (mejor conocidas como ciclos) permiten especificar queun programa debe repetir una acción mientras cierta condición sea verdadera. A cadarepetición de éste fragmento de código o acción, se le conoce como iteración.

Por ejemplo, consideremos el siguiente seudocódigo:

Mientras existan art ículo s en el carri to d e com prasSum ar al total el precio del artícul o y qu itarlo

Éste se realizará de forma repetida mientras haya artículos en el carrito de compras.Para resolver éste tipo de situaciones, en Java nos encontramos con tres formasbásicas de ciclos: while, do-while y for.






3.4.1.- While

La instrucción while tiene como objetivo iterar un conjunto de instrucciones mientrasuna condición dada sea verdadera, de otro modo, se deja de iterar.

Por lo general, se utiliza cuando no se conoce la cantidad exacta en que debe serejecutado cierto bloque de instrucciones. De ésta manera, lo único que se debe tomaren cuenta es una condición; el usuario deberá prevenir que en algún punto del tiempola condición será verdadera, con el fin de no producir un ciclo infinito.

Sintaxis :

while(condicion){

//Tareas }

Ejemplo :

int numero = 0;while(numero != 5){

System.out .println("Aún no se tiene el valor5");

numero = numero + 1;}

En el ejemplo anterior, el bloque while se ejecutará mientras el valor de la variablenúmero no sea 5. Una vez sea 5 no se ejecutará éste bloque.






3.4.2.- For

La instrucción for tiene como objetivo iterar un conjunto de instrucciones al igual quecon while, sin embargo, la condición se evalúa a través de un variable contadorespecificado en su misma sintaxis.

Generalmente, la utilizaremos cuando conocemos (aunque quizá no en valor) lacantidad de iteraciones a realizar. Incluso, se podría representar ésta cantidad con unaexpresión o función.

Sintaxis :

for (incialización; condición; incremento){

//tareas }

Ejemplo :

for (int i=0; i < 100; i++){

System.out .println(i);}

El código anterior, inicia declarando la variable i y asignando a ésta el valor de cero.Una vez inicializada, se evalúa la condición, es decir, si es menor a 100. Entonces,entra al cuerpo del for e imprime el valor de i. Luego vuelve a la línea principal eincrementa en 1 el valor de i, seguido vuelve a evaluar la condición, si es verdaderacontinua ejecutando las instrucciones. De este modo, sucesivamente hasta que lacondición sea falsa.






3.4.3.- Do - While

La instrucción do-while es similar a la instrucción while, sin embargo, a diferencia de lainstrucción while donde la condición se evalúa al inicio, en do-while la condición seevalúa al terminar el cuerpo del ciclo, esto infiere que el ciclo se ejecuta por lo menosuna vez.

Sintaxis :

do {

//tareas }while(condicion);

Note como en el while, se especifica al final un punto y coma. Además de que lasintaxis de Java es siempre con punto y coma al final de cada instrucción, nos permitediferenciar de un while normal. Ya que de no llevar punto y coma, se podría pensar quesolo es un while.

Ejemplo :

int numero = 0;do {

System.out .println("Aún no se tiene el valor5");

numero = numero + 1;}while(numero != 5);






3.5.- Instrucciones break y continue

Además de las instrucciones de repetición y de control, Java cuenta con lasinstrucciones break y continue. Estas instrucciones sirven para alterar el flujo delcontrol.

3.5.1.- Instrucción break

Como se mostró anteriormente, el primer uso del break normalmente lo encontraremosen el switch. En éste caso, el break actúa en modo de detener la evaluación de lossiguientes case, en caso de que ya se haya encontrado alguno que satisface lacondición.

Cuando break se ejecuta en una instrucción while, for, do-while o switch, interrumpe laejecución del bloque de código y produce la salida inmediata de esa instrucción. En unciclo, usualmente se utiliza para escapar anticipadamente del ciclo o omitir el resto delas instrucciones.

El siguiente bloque de código muestra un ejemplo del uso de break para escapar de unciclo for:

for (int i=0; i < 100; i++){

System.out .println(i);

if (i == 5)break;

}

El for se interrumpirá cuando la i tome el valor de 5.






3.5.2.- Instrucción continue

Cuando la instrucción continue se ejecuta en una instrucción while, for o do-while,omite las instrucciones restantes en el cuerpo del ciclo, similar al break. Sin embargo, adiferencia del break, el continue no termina con la ejecución del ciclo en cuestión, másbien forzará una nueva iteración y que se ejecutará de manera normal a menos que elflujo del programa vuelva a encontrarse con la instrucción continue.

for (int i=0; i < 100; i++){

if (i == 5)continue;

System.out .println(i);}

Como se puede observar, en el ejemplo anterior nunca se imprimirá el valor de 5. Dadoque una vez la i tenga este valor se forzará una nueva iteración y no alcanzará a tocarel método println. La salida del programa será: 1234678910....100.






4.- Introducción a la programación orientada a objetos

4.1.- Clases

El concepto de clases y objetos son los pilares del paradigma de la programaciónorientada a objetos. Para ilustrar el concepto de éste paradigma, se debe iniciar con elpensamiento de que cualquier situación del mundo real puede modelarseconceptualmente en la programación. Con esto, entidades físicas del mundo realpodrán ser modeladas.

Para ilustrar lo anterior, supongamos una entidad del mundo real. Por ejemplo unautomóvil. el automóvil está hecho para ser conducido, implica ciertos mecanismos loscuales están "encapsulados", es decir, al usuario del automóvil no le importa cuál seala implementación detallada de estos mecanismos. Ahora bien, para poder serconstruido dicho automóvil necesita un diseño. Es decir, un mapeo o plantilla de cómodebe ser una instancia, dado que puede haber múltiples automóviles a partir del mismodiseño.

Haciendo analogía a éste ejemplo, a estos diseños o plantillas lo podemos representarcomo una Clase.

4.2.- Objetos

Partiendo del ejemplo anterior, un objeto sería una instancia de éste diseño. Es decir,

una aplicación del mismo. Dicho de otro modo, el automóvil real.Una vez que se obtiene una instancia de ésta plantilla, es decir, de la clase; el objetoadquiere todas aquellas definiciones realizadas dentro de una clase. Por lo cual, sedice que se "encapsulan" las propiedades y comportamientos de dicha clase en elobjeto.

Volviendo a la analogía, el objeto automóvil encapsulará todas aquellas característicasque posee el automóvil; por ejemplo: el color, el tama;o, el modelo, etc. Y además,puede ejecutar acciones, por ejemplo: acelerar, mover a la izquierda o a la derecha,retroceder, etc.

De ésta manera podemos redefinir el concepto de clase: Una clase es un conjunto dedefiniciones de características (las cuales llamaremos propiedades) y comportamientos(los cuales llamaremos métodos) para un objeto en concreto una vez que este se hayainstanciado. Es decir, una vez se haya creado un objeto en un momento en particular apartir de la definición de la clase.






4.3.- Métodos

Los métodos, son bloques de código diseñados con el fin de realizar alguna tarea.Dichos métodos para poder ser identificados de manera única se realiza a través de sunombre, su tipo de retorno y el conjunto de parámetros que requiera para realizar sutarea.

4.4.- Declaración de una clase

Sintaxis :

Ejemplo :

<<modificadorAcceso>> class <<NombreDeClase>> {

}

public class Clase {//propiedades

//métodos }






4.5.- Declaración de un objeto

Sintaxis :

Ejemplo :

4.6.- Declaración y definición de métodosSintaxis :

Ejemplo:

Clase objeto = new Clase();

<<NombreDeClase>> nombreDeObjeto = new <<NombreDeClase>>();

public void Metodo( int parametroEntero){

System. out .println( "MÉTODO");}

<<ModificadorDeAcceso>> <<valorRetorno Nombre(parametros){

//tareas }






4.7.- Constructores

Un constructor, es por definición, un método que carece de tipo de retorno. La finalidadde éste método es para asegurar la correcta creación de un objeto al instanciar unaclase.

A menudo nos encontraremos con la necesidad de que al instanciar un objeto, éste seconstruya con un conjunto de variables ya inicializadas con cierto valor. Esta es lafinalidad de los constructores.Ejemplo:

//Ésta es la definición de la clase public class Clase{

//El método constructor debe nombrarse igual que la//clase y no debe llevar un valor de retornopublic Clase( int parametroEntero){

//hacer algo con el parámetro entero }

}

public class OtraClase{

public void Metodo(){

//declaramos el objeto y le enviamos el valor 0//para el parámetro "parametroEntero" de la clase//anterior. Clase objetoDeClase = new Clase(0);

}}






La palabra reservada new indica que se creará un nuevo objeto. al hacer esto se defineseguido a dicha palabra la clase que construirá el objeto. Es ahí donde el constructores llamado para construir dicho objeto.

Por defecto, si el programado no asigna un constructor explícitamente, el compilador deJava construirá un constructor automáticamente para solventar esto. El constructorserá vacío, sin embargo la finalidad de esto es dar coherencia y se debe tener encuenta que siempre habrá un constructo para cada clase.

En los constructores podremos definir parámetros de entrada para poder alimentar lasvariables necesarias para la correcta construcción del objeto.

4.8.- Modificadores de acceso

Un modificador de acceso es una palabra reservada de Java que se utiliza durante ladefinición de una clase o método. El uso del modificador implica el nivel deaccesibilidad:

Modificador deacceso

La misma clase Clase delmismo paquete

Subclase deotro paquete

Clase de otropaquete

Public X X X XProtected X X X

Default X XPrivate X

Como se puede observar, cada uno de los modificadores permiten o no acceder a losmiembros de una clase o a la misma clase desde otro lugar.

Public: permite a una clase, método o variable ser accedida desde cualquier clase sinimportar que esté o no en otro paquete.

Protected restringe el acceso desde las clases de otros paquetes.

Default, o mejor dicho, si no se asigna un modificador de acceso, por defecto solo sepermite el acceso dentro de las clases del mismo paquete.

Private restringe cualquier acceso al método o variable fuera de la clase donde fuerondeclarados.






5.- Arreglos

5.1.- Arreglos de una dimensión

Así como podremos utilizar variables, las cuales no son mas que direcciones enmemoria con valores específicos, Java también posee estructuras de datos paraalmacenar en memoria de manera más organizada un conjunto de datos.

Los arreglos, realmente es cierto acomodo de espacios de memoria con los que esmas sencillo realizar manipulaciones de un conjunto de valores. Esto nos da laposibilidad de poder ordenar como si de una lista se tratara.

Por lo regular, a un arreglo de una dimensión se le conoce como Vector. Se puederepresentar gráficamente como casillas que contienen elementos:

El valor del índice, es decir el valor de la posición, en java siempre iniciará en base 0,

como aparece en la imagen anterior.Sintaxis:

Ejemplo :

El anterior, es un arreglo de tipo entero, el cual tendrá una longitud de 3.

tipo [] nombre = new tipo [longitud];

int [] vector = new int [3];






5.2.- Arreglos de dos dimensiones

Del mismo modo que existen los vectores, podremos tener un conjunto de vectoresdispuestos en cierto orden en una sola estructura. A esto se le conoce como arreglo dedos dimensiones o de manera más popular Matrices.

Sintaxis :

Ejemplo :

int [][] vector = new int [3][5];

tipo [][] nombre = new tipo [cantidadFilas][cantidaColumnas];






5.3.- Manipulación de ArreglosLa forma habitual para trabajar con arreglos es a través de ciclos. Se recorren loselementos de los vectores o matrices a través de iteraciones.

Para el caso de un vector, consideremos el siguiente ejemplo:

La clase de prueba, para ejecutar los métodos anteriores:

public class Arreglos {public void leerArreglo( int [] vector){

Scanner entrada = new Scanner(System. in );int index = 0;for ( int i = 0; i < vector. length ; i++){

index = i+1;System. out .println( "Introduzca elemento " +index + ":" );vector[i] = entrada.nextInt();

}}

public void imprimirArreglo( int [] vector){

int index=0;for ( int i = 0; i < vector. length ; i++){

index = i+1;System. out .println( "Elemento en posición " +

index + ": " + vector[i]);}}

//fin de la clase Arre los

public class PruebaArreglos {

public static void main(String[] args){

Arreglos objArreglo = new Arreglos();

int [] vector = new int [3];

objArreglo.leerArreglo(vector);objArreglo.imprimirArreglo(vector);

}}






6.- Archivos y flujos

6.1.- Creación y escritura de archivos

Como se vio anteriormente, podremos manipular información a través de estructuras dedatos como lo son los arreglos. Esto nos permite una mayor flexibilidad para podertransmitir un conjunto de información durante todo un flujo del programa.

Aunque los arreglos, almacenan en memoria información, el propósito de estos no esser un contenedor de datos. A menudo, en la vida real, necesitaremos un lugar o uncontenedor donde almacenar información de manera persistente, hoy en díaconocemos las bases de datos.

Similar a lo anterior, para almacenar información en Java podemos hacer uso del

manejo de archivos físicos. Para esto se requiere el uso de diferentes clases de la APIde Java.

La clase principal para el manejo de archivos, es la clase File. En dicha clase sedefinen métodos para la creación y manejo de archivos, así como para comprobar elestado del archivo, etc.

Además de la clase File, la API de Java contiene la clase FileWriter, ésta clasecontiene métodos necesarios para escribir o sobreescribir archivos, a través del objetoFile.






Por otra parte, se debe tomar en cuenta que mientras escribirmos un archivo entra en juego el proceso de la memoria de la computadora. Dado que necesitaremosinformación disponible en memoria para poder identificar caracteres y además haceruso de tiempo y recursos para diferentes tareas. Para esto, existe la claseBufferedWriter, la cual almacena caracteres o cadenas que deseemos introducir en unarchivo en una especie de buffer, una vez sea necesario se empuja toda esainformación a la dirección física persistente de almacenamiento para introducir elcontenido.Por último, tenemos la clase PrinterWriter, la cual nos provee la facilidad de ingresarinformación al buffer, esto a través del método write().

En el código anterior, lo que se realiza es primeramente crear un objeto de la clase File,esto representará el archivo que se va a trabajar. Se la asigna un nombre enviándole elstring hacia el constructor de dicha clase.

void escritura(String nombre){

File f = new File(nombre);

try {

FileWriter fw = new FileWriter(f);BufferedWriter bw = new BufferedWriter(fw);PrintWriter pw = new PrintWriter(bw);pw.write( "texto" ); //String que se desea

escribir

pw.println(); //Salto de linea

//Cerramos el buffer y la escritura.bw.close();pw.close();

}catch (Exception e){

}}






Luego, se crea un objeto FileWriter que se encargará de escribir en el archivo, a suconstructor le enviamos el archivo que hemos creado, es decir el objeto de la claseFile.

Hecho esto, se necesitará de un objeto de tipo BufferedWritter, el cual almacenará loscaracteres o cadenas que se escribirán en dicho archivo.Con el objeto pw de tipo PrintWriter, mandaremos hacia el buffer el texto quedeseemos escribir en el archivo.

Por último cerramos los objetos PrintWritter y BufferedWritter, ambos con el métodoclose(), para asegurar que el archivo se almacene de manera correcta.

6.2.- Lectura de archivos

Para leer una archivo solo se requieren de dos clases, además de File el cual esindispensable en todo momento para este tipo de tareas. Éstas clases son FileReader yBufferedReader.

Del mismo modo que con BufferedWriter , la función de BufferedReader es crear unespacio buffer donde se almacena temporalmente lo que se va leyendo del archivo.Todo esto a través del método readLine().






En el código anterior, inicialmente se crea un objeto File, que será el objeto para utilizarcon el archivo a trabajar. En seguida, instanciamos de la clase FileReader en un objetoque es el que se encargará de leer el archivo.

Mediante BufferReader podemos ir accediendo a cada una de las líneas del archivopara después trabajar con ellas. Iteramos sobre las líneas para tomar una a una laslíneas de texto almacenadas en el archivo y las asignamos a una variable de tipoString.

Por último, imprimimos el contenido de la cadena.

6.3.- Métodos de la clase File

Para realizar operaciones sobre direcciones físicas, es decir, ubicaciones en nuestrodisco, necesitamos contar con la información referente sobre los archivos.

De nuevo, la clase File, proporciona muchas utilidades relacionadas con archivos y conla información de los mismos. Para esto, Java pone a nuestra disposición los siguientesmétodos de la clase File:






Métodos de la clase File

Método FunciónString getName() Devuelve el nombre del ArchivoString getPath() Devuelve la ruta donde se encuentra el

ArchivoString getAbsolutePath() Devuelve la ruta absoluta

String getParent() Devuelve la ruta padreBoolean renameTo(File nuevoNombre) Cambia el nombre del Archivo

Método FunciónBoolean exists() Devuelve falso o verdadero indicando si

existe o no el archivoBoolean canWrite() Comprueba si el archivo puede

modificarseBoolean canRead() Comprueba si el archivo puede ser leído

Boolean isFile() Comprueba si el archivo existeBoolean isDirectory() Comprueba si la ruta existeBoolean isAbsolute() Comprueba si la ruta es absoluta

Método FunciónLong lastModified() Indica la fecha en que fué modificado por

última vezLong length() Devuelve el tamaño del archivo en bytes

Método Función

Boolean mkdir() Crea un directorioString[] list() Devuelve un arreglo de tipo Stringnombrando las filas y directorios en el

directorio denotado por la ruta






7.- Programación orientada a objetos: un análisis más detallado

7.1.- Sobrecarga de métodos

Como se mencionó anteriormente, lo que hace único a un método está en función de elnombre del método, el tipo de valor de retorno y los parámetros de entrada. Con esto,llamamos sobrecarga de métodos a dos métodos con el mismo nombre pero quepueden cumplir con tareas diferentes, retornar tipos de datos diferentes o poseerdiferentes valores de entrada, ya sea en cantidad o en especie.

Consideremos el siguiente ejemplo, donde el cuadrado de un número ya sea entero oflotante puede calcularse:

import java.util.Scanner;

public class ElevarCuadrado {

int cuadrado( int n){

return n*n;}

float cuadrado( float n){return n*n;

}}






7.2.- Sobrecarga de constructoresSe mencionó que un constructor es por definición un método sin valor de retorno. Estoinfiere que también los constructores pueden llegar a ser sobrecargados como semuestra en el siguiente ejemplo:


class Alumnos{

String[] nombre ;

//Caso 1Alumnos( int n){

nombre = new String[n];}

//Caso 2Alumnos(){

nombre = new String[ ' ' ];}

}

class PruebaAlumnos{

public static void main(String[] args){

int n,i;Scanner teclado = new Scanner(System. in );

//*****Caso 1System. out .println( "Ingrese un numero entero" );n = teclado.nextInt();






Como se puede observar, en el primer caso se conoce el número de alumnos, y deesta manera asignamos una longitud exacta al arreglo. A diferencia del segundo casodonde desconocemos la longitud que tendrá el arreglo, y se declara con comillas en el

corchete, esto provee 250 espacios. De requerir más se podría utilizar otra sobrecarga. Aunque estos métodos no son lo más habituales, sirve bien para ejemplificar lasobrecarga.

Esto nos provee la facilidad de poder instanciar un objeto con diferentes valores.La sobrecarga tanto de métodos como de constructores conllevan a un tipo depolimorfismo, es decir, el mismo método puede tener comportamientos diferentes, estose explica más adelante.

Alumnos al = new Alumnos(n);

for (i=0;i<n;i++)

{System. out .println( "Ingrese el nombre delalumno " + (i+1));al. nombre [i] = teclado.next();

}

//*****Caso 2

Alumnos al2 = new Alumnos();

i = 0;String s;do {

System. out .println( "Ingrese el nombre delalumno " + (i+1));al2. nombre [i++] = teclado.next();

System. out .println( "Desea continuar?(si/no)" );s = teclado.next(); } while (s == "si" );

}}

}






7.3.- Clases y métodos estáticos

La palabra reservada static nos sirve para crear miembros de una clase o una mismaclase sin tener que instanciarlos.

El uso de static está directamente relacionado en aquellos casos donde se necesite,dentro de un programa, tareas en las que no se necesita tener el comportamiento de unobjeto como tal. Es decir, para estos casos no es importante que se tenga queinstanciar un objeto y éste mantenga o no un estado en el tiempo. Para lograr estobasta con agregar la palabra reservada static después del modificador y antes del tipode valor de retorno.

Del mismo modo en que ese utiliza static en las clases, lo podremos realizar conmétodos o variables. Esto provee la flexibilidad de poder hacer uso de estas variables y

métodos sin necesidad de declarar una variable de instancia u objeto.

En el siguiente ejemplo, se hace uso de la clase Math, la cual es estática así como susmétodos. Note como no se necesita instanciar y se puede acceder directamente a losmétodos.


public class Ejemplo {

public static void main( String args){

System.out.println("Valor de PI:" + Math.PI);}

}






7.4.- HerenciaLa herencia es otro de los conceptos con suma importancia dentro de la programaciónorientada a objetos. Éste concepto hace referencia a poder utilizar clases existentespara extender nuevas clases que son derivadas de estas. Entiéndase comosubconjunto de la clase principal.

Para ilustrar lo anterior, imaginemos que necesitamos modelar un programa dondenecesitemos información de diferentes tipos de animales. La mayoría de los animalestienen comportamientos que funciona del mismo modo para todos. Por ejemplo,supongamos la acción comer, hasta donde se conoce , todos los animales comen. Sinembargo, imaginemos la acción caminar, no todos los animales caminan.

En definitiva, podemos sugerir una lista de acciones que aplican para algunos y paraotros no, pero habrá algunas que apliquen para todos. En este tipo de situaciones esdonde se indica trabajar una clase base, por ejemplo, la clase Animal y de ahí derivarclases, por ejemplo AnimalesTerrestres y AnimalesMarinos.

En la clase base, Animales, definiremos propiedades y métodos que puedan serutilizadas tanto por AnimalesTerrestres como AnimalesMarinos. Pero imaginemos quenecesitemos de la acción Nadar(). esto solo se definirá solo en la clase

AnimalesMarinos y en la clase AnimalesTerrestres podremos definir el métodoCaminar(). Quizá, de ser necesario podríamos nuevamente extender la clase de

AnimalesTerrestres en diferentes tipos para indicar si es rastrero o no.

Todo lo anterior depende de la necesidad del problema, en algún caso pudiera no sertan impactante el dividir acciones de los animales terrestres y quizá se solventaríahaciendo uso de una variable , dentro de la misma clase, que almacene éstainformación.Sintaxis

Nota: el modificador de acceso protected nos sirve para restringir el acceso a losmétodos o atributos de una clase. Aquellos atributos o métodos que sean protectedsolo podrán ser usados por clases del mismo paquete donde se encuentre la clase quelos contiene, o por subclases de esta.

class AnimalesTerrestres extends Animales{

....}






7.4.1.- Acceder a miembros mediante la palabra super

Dentro de nuestras clases, en ocasiones, será indispensable acceder a información dela clase superior, es decir de la superclase. Para esto se utiliza la palabra reservadasuper, la cual le indica al compilador que se debe acceder la información desde la clasesuperior.

7.5.- Polimorfismo

El polimorfismo, es otro de los conceptos que toma una amplia relevancia dentro delparadigma de la programación orientada a objetos.

Este concepto refiere a que podemos obtener la flexibilidad de programar de un modomás general y en base a condiciones o parámetros, hacer que alguna tarea obtenga uncomportamiento distinto.

Para ejemplificar esto, volvamos al concepto de sobrecarga de métodos yconstructores puesto en el ejemplo de la clase Animales. Imaginemos que unainstancia, es decir un objeto, de nuestra subclase AnimalesTerrestres refiere a un Perroy por otro lado, una segunda instancia refiere a un Gusano. Ambos animales poseen uncomportamiento o un conjunto de acciones, por ejemplo moverse. Sin embargo, no semueven de la misma manera.Es en éste punto donde nuestro método Mover() podría actuar de manera diferentesegún corresponda. Para esto podríamos optar por declarar dos métodos con el mismo

nombre, Mover, pero que posean una implementación diferente.






8.1.- Try y catch

El bloque try-catch son exageradamente útiles para el manejo de excepciones. Dehecho no existe otro método para tratar los errores de manera organizada y bienpensada.

Cuando tenemos un fragmento de código que sbaemos que posiblemente en algúnmomento en el tiempo dentro del ciclo de vida de la aplicación se puede producir unerror, debemos utilizar los bloques try catch definitivamente.

El proceso es simple, todo el bloque de código que podría producir un error debe serencerrado dentro de las llaves de try. Éste se encargará de ejecutar las tareas y encaso de ocurrir una excepción, el bloque catch lo atrapará y se ejecutará en su lugarese bloque.






Sintaxis :

Hay muchos tipos de excepciones, sin embargo un bloque catch solo puede atraparuna. Para solventar esto Java permite indicar múltiples bloques catch para un solobloque try:

Sintaxis

Cuando se colocan múltiples bloques catch, Java los ejecuta en el orden en el queaparecen descritos. si hay alguno que coincida, se ejecuta el bloque.

try {

//instrucciones }catch (TipoExcepcion nombre){

//instrucciones }

try {

//instrucciones }catch (TipoExcepcion nombre){

//instrucciones

}........catch (OtroTipo nombre){

}






Además, es importante saber que algunas excepciones engloban a otras, por ejemplola clase Exception, es la clase encargada de manejar cualquier tipo de excepciónindependientemente del error, sin embargo podría traernos información másgeneralizada y no podríamos detectar puntualmente cual fue el error.

Por otro lado, debe advertirse que, dado que se ejecutarán en el orden en que loespecifiquemos, lo ideal es ordenarlas de menor a mayor en relación a la jerarquía, esdecir, primero las mas puntuales y hasta el final las más genéricas. De otro modo,nunca llegará a excepciones más abajo.

try {

int numero = 10;int resultado;

resultado = numero/0;}catch (ArithmeticException e1 ){

System. out .println( e1 .getMessage());}catch (Exception e2 ){

System. out .println( "Ocurrió un error en elprograma" );

}






8.2.- Throw

La sentencia throw se utiliza para lanzar explícitamente una excepción. En primer lugarse debe obtener un descriptor de objeto Throwable(tipo de excepción), bien medianteun parámetro en una cláusula catch, o se puede crear utilizando el operador new. Laforma general de la sentencia throw es:

¿Lanzar una excepción? Durante el aprendizaje, es buena pregunta. En ocasiones, elprogramador necesita producir errores para probar sus desarrollos. En otras ocasiones,

código no implementado y ya referenciado en otro lugar, producirá un error quedetenga nuestra aplicación; para evitar que se detenga y continuar con el procesonormal, a;adimos alguna excpeción solo para mostrar algún mensaje al usuario; quizáéste no completo lo que buscaba realizar pero con esto al menos el programa noproduce más errores.

Finalmente, como todo en Java, las excepciones no son más que clases. Esto nos llevaa la idea que podemos crear nuestras propias excepciones, lo cual es cierto. Para estonecesitamos crear una clase con el nombre de nuestra excepción y heredar losatributos de la clase Exception.

El constructor puede o no pedir variables, lo único que aquí se hace es enviarle alconstructor de la superclase el texto del error.

Una vez creada nuestra excepción personalizada, ya puede ser utilizada en nuestrocódigo.

throw ObjetoThrowable;

public class Nombre extends Exception{

Nombre(parametros){

super ( "Texto del error" );}

}






8.3.- Finally

El bloque finally se a;ade al final de la instrucción catch y nos sirve para liberar recursosen la memoria. Éste bloque se ejecuta siempre que haya una instrucción try,independientemente de que se produzca o no una excepción.

Éste bloque permite que los objetos que se utilizaron se "limpien" y no se preste aerrores consecuentes. Por ejemplo, imagine el caso donde se haya abierto un archivo ypor alguna razón se produjo una excepción mientras se trabajaba con el mismo, por lotanto no alcanzo a llegar a la instrucción donde se intentaba cerrar, ahí es donde elbloque finally nos ayudaría a cerrar dicho archivo cualquiera que sea el resultado.

En definitiva, podemos resumir lo siguiente:- Try ejecutará código que puede producir o no un error.

- Con catch nos aseguraremos de realizar algo para que, en caso de error, el programacontinúe de manera habitual.- Con el bloque finally, nos aseguraremos de que independientemente de lo quesuceda el programa quede libre de errores.- Con throw lanzaremos excepciones con propósito.





8.4.- Excepciones comunes

Excepción Descripción ArithmeticException Error aritmético, domo la división por cero.

ArrayIndexOutOfBoundsException Índice de un arreglo fuera de los límites ArrayStoreException Asignamiento de un tipo incompatible de

dato a un elemento de un arregloClassCastException Cast inválido

IllegalArgumentException Argumento inválido para invocar unmétodo

IndexOutOfBoundsException Algún tipo de índice fuera de los límitesNegativeArraySizeException Arreglo creado con índice negativo

NullPointerException Uso de una referencia nulaNumberformatException Conversión inválida de String a formato

numéricoStringIndexOutOfBounds Intento de ingresar un string mayor al

límiteUnsupportedOperationException Operación no encontrada

classNotFoundException Clase no encontradaCloneNotSupportedException Intento de clonar un objeto que no tiene

una interfaz clonableIllegalAccessException Acceso a una clase denegadoInstantiationException Intento de crear un objeto de una clase

abstracta o interfaz abstractaInterrumpedException Un thread (hilo) interrumpido por otroNoSuchFieldException Campo requerido no encontrado

NoSuchMethodException Método requerido no encontrado

Apuntes de Programación en JAVA

Documents

Transcript of Apuntes de Programación en JAVA