Vídeo-código: Avión - Parte III

Loading...

Del curso dictado por Universidad de los Andes

Introducción a la programación orientada a objetos en Java

65 calificaciones

Universidad de los Andes

Introducción a la programación orientada a objetos en Java

65 calificaciones

¡Le damos la bienvenida al curso de Introducción a la programación en java por objetos de la Universidad de los Andes! El propósito de este curso es ofrecerle un ambiente interactivo orientado a construir aprendizajes sobre el lenguaje de la programación en Java para la creación y manipulación de objetos. La estrategia pedagógica empleada es el aprendizaje activo basado en casos. Es un curso altamente interactivo que constantemente lo reta a responder preguntas, verificar su comprensión, ejercitarse en código, resolver casos en diferentes niveles y múltiples oportunidades para pasar de la teoría a la práctica con actividades formativas que le permitirán ganar puntos de experiencia, puntos de competencia y puntos de habilidad, con los cuales desarrollará habilidades de abstracción y de programación. Además, podrá utilizar dos aplicaciones web desarrolladas por la Universidad de los Andes que son novedosas e importantes para el desarrollo de habilidades de programación: 1. CupiExámenes: Software de ejercitación en código Java, que ofrece retroalimentación automática sobre la escritura incorrecta del código y califica el proceso de programación es decir, le indica si el resultado está bien o mal, dónde se equivocó y por qué. 2. CupiTips: Es otra aplicación web donde puede encontrar una lista de errores comunes que se cometen al programar en Java y le permite al estudiante corregirlos de manera que pueda aprender de ellos. La Universidad de los Andes está poniendo a su disposición y de forma gratuita estas aplicaciones, así como los libros que le permitirán nivelarse o aclarar algunos conceptos importantes, si así lo necesita para poder tomar este curso. Tenga en cuenta que el tiempo estimado para la realización de las actividades de cada módulo es de 14 horas en promedio. Usted puede invertir este tiempo en un periodo de 1 o 2 semanas por módulo, de acuerdo con sus posibilidades y necesidades educativas. Así mismo le recomendamos que desarrolle todas las actividades educativas en el orden propuesto, de manera que pueda sacar mejor provecho de este curso.

De la lección

Módulo 2: Arreglos y vectores

¡Le damos la bienvenida al módulo 2! La construcción del modelo conceptual del mundo del problema en muchas ocasiones implica usar el concepto de colección o grupos de elementos de la misma clase, y manejar estrategias para añadir nuevos elementos a ese grupo o para buscar un elemento en particular dentro de dicha colección. En este módulo vamos a tratar algunos conceptos fundamentales de la programación que nos permiten manejar grupos de elementos: los arreglos y las matrices, que son estructuras contenedoras de 1 y 2 dimensiones. Usaremos estas entidades para representar colecciones de datos u objetos en nuestro modelo del mundo. Además, vamos a revisar las diferentes operaciones algorítmicas que podemos realizar sobre las estructuras de datos en 1 y 2 dimensiones, ya sea para agregar y eliminar elementos o para realizar tanto búsquedas como manipulaciones de los objetos contenidos allí. Tenga en cuenta que el tiempo estimado para la realización de todas las actividades de este módulo es de cerca de 16 horas, tiempo que usted puede invertir de acuerdo con sus posibilidades. Le recomendamos que desarrolle todas las actividades en el orden propuesto y que considere hacerlo en un tiempo de dos semanas.

Vídeo-código: Avión - Parte I4:45

Vídeo-código: Avión - Parte II11:13

Vídeo-código: Avión - Parte III9:23

Vídeo-código: Avión - Parte IV2:26

Vídeo-código: Visor Imágenes13:02

Conoce a los instructores

Marcela Hernández Hoyos
Profesora Asociada
Ingeniería de Sistemas y Computación
Álvaro Andrés Gómez D’Alleman
Coordinador Académico
Ingeniería de Sistemas y Computación
Juan Pablo Reyes Gómez
Investigador en Computación Gráfica y Astrofísica
Ingeniería de Sistemas y Computación

[música de fondo]

Continuamos, entonces tenemos un método

se llama asignar silla,

dada la clase y la ubicación de un pasajero,

vamos a asignar pasajero a la silla,

miremos el método buscar silla ejecutiva libre,

éste método recibe una ubicación preferida

por el usuario y busca la primera silla ejecutiva

que corresponda a esa ubicación,

si es ventana o pasillo.

Entonces lo que vamos a hacer es

un recorrido parcial

donde nos vamos a detener apenas encontramos

una silla con esas condiciones,

sino retornamos en uno,

entonces

primero nuestras variables que nos

van a permitir llevar el estado del ciclo

vamos a realizar nuestro ciclo, es un for

Entonces utilizamos una variable de control,

un "i" de índice,

si queremos y vamos a iterar por todas las sillas ejecutivas,

siempre y cuando nuestra variable encontrada

sea igual a false, es decir

mientras no hayamos encontrado,

lo que estamos buscando,

no hayamos encontrado la silla ejecutiva con la ubicación deseada.

Entonces empecemos

nuestra variable silla la vamos a utilizar

para llevar el control de las sillas en cada posición

"i" del arreglo individualmente

de las sillas ejecutivas

y vamos a comparar. Entonces sí, la silla

.silla asignada

es decir está libre,

no está asignada, es decir esto nos dará false

y además

la ubicación de esta silla

corresponde

a la ubicación que recibimos como parámetro,

en este caso

record, cambiamos

nuestra variable encontrada true porque ya encontramos la silla.

Es decir si la silla esta libre y es de una ubicación que nos sirve,

entonces está encontrada

y acabamos nuestro ciclo haciendo una condición simple,

sí encontramos la silla,

retornamos la silla,

es decir este return va a acabar el ciclo inmediatamente

y de lo contrario,

retornamos null.

Esto si nos damos cuenta

tiene que estar fuera del ciclo,

acá lo que estamos haciendo sí la variable cambia,

retornamos la variable y de lo contrario retornamos de nuevo

pero ¿Qué va a pasar? es que tenemos que revisar todas las sillas

¿Cierto?

Entonces

hasta aquí si hacemos eso lo ponemos fuera del ciclo,

una vez se acabe el ciclo

y el ciclo se va a acabar justamente

cuando encontrado= true,

no vamos a iterar más y vamos a retornar sillas.

Sí el ciclo se acaba porque se nos acabaron las sillas a buscar,

entonces este condicional va a retornarnos null

¿Existe otra manera de hacerlo?

si, justamente

podemos ahorrarnos un par de líneas

super sencillo y podemos decir lo siguiente

vamos a recorrer todo el arreglo,

no vamos a necesitar nuestra variable encontrada

porque apenas encontremos la silla sí cumple la condición

la vamos a retornar.

De lo contrario

sí el ciclo se acaba

porque llegamos al final de las sillas ejecutivas

en ese caso entonces

siempre vamos a retornar null al final del ciclo

porque el ciclo se acabó de manera natural

y no por ésta instrucción de retorno

que hace que el ciclo no termine en sus iteraciones normales.

Este es un patrón de recorrido parcial

porque en el caso en el que haya un elemento

que tenga las características que estamos buscando, va a terminar.

Vamos entonces a buscar silla económica libre,

silla económica libre dada la ubicación

es exactamente lo mismo

justamente vamos a utilizar entonces

la estructura que acabamos de ver pero recordemos, uno,

esto es sobre sillas económicas,

el arreglo que queremos ver es sillas económicas

y ya.

Esos son los dos únicos cambios que tenemos que hacer,

revisando la ubicación que en este caso va

a ser ventana, central o pasillo

y vamos a mirar los métodos buscar pasajero ejecutivo y

buscar pasajero económico.

En éste caso entonces

lo que tenemos que hacer es exactamente lo mismo,

es un patrón de recorrido parcial,

comenzamos lo mismo,

hacemos las mismas variables para tener el control de nuestro ciclo

y vamos a hacer lo siguiente,

vamos a hacer un ciclo

que vaya desde i=0

y menor que sillas ejecutivas

porque estamos buscando en este arreglo a nuestro pasajero

y no lo hayamos encontrado,

siguiendo entonces la estructura que vimos inicialmente,

aumentando de uno en uno.

Hacemos lo siguiente,

recibimos en la variable silla,

la silla en la posición "i"

de nuestro arreglo sillas ejecutivas

y hacemos la comparación, sí silla.

silla asignada es true, es decir,

sí la silla está asignada, es decir hay un pasajero,

no vale la pena revisar las que no están vacías

y el pasajero que está en la silla

es igual al pasajero que recibimos como parámetro,

entonces

decimos que lo encontramos

¿Correcto?

Acá hay un pequeño error,

obviamente esta variable se llama silla no sillas

y como miramos, como habíamos dicho antes después del ciclo,

utilizamos la variable encontrados, sí encontrados

es verdadera, es true,

lo que significa que hemos salido

del ciclo de manera no natural,

sino porque encontramos

una silla asignada

que además correspondía al pasajero por parámetro,

entonces retornamos esa silla,

de lo contrario

significa que el ciclo se acabó

naturalmente al llegar

al final de las sillas ejecutivas y regresamos null.

Entonces pues

queda a cada uno tratar de hacer la versión corta de este método

con un poquito menos de líneas de código.

Vamos a hacer lo mismo para buscar pasajero económico

pero recordemos entonces que--

entonces cambiamos el número

que nos va a definir cuántas vamos a recorrer

sobre cual arreglo,

entonces sillas económicas

pero el cuerpo del método viene a ser el mismo,

no tenemos que hacer ningún otro cambio más

y ya hemos terminado acá,

guardamos.

Y vamos finalmente a los últimos métodos,

dice contar sillas ejecutivas ocupadas

para contar las sillas ejecutivas ocupadas,

pues vamos a utilizar una variable contadora.

Recordemos que éste tipo de métodos

es recorrido total,

recorrido total quiere decir

que tenemos que recorrer siempre todo el arreglo

para estar seguro de haber hecho bien nuestro método,

pues comenzamos con nuestro índice,

el índice por todas las sillas ejecutivas

y para dos más,

entonces lo que hacemos es lo siguiente,

sí la silla en la posición "i" del arreglo sillas ejecutivas

está asignada, es decir, que éste método nos retorna true,

vamos a aumentar en uno el contador,

esto quiere decir contador++

De lo contrario

no hacemos nada,

entonces no vale la pena ponerlo ¿Cierto?

Y finalmente

retornamos al final de nuestro ciclo

no después del if, al final de nuestro ciclo

después de haberlo terminado,

este contador,

es necesario ir y revisar hasta la última silla

por si la última también está ocupada.

Y esto mismo es lo que vamos a aplicar

si tenemos que contar las sillas económicas,

la diferencia bueno,

tenemos que iterar sobre el número de sillas económicas

para el arreglo de sillas económicas.

¿Bien? esto debería terminar.

Ya tenemos todos nuestros métodos

bien implementados

a través de ciclos simples con recorrido parcial

y recorrido total.

[música de fondo]

Explora nuestro catálogo

Inscríbete de manera gratuita y obtén recomendaciones personalizadas, actualizaciones y ofertas.

Coursera brinda acceso universal a la mejor educación del mundo, al asociarse con las mejores universidades y organizaciones, para ofrecer cursos en línea.

© 2018 Coursera Inc. Todos los derechos reservados.

Descargar en la App Store

Consíguelo en Google Play