“Año de la lucha contra la corrupción e impunidad”

UNIVERSIDAD NACIONAL DEL SANTA

FACULTAD DE INGENIERÍA

ESCUELA ACADEMICO PROFESIONAL

INGENIERÍA DE SISTEMAS E INFORMÁTICA

Curso: Programación
Docente: Ing.Carlos E. Vega Moreno
Turno: Tarde
Tema: Programación orientada a objetos
Integrantes:
 More Sulca Cesar Gonzalo
 Aguilar Malca Cesar Leyner
 Cruzado Alegre Axel Arturo
 Castañeda Vasquez Eduardo Jose
 Avila Rodriguez Denis Walter
PROGRAMACION
ORIENTADA
A OBJETOS

2
ÍNDICE
1. INTRODUCCIÓN..............................................................................................................5
2. DEFINICIÓN.....................................................................................................................6
3. PILARES DE LA POO......................................................................................................6
3.1. Abstracción.................................................................................................................6
3.2. Encapsulamiento.........................................................................................................7
3.3. Herencia......................................................................................................................8
3.4. Polimorfismo...............................................................................................................8
4. ABSTRACCIÓN DE DATOS...........................................................................................9
4.1. Nivel Físico..................................................................................................................9
4.2. Nivel Lógico o Conceptual.........................................................................................9
4.3. Nivel de Vistas.............................................................................................................9
5. Arreglos, Expresiones y Control de Flujos.......................................................................9
5.1. Arreglos.......................................................................................................................9
5.2. DECLARACIÓN Y ASIGNACIÓN DE UN ARREGLO........................................9
5.3. ARREGLOS BI-DIMENSIONALES......................................................................10
5.4. ARREGLOS DESIGUALES...................................................................................10
5.5. ALGUNAS CONSIDERACIONES.........................................................................10
5.6. EXPRESIONES........................................................................................................11
5.7. SENTENCIAS DE ASIGNACIÓN.........................................................................11
5.8. BIFURCACIONES – SENTENCIAS DE CONTROL DE SALTOS (IF-ELSE) 12
5.9. BIFURCACIONES – SENTENCIAS DE CONTROL DE SALTOS (SWITCH)12
5.10. BUCLES- SENTENCIAS REPETITIVAS (FOR).............................................13
5.11. BUCLES – SENTENCIAS REPETITIVAS (WHILE)......................................13
5.12. Bucles – Sentencias repetitivas (do-while)..........................................................14
5.13. BUCLES – SENTENCIAS REPETITIVAS (FOR IN) : SÓLO EN JDK 1.5 Ó
TIGGER................................................................................................................................14
5.14. INSTRUCCIONES BREAK Y CONTINUE DENTRO DE UN BUCLE.........14
5.15. BUGS AL UTILIZAR BUCLES.........................................................................15
5.16. RESUMEN............................................................................................................15
6. OPERADORES................................................................................................................15
6.1. ARITMETICOS.......................................................................................................15
6.2. UNARIOS.................................................................................................................15
6.3. DE ASIGANCIÓN....................................................................................................16
6.4. RELACIONALES....................................................................................................17
6.5. LOGICOS.................................................................................................................17

3
 6.6. TERNARIO..............................................................................................................17
6.7. BIT A BIT.................................................................................................................18
6.8. OPERADORES SHIFT...........................................................................................18
7. SENTENCIAS DE CONTROL.......................................................................................18
7.1. Sentencias de toma de decisiones: IF......................................................................19
7.2. Funcionamiento del IF.............................................................................................19
7.3. Sentencias de bucles: WHILE.................................................................................19
7.4. Sentencias de excepciones: TRY..............................................................................20
7.5. Sentencias de misceláneas: BREAK........................................................................20
8. EXCEPCIONES DE PROGRAMACIÓN......................................................................21
8.1. Uso del manejo de excepciones................................................................................21
8.2. Limpieza de pila........................................................................................................22
8.3. Aserciones.................................................................................................................22
8.4. Conclusión.................................................................................................................22
9. Conclusión.........................................................................................................................23

4
 1. INTRODUCCIÓN
Los objetos son entidades que tienen un determinado estado, comportamiento (método)
e identidad:

 El estado está compuesto de datos o informaciones; serán uno o varios atributos

a los que se habrán asignado unos valores concretos (datos).
 El comportamiento está definido por los métodos o mensajes a los que sabe
responder dicho objeto, es decir, qué operaciones se pueden realizar con él.
 La identidad es una propiedad de un objeto que lo diferencia del resto; dicho con
otras palabras, es su identificador (concepto análogo al de identificador de una
variable o una constante).

Un objeto contiene toda la información que permite definirlo e identificarlo frente a

otros objetos pertenecientes a otras clases e incluso frente a objetos de una misma clase,
al poder tener valores bien diferenciados en sus atributos. A su vez, los objetos disponen
de mecanismos de interacción llamados métodos, que favorecen la comunicación entre
ellos. Esta comunicación favorece a su vez el cambio de estado en los propios objetos.
Esta característica lleva a tratarlos como unidades indivisibles, en las que no se separa el
estado y el comportamiento.

Los métodos (comportamiento) y atributos (estado) están estrechamente relacionados

por la propiedad de conjunto. Esta propiedad destaca que una clase requiere de métodos
para poder tratar los atributos con los que cuenta. El programador debe pensar
indistintamente en ambos conceptos, sin separar ni darle mayor importancia a alguno de
ellos. Hacerlo podría producir el hábito erróneo de crear clases contenedoras de
información por un lado y clases con métodos que manejen a las primeras por el otro.
De esta manera se estaría realizando una programación estructurada camuflada en un
lenguaje de programación orientado a objetos.

La POO difiere de la programación estructurada tradicional, en la que los datos y los

procedimientos están separados y sin relación, ya que lo único que se busca es el
procesamiento de unos datos de entrada para obtener otros de salida. La programación
estructurada anima al programador a pensar sobre todo en términos de procedimientos o
funciones, y en segundo lugar en las estructuras de datos que esos procedimientos
manejan. En la programación estructurada solo se escriben funciones que procesan
datos. Los programadores que emplean Programación Orientada a Objetos, en cambio,
primero definen objetos para luego enviarles mensajes solicitándoles que realicen sus
métodos por sí mismos.

5
 2. DEFINICIÓN:
La P.O.O. (también conocida como O.O.P., por sus siglas en inglés) es lo que se conoce
como un paradigma o modelo de programación. Esto significa que no es un lenguaje
específico, o una tecnología, sino una forma de programar, una manera de plantearse la
programación. No es la única (o necesariamente mejor o peor que otras), pero se ha
constituido en una de las formas de programar más populares e incluso muchos de los
lenguajes que usamos hoy día lo soportan o están diseñados bajo ese modelo (PHP, AS2,
AS3,…).
Los objetos interactúan con otros objetos. Con una visión tradicional, un programa es una
colección de subrutinas (funciones o procedimientos); también se puede decir que es una
lista de instrucciones, pasos para distintas funciones en el computador. Así, un objeto es
capaz de recibir información (mensajes, datos) y procesarlos para enviarlos a otros objetos
de manera similar a un servicio.

3. PILARES DE LA POO
La POO tiene varios pilares para asegurar la simplicidad de código y su reutilización, y
aunque diversos autores señalan diversos pilares, en este documento se considerarán los
cuatro que son comunes en la mayoría de textos, estos son: Abstracción,
Encapsulamiento, Herencia y Polimorfismo, las dos primeras están más relacionadas con
la búsqueda de códigos simples y las dos siguientes con la reutilización.

3.1. Abstracción
Es el pilar de la POO, que permite identificar las características y comportamientos de un
objeto y con los cuales se construirá la clase (plantilla). Esto quiere decir que a través de
este pilar o fundamento es posible reconocer los atributos y métodos de un objeto.
La imagen muestra en texto de color negro algunas de las características del objeto: color,
tamaño, marca, son características porque todos los controles pueden tenerlas y cada
objeto de este tipo tomará valores que le identifiquen; el objeto de la imagen tiene los
siguientes valores:
Color: negro
Tamaño: 15
Marca: Samsung

6
De igual forma, se identifican los comportamientos que en la imagen aparecen como
textos de color blanco

3.2. Encapsulamiento
Es la característica de la POO que permite el ocultamiento de la complejidad del código,
pertenece a la parte privada de la clase y que no puede ser vista desde ningún otro
programa.
En el gráfico se representa como la complejidad del código queda oculta dentro de una
caja fuerte impidiendo que quien lo utilice sin observar los detalles de cada una de las
líneas que permiten el cumplimiento de una acción específica.
En realidad, el encapsulamiento está relacionado con el acceso a un código desde el
código de otra clase; sin embargo en términos generales, esta representación gráfica es
conveniente para comprender el concepto de encapsulamiento.

7
 3.3. Herencia
Es el pilar más fuerte que asegura la reutilización de código, ya que a partir de esta
característica es posible reutilizar (heredar) las características y comportamientos de una
clase superior llamada clase padre, a sus clases hijas, denominadas clases derivadas.
Esto implica que una vez desarrollado el código de una clase base, su código puede ser
reutilizado por las clases derivadas.
En el gráfico, Persona es la clase Padre, que tiene como características: CI, nombre,
dirección, fecha Nac, genero, entre otros; y Estudiante y Profesor son las clases "Hijas",
que heredan las características de la clase padre y a su vez establecen las propias de su
clase. Esto implica que no se deberán volver a definir, sino que por el simple hecho de
heredarlas ya es posible utilizarlas y en el caso de los comportamientos ejecutarlos o
modificarlos si es necesario.

3.4. Polimorfismo
A través de esta característica es posible definir varios métodos o comportamientos de
un objeto bajo un mismo nombre, de forma tal que es posible modificar los parámetros
del método, o reescribir su funcionamiento, o incrementar más funcionalidades a un
método.
En el gráfico se observa que todas son figuras geométricas por lo que pueden incluirse
en una clase Padre, por lo que la clase deberá tener el método Área(), este método podrá
ser reescrito tantas veces como figuras existan, con los parámetros correspondientes en
cada clase derivada: Circulo, Triangulo y Rectángulo, o reescrita en la clase base.

8
 4. ABSTRACCIÓN DE DATOS
La abstracción de datos es la característica de un sistema de bases de datos, que permite
al usuario o programador operar con los datos sin necesidad de conocer detalles que
para él no son de “importancia”, ofreciendo así una visión abstracta de estos. Para
cumplir con tal fin se han definido diferentes niveles de abstracción.

4.1.  Nivel Físico. Determina como están almacenados físicamente los datos (pistas,
sectores, cilindros), representa el nivel más bajo.

4.2. Nivel Lógico o Conceptual. Determina la organización de los archivos.

Índices, llaves, orden de campos, relaciones, tipos de datos.

4.3.  Nivel de Vistas. Oculta parte de la información a los usuarios, es decir hace

visible solo una parte de la base de datos.

5. Arreglos, Expresiones y Control de Flujos

5.1. Arreglos
- En Java, Array es un tipo de objeto. Este objeto puede contener objetos ( por
ejemplo, un array de String o de int )
- Se declara una variable de tipo Array mediante [ ]
tipo_basico[] nombre_variable ;
- Por ejemplo : int[ ] values ;
- Como un Array es una clase dinámica, se tiene que construir un objeto de
este tipo mediante el operador new:
nombre_variable = new tipo_basico[numero_de_elementos ] ;

5.2. DECLARACIÓN Y ASIGNACIÓN DE UN ARREGLO

 Primera Posibilidad (Declarar y luego Asignar)
int miArreglo[ ] ;
miArreglo = new int[100] ;
 Segunda Posibilidad (Declarar y Asignar )
int miArreglo[ ] = new int[100];
 Tercera Posibilidad ( Declarar e Inicializar con Valores )
int miArreglo[ ] = { 1,2,5,6,7,3,4 } ;
 Cuarta Posibilidad ( Declaración de múltiples arreglos en una línea )
Int [ ] miArreglo1, miArreglo2 ;

9
5.3. ARREGLOS BI-DIMENSIONALES
 Un arreglo puede contener una arreglo, ej. Si se desea almacenar la
información en forma de una tabla (filas x columnas):
Int tabla [ ] [ ] = new int[3][3]

5.4. ARREGLOS DESIGUALES

 Al contrario que otros lenguajes, Java no le fuerza a especificar el
mismo número de columnas por cada fila
Int [ ] [ ] x = new int [5] [ ] :

5.5. ALGUNAS CONSIDERACIONES

Mientras la manipulación de un arreglo es muy sencilla, tiene ciertas
limitaciones:
 Su tamaño no puede cambiar. No podemos reducirlo si ya no
queremos un elemento o aumentarlo si queremos más elementos.
 Tenemos que recordar nosotros mismos él número de elementos que
tenemos en el array ( que puede ser <= length), por ejemplo con un
conductor.
 Los elementos son del mismo tipo.
Error cómun:
 Intentar manipular un elemento con índice no válido, ej. Si índice es
negativo o sí índice >= length, se lanzará la excepción
ArrayIndexOutOfBoundsException

10
5.6. EXPRESIONES
 Literal y Variables son expresiones primarias :
1.7 // Literal real de tipo double
Sum // Variable
Los literales se evaluan a sí mismos.
Las variables se evaluan a su valor.
 Los operadores nos permiten combinar expresiones primarias y otras
expresiones formadas con operadores :
1 + 2 + 3*1.2 + (4+8)/3.0
5.7. SENTENCIAS DE ASIGNACIÓN
 Las sentencias de asignación constituyen el ingrediente básico en la
construcción de programas con lenguajes imperativos.
Sintaxis:
<variable> = <expresión>;
Ejemplos:
X=x+1;
Int miVariable = 20 ;
otraVariable = miVariable ;
1. ¿Qué es el flujo de un programa?
 Secuencia de Sentencias con un inicio y un final.

 Los delimitadores usados en Java son “{“ para el inicio y “}” para el
fn del bloque

11
5.8. BIFURCACIONES – SENTENCIAS DE CONTROL DE
SALTOS (IF-ELSE)

5.9. BIFURCACIONES – SENTENCIAS DE CONTROL DE

SALTOS (SWITCH)

12
5.10. BUCLES- SENTENCIAS REPETITIVAS (FOR)

5.11. BUCLES – SENTENCIAS REPETITIVAS (WHILE)

13
5.12. Bucles – Sentencias repetitivas (do-while)

5.13. BUCLES – SENTENCIAS REPETITIVAS (FOR IN) : SÓLO

EN JDK 1.5 Ó TIGGER

5.14. INSTRUCCIONES BREAK Y CONTINUE DENTRO DE UN

BUCLE

14
5.15. BUGS AL UTILIZAR BUCLES

5.16. RESUMEN

6. OPERADORES

6.1. ARITMETICOS

Se utilizan para realizar operaciones aritméticas simples en tipos de datos primitivos.

*: Multiplicación
/: División
%: Modulo
+: Adición
–: Resta

6.2. UNARIOS
Los operadores unarios solo necesitan un operando. Se usan para incrementar,
disminuir o negar un valor.

15
 –: Unario menos, utilizado para negar los valores.
 +: Unario más, usado para dar valores positivos. Solo se usa cuando se convierte
deliberadamente un valor negativo en positivo.
 ++: Operador de incremento, utilizado para incrementar el valor en 1. Hay dos
variedades de operador de incremento.

1. Pre-Incremento: el valor se incrementa primero y luego se calcula el resultado.

2. Post-Incremento: el valor se usa por primera vez para calcular el resultado y

luego se incrementa.

 —: Operador de decremento, usado para incrementar el valor en 1. Hay dos

variedades de operador de incremento.

1. Pre-Decremento: el valor se disminuye primero y luego se calcula el resultado.

2. Post-Decremento: el valor se usa por primera vez para calcular el resultado y

luego se disminuye.

 !: Operador lógico “no”, utilizado para invertir un valor booleano.

6.3. DE ASIGANCIÓN
El operador de asignación se usa para asignar un valor a cualquier variable. Tiene
una asociación de derecha a izquierda, es decir, el valor dado en el lado derecho del
operador se asigna a la variable de la izquierda y, por lo tanto, el valor del lado
derecho debe declararse antes de usarlo o debe ser una constante.

El formato general del operador de asignación es, variable = valor;

En muchos casos, el operador de asignación se puede combinar con otros operadores

para construir una versión más corta de la declaración llamada Declaración
Compuesta (Compound Statement). Por ejemplo, en lugar de a = a + 5, podemos
escribir a + = 5.

int a = 5;
a += 5; // a = a + 5;

+ = , para sumar el operando izquierdo con el operando derecho y luego

asignarlo a la variable de la izquierda.
- = , para restar el operando izquierdo con el operando derecho y luego
asignarlo a la variable de la izquierda.
= , para multiplicar el operando izquierdo con el operando derecho y luego
asignándolo a la variable de la izquierda.
/ = , para dividir el operando izquierdo con el operando derecho y luego
asignarlo a la variable de la izquierda.
^ = , para aumentar la potencia del operando izquierdo al operando derecho y
asignarlo a la variable de la izquierda.

16
 % = , para asignar el módulo del operando izquierdo con el operando derecho
y luego asignarlo a la variable de la izquierda.

6.4. RELACIONALES
Estos operadores se utilizan para verificar relaciones como igualdad, mayor que,
menor que. Devuelven el resultado booleano después de la comparación y se usan
ampliamente en las instrucciones de bucle, así como en las sentencias condicionales
if/else. El formato general es, variable operador_relacion valor

Algunos de los operadores relacionales son:

==, Igual a: devuelve verdadero si el valor del lado izquierdo es igual al lado
derecho.
! =, No igual a: devuelve verdadero si el valor del lado izquierdo no es igual al
lado derecho.
<, menos que: el resultado verdadero si el valor del lado izquierdo es inferior al
del lado derecho.
<=, menor o igual que: devuelve verdadero si el valor del lado izquierdo es
menor o igual que el lado derecho.
>, Mayor que: devuelve verdadero si el valor del lado izquierdo es mayor que el
lado derecho.
>=, Mayor que o igual a: regresa verdadero si el valor del lado izquierdo es
mayor o igual que el lado derecho.

6.5. LOGICOS
Estos operadores se utilizan para realizar operaciones “lógicas AND” y “lógicas OR”,
es decir, la función similar a la puerta AND y la puerta OR en electrónica digital. Una
cosa a tener en cuenta es que la segunda condición no se evalúa si la primera es falsa, es
decir, tiene un efecto de cortocircuito. Se usa ampliamente para probar varias
condiciones para tomar una decisión.

Los operadores condicionales son:

&&, AND lógico: devuelve verdadero cuando ambas condiciones son verdaderas.
||, O lógico: devuelve verdadero si al menos una condición es verdadera.

6.6. TERNARIO
Ternario es una versión abreviada de la declaración if-else. Tiene tres operandos y de
ahí el nombre ternario. El formato general es: condición? if true : if false

La declaración anterior significa que si la condición se evalúa como verdadera,

entonces ejecuta las instrucciones después del ‘?‘ de lo contrario, ejecuta las
instrucciones después de ‘:‘.

17
 6.7. BIT A BIT

Los operadores a nivel de bits se utilizan para realizar la manipulación de bits

individuales de un número. Se pueden usar con cualquiera de los tipos enteros. Se
utilizan al realizar operaciones de actualización y consulta de árbol indexado binario.

 &,  Operador  bit a bit AND: Si ambos bits de entrada son 1, establece el
resultado en 1. De lo contrario da como resultado 0. El resultado binario final se
muestra en decimal.
 |  ,  Operador  bit a bit OR: Si al menos uno de los dos bits de entrada es 1,
establece el resultado en 1. De lo contrario da como resultado 0. El resultado
binario final se muestra en decimal.
 ^,  Operador bit a bit XOR: Si uno de los bits de entrada es 0 y el otro 1, el
resultado es 1. Si ambos bits comparados son iguales, el resultado es 0. El
resultado binario final se muestra en decimal.
 ~,  Operador bit a bit de complemento (NOT) : este es un operador unario que
devuelve la representación complementaria del valor de entrada, es decir, con
todos los bits invertidos. El resultado binario final se muestra en decimal.

6.8. OPERADORES SHIFT

Los operadores shift de Java se usan para desplazar los bits de un número hacia la izquierda o
hacia la derecha, multiplicando o dividiendo el número por dos, respectivamente. Se pueden usar
cuando tenemos que multiplicar o dividir un número por dos.

 <<, operador de desplazamiento a la izquierda: desplaza los bits del número hacia la
izquierda y llena con “0” los bits desplazados. Efecto similar a la multiplicación del número
con una potencia de dos.

 >>, Operador de desplazamiento a la derecha firmado: desplaza los bits del número a la
derecha y llena con “0” los bits desplazados. El bit más a la izquierda depende del signo del
número inicial. Efecto similar a partir de dividir el número con alguna potencia de dos.

 >>>, Operador de cambio a la derecha sin signo: desplaza los bits del número a la derecha
y llena con “0” los bits desplazados. El bit más a la izquierda se establece en 0.

7. SENTENCIAS DE CONTROL
Su propósito es determinar el orden en que se ejecutaran las distintas sentencias dentro
del programa. Java soporta varias sentencias, como por ejemplo:
-Toma de decisiones con if o else, switch o case.
-Bucles utilizando for, while, do o while.
-Excepciones con try, catch o finally y con throw.
-Miscelaneas utilizando break, continue, label o return.
18
Vamos a poner un ejemplo de cada una de las sentencias de cada apartado.
7.1. Sentencias de toma de decisiones: IF
La sentencia if, actúa como cabría esperar. Si la condición es verdadera, la sentencia se
ejecuta, de otro modo, se salta dicha sentencia, continuando la ejecución del programa
con otras sentencias a continuación de ésta. La forma general de la sentencia if es:

7.2. Funcionamiento del IF

Si el resultado del test es verdadero (true) se ejecuta la sentencia que sigue a
continuación de if, en caso contrario, falso (false), se salta dicha sentencia, tal como se
indica en la figura. La sentencia puede consistir a su vez, en un conjunto de sentencias
agrupadas en un bloque.
if (condición){
sentencia1;
sentencia2;
}
En el siguiente ejemplo, si el número del boleto que hemos adquirido coincide con el
número aparecido en el sorteo, nos dicen que hemos obtenido un premio.
if(numeroBoleto==numeroSorteo)
System.out.println("has obtenido un premio");
7.3. Sentencias de bucles: WHILE
Se utilizan cuando queremos repetir la ejecución de unas sentencias un número
indefinido de veces, siempre que se cumpla una condición. Es más sencillo de
comprender que el bucle FOR, pues no incorpora en la misma línea la inicialización de
las variables su condición para seguir ejecutándose y su actualización. Sólo se indica,
como veremos a continuación, la condición que se tiene que cumplir para que se realice
una iteración.
var color = ""
while (color != "rojo"){
color = prompt("dame un color (escribe rojo para salir)","")
}

19
En este ejemplo vamos a declarar una variable e inicializarla a 0. Luego iremos
sumando a esa variable un número aleatorio del 1 al 100 hasta que sumemos 1.000 o
más, imprimiendo el valor de la variable suma después de cada operación. Será
necesario utilizar el bucle WHILE porque no sabemos exactamente el número de
iteraciones que tendremos que realizar (dependerá de los valores aleatorios que se vayan
obteniendo).
var suma = 0;
while (suma < 1000){
suma += parseInt(Math.random() * 100);
document.write (suma + "<br>");
}
7.4. Sentencias de excepciones: TRY
Todo el código que vaya dentro de esta sentencia será el código sobre el que se intentará
capturar el error si se produce y una vez capturado hacer algo con él. Lo ideal es que no
ocurra un error, pero en caso de que ocurra un bloque try nos permite estar preparados
para capturarlo y tratarlo.
Este sería un ejemplo de esta sentencia.
try {
System.out.println(“bloque de código donde pudiera saltar un error es este”);
}
7.5. Sentencias de misceláneas: BREAK
Aparece en los bucles, esta sentencia se utiliza para ordernar a Flash que se omita el
resto del bucle, detenga la acción de bucle y ejecute la sentencia a continuación de la
sentencia de bucle. Cuando se utiliza en una sentencia switch, la sentencia break ordena
a Flash que omita el resto de sentencias en ese bloque de sentencias case y que salte a la
primera sentencia que vaya a continuación del bloque switch.
var i:Number = 0;
while (true) {
trace(i);
if (i >= 10) {
break; // esto terminará/saldrá del bucle
}
i++;
}

8. EXCEPCIONES DE PROGRAMACIÓN
Una excepción en términos de lenguaje de programación es la indicación de un
problema que ocurre durante la ejecución de un programa. Sin embargo, la palabra
excepción se refiere a que este problema ocurre con poca frecuencia generalmente
cuando existe algún dato o instrucción que no se apega al funcionamiento del programa

20
por lo que se produce un error. El manejo de excepciones permite al usuario crear
aplicaciones tolerantes a fallas y robustas (resistentes a errores) para controlar estas
excepciones y que pueda seguir ejecutándose el programa sin verse afectado por el
problema. En lenguaje java estas excepciones pueden manejarse con las clases que
extienden el paquete Throwable de manera directa o indirecta, pero existen diversos
tipos de excepciones y formas para manejarlas.
8.1. Uso del manejo de excepciones
El manejo de excepciones ayuda al programador a trasladar el código para manejo de
errores de la línea principal de ejecución, además se puede elegir entre manejar todas las
excepciones, las de cierto tipo o de las de grupos relacionados, esto hace que la
probabilidad de pasar por alto los errores se reduzca y a la vez hace los programas más
robustos. Pero es importante utilizar un lenguaje de programación que soporte este
manejo, de lo contrario el procesamiento de errores no estará incluido y hará el
programa más vulnerable. Este manejo está diseñado para procesar errores que ocurren
cuando se ejecuta una instrucción, algunos ejemplos son: desbordamiento aritmético,
división entre cero, parámetros inválidos de método y asignación fallida en la memoria.
Sin embargo, no está diseñado para procesar problemas con eventos independientes al
programa como son pulsar una tecla o clic al mouse.
Las excepciones se dividen en verificadas y no verificadas. Es importante esta división
porque el compilador implementa requerimientos de atrapar o declarar para las
verificadas lo que hará que se detecten las excepciones automáticamente y de acuerdo al
lenguaje de programación utilizado se utilizará un método para corregirlas. Sin embargo
para las no verificadas se producirá un error indicando que deben atraparse y declararse.
Por eso el programador debe pensar en los problemas que pueden ocurrir cuando se
llama a un método y definir excepciones para verificarse cuando sean importantes. Las
clases de excepciones pueden derivarse de una superclase común, por lo que con un
manejador para atrapar objetos de la superclase, también se pueden atrapar todos los
objetos de las subclases de esa clase. Pero también, se pueden atrapar a cada uno de los
tipos de las subclases de manera individual si estas requieren ser procesadas diferente.
A cada célula se le conoce como compiladora de distintos.
8.2. Limpieza de pila
En ocasiones cuando se lanza una excepción, pero no se atrapa en un enlace específico,
la pila de llamadas se limpia y el programa intenta volverlo a atrapar en el siguiente
bloque, esto se conoce como limpieza de pila. Este proceso hace que el método en el
que no se atrapó la excepción termine, todas sus variables quedan fuera del enlace y el
control regresa a la instrucción que originalmente la invocó. La limpieza de pila se
repetirá hasta que la excepción pueda ser atrapada porque de lo contrario se producirá
un error a la hora de compilar.
8.3. Aserciones
Las aserciones ayudan a asegurar la validez del programa al atrapar los errores
potenciales e identificar los posibles errores lógicos del desarrollo. Estas pueden
escribirse como comentarios para apoyar a la persona que desarrolla el programa.
Algunos ejemplos son:
Precondiciones y pos condiciones:

21
 Estas características son utilizadas por los programadores para hacer un análisis de lo
esperado del programa antes y después de su ejecución. Son importantes porque gracias
a ellas se pueden detectar posibles fallas en el programa y corregirlas.
Las precondiciones son verdaderas cuando se invoca a un método, estas describen las
características del método y las expectativas que se tienen en el estado actual del
programa. Si no se cumplen las precondiciones el comportamiento del método es
indefinido por lo que se lanza una excepción que esté preparada o continuar con el
programa esperando el error. Las pos condiciones describen las restricciones en el
entorno y cualquier efecto secundario del método. Es recomendable escribirlas para
saber que esperar en un futuro si es que se hacen modificaciones.
8.4. Conclusión
El manejo de excepciones ayuda a lidiar con los errores de una aplicación por medio de
la manipulación del código para hacer programas más robustos. Además, existen
herramientas que ayudan a manejarlas tal es el caso de los bloques try (intentar) que
encierran el código que puede lanzar una excepción y los bloques el catch (atrapar) que
lidian con las excepciones que surjan. También existen técnicas que el programador
utiliza para conocer el posible funcionamiento del programa y detectar los errores que
pueda contener.

9. Conclusión
En la P.O.O un objeto no es un dato simple, tiene contenido en su interior un gran
número de componentes muy bien estructurados, ese objeto no es un ente aislado, sino
que forma parte de una organización jerárquica o de otro tipo.

            Este tipo de programación contiene una identidad, una clasificación, un polimorfismo y
una herencia para caracterizar un lenguaje orientado a objetos, estos términos podrían
utilizarse de un modo independiente uno de otro, pero juntos complementan una
relación sinérgica. Son muchos los beneficios que se pueden obtener de la programación
orientada a objetos de los que podemos ver a simple vista.

            El concepto de programación orientada a objetos no es un término nuevo, ya que ha

sido utilizado en ocasiones anteriores, dado que se basa en la idea natural de la
existencia de un mundo lleno de objetos y que la resolución del problema se realiza en
términos de objetos, un lenguaje se dice que está basado en objetos si soporta objetos
como una característica fundamental del mismo.

22
LINKOGRAFÍA

https://l.facebook.com/l.php?u=https%3A%2F%2Fjavadesdecero.es%2Fbasico
%2Foperadores-en-java-ejemplos%2F%3Ffbclid
%3DIwAR0uHhv2KQsn6oCQiKzPAfsOwehLRxt4RCas-
04rToH7f4kHpB1SB1Z3Ms0%23targetText%3DComo%2520por%2520ejemplo
%253A%2520Operadores%2520relacionales%2Cpueden%2520usar%2520seg
%25C3%25BAn%2520la%2520necesidad.%26targetText%3DOperadores%2520l
%25C3%25B3gicos%2COperador
%2520ternario&h=AT3pMyxvvwj7lYzIhENDNdTXVDWvppnOopYWgd71x7YR3Ln
TNI8EpqO3Xl0VLvbhV_JJkvhCHCDnBDC6IGGpQG0ih5Y960YMQtz7bYOCjSisE3
ksd88VwrMlPDBN4wqZTC4wXg

http://www.programacionenjava.com/blog/2008/07/01/javabasico/sentencias-de-
control-de-flujo-en-java/

https://vcalpena.wordpress.com/4-excepciones/

http://www.ciberaula.com/cursos/java/programacion_orientada_objetos.php

23