DEPARTAMENTO DE DISEÑO E IMAGEN - … · PROGRAMACIÓN TECNOLOGÍAS DE LA INFORMACIÓN Y...

ELABORÓ: UNIVERSIDAD TECNOLÓGICA

REVISÓ: UNIVERSIDAD(ES) TECNOLÓGICA(S)

AUTORES: MSC Erika Rodallegas Ramos, MC Pedro Martínez Galaviz

REVISORES:

APROBÓ: COMISION NACIONAL ACADÉMICA

DE TIC FECHA DE ENTRADA EN VIGOR:

Universidad Tecnológica de Puebla Tecnologías de la Información y Comunicación

Manual de Asignatura Basado en Competencias Profesionales

Programación

Enero-Abril 2012

PROGRAMACIÓN

TECNOLOGÍAS DE LA INFORMACIÓN Y COMUNICACIÓN

2

INDICE

Contenido

INTRODUCCIÓN ...................................................................................................... 4

I.UNIDAD TEMÁTICA I FUNDAMENTOS DE PROGRAMACIÓN ORIENTADA A OBJETOS. ......... 6

1.1 FUNDAMENTOS DE LA POO. .................................................................................. 6

1.2 CARACTERÍSTICAS DE LA POO ............................................................................. 18

II.UNIDAD TEMÁTICA II AMBIENTE DE DESARROLLO DE LA POO. ................................... 24

2.1 GENERALIDADES DE LA HERRAMIENTA DE DESARROLLO. ........................................ 25

2.2 CARACTERÍSTICAS DE LA INTERFAZ DE DESARROLLO. ............................................. 27

III.UNIDAD TEMÁTICA III PROGRAMACIÓN ORIENTADA A OBJETOS. ............................... 31

3.1 ESTRUCTURA BÁSICA DE UNA CLASE ..................................................................... 33

3.2 ASPECTOS LÉXICOS ............................................................................................. 33

3.3 CLASES Y OBJETOS ............................................................................................. 37

3.4 ESTRUCTURAS DE CONTROL ................................................................................. 53

3.5 ENCAPSULAMIENTO. ............................................................................................ 58

3.6 HERENCIA. .......................................................................................................... 60

3.7 POLIMORFISMO. .................................................................................................. 62

IV. UNIDAD TEMÁTICA IV ARREGLOS. ........................................................................ 65

4.1 DEFINICIÓN DE ARREGLOS................................................................................... 66

4.2 MANEJO DE ARREGLOS ........................................................................................ 66

V. UNIDAD TEMÁTICA V MANEJO DE EXCEPCIONES. ..................................................... 72

5.1 CONCEPTO Y TIPOS DE EXCEPCIONES. ................................................................... 73

5.2 MANEJO DE EXCEPCIONES. ................................................................................... 74

5.3 CREACIÓN Y LANZAMIENTO DE EXCEPCIONES. ........................................................ 79

PROGRAMACIÓN


3

REFERENCIAS ......................................................................................................... 81

ANEXO 1 : LISTA DE COTEJO DE LA MATERIA ............................................................... 82

ANEXO 2 : RUBRICA PARA PORTAFOLIO DEL ALUMNO ................................................... 83

ANEXO 3 : RÚBRICA PARA EXPOSICIONES.................................................................... 84

ANEXO 4 : RÚBRICA PARA EVALUAR EL “SER” ............................................................ 85

PROGRAMACIÓN


4

INTRODUCCIÓN

El siguiente documento integra información acerca de temas relacionados con la asignatura de Programación. El objetivo principal del documento es brindar al alumno información que le permita trabajar sobre el diseño de pequeños sistemas de cómputo, ésta materia es la primera que el alumno tendrá en la que usará un lenguaje de programación, motivo por el cual, la complejidad de los ejercicios será de nivel bajo-medio, el lenguaje de programación utilizado es C#. Comenzaremos con los fundamentos de la programación orientada a objetos, después daremos un recorrido al ambiente de desarrollo, de tal manera que el alumno se familiarice con ésta herramienta, la unidad 3 es la que ocupa el grueso del cuatrimestre, ya que ésta abarca desde la estructura básica de una clase hasta temas más completos como la herencia y el polimorfismo. La unidad 4 tratará el tema de arreglos y para finalizar, manejo de excepciones. Es importante recalcar que para que el alumno culmine con éxito ésta asignatura, deberá tener un buen nivel de abstracción, el cual será desarrollado con la elaboración de cada una de las prácticas propuestas en el curso. Con la finalidad de que el alumno pueda aplicar algunos de los conocimientos adquiridos durante el desarrollo de la asignatura, en este manual se integran prácticas que le permitirán comprender conceptos y desarrollar su nivel de abstracción. DESARROLLO El manual está compuesto por 5 unidades temáticas:

I. Fundamentos de programación orientada a objetos

II. Ambiente de desarrollo de la POO

III. Programación orientada a objetos

IV. Arreglos

V. Manejo de excepciones

Cada uno de estas unidades cuenta con información que sustenta cada uno de los temas contenidos en la unidad. Esta información en su mayoría ha sido colectada de libros, sitios de internet, para brindar al alumno información seria y de calidad. Se integran prácticas a los temas para fortalecer el aprendizaje significativo del alumno.

PROGRAMACIÓN


5

I. Unidad Temática I Fundamentos de programación orientada a objetos. Objetivo: El alumno identificará los fundamentos de la programación orientada a objetos para abstraer los elementos de un escenario.

Temas Saber Saber hacer Ser

Fundamentos de la POO.

Identificar el paradigma de la POO. Describir los conceptos de objetos y clases (métodos y atributos).

Representar los métodos y atributos, de un conjunto de objetos a partir de un modelo real.

Analítico. Ordenado. Sistemático. Hábil para comunicarse de forma oral y escrita. Hábil para trabajo en equipo.

Características de la POO

Identificar las características de la POO: abstracción, herencia, encapsulamiento y polimorfismo.

Representar las clases, la herencia, el encapsulamiento y el polimorfismo en un escenario.

Analítico. Ordenado. Sistemático. Hábil para comunicarse de forma oral y escrita. Hábil para trabajo en equipo.

Resultado de aprendizaje: Elaborará, a partir de un problema planteado, un modelo conceptual donde identifique las clases (atributos y métodos), encapsulamiento, herencia y polimorfismo.

PROGRAMACIÓN


6

UNIDAD I. FUNDAMENTOS DE PROGRAMACIÓN ORIENTADA A OBJETOS.

El objetivo de esta sección es presentar los elementos básicos del modelo Orientado a Objetos (OO). Para iniciar, se propone considerar las siguientes ideas: “ … la Programación Orientada a Objetos (POO) se parece mucho a la cerveza … A la mayoría de la gente que la prueba por primera vez no le gusta, y podría cuestionar la salud mental de quienes cuentan sus alabanzas. ¿Qué te hice – dirían – para que me hicieras beber esto? Algún tiempo después, sin embargo, se cultiva un gusto por la cerveza en quienes continúan bebiéndola. La POO como la cerveza, es un gusto que se adquiere con el tiempo. Otro parecido de la POO con la cerveza es: puede provocar desorientación, causar náuseas y una visión alterada del mundo” . “La POO es un conjunto de conceptos e ideas. Es una manera de pensar en el problema al que va dirigido una aplicación y de afrontarlo de modo más intuitivo e incluso más productivo. El enfoque OO es más intuitivo y más cercano a cómo muchos de nosotros pensaríamos en la manera de afrontar un problema”. En el modelo OO, “en lugar de tratar de modelar un problema en algo familiar a la computadora se trata de acercar la computadora al problema. Es decir, modelar la realidad del problema a través de entidades independientes pero que interactúan entre sí y cuyas fronteras no estén determinadas por su instrumentación computacional sino por la naturaleza del problema. Estas entidades serán denominadas objetos por analogía con el concepto de objeto en el mundo real”. Esto es tal vez lo bello de la POO, la sencillez de sus conceptos. Resolver problemas consiste en definir objetos y sus acciones y entonces invocar las acciones enviando mensajes a los objetos que ocultan las características internas de cómo se llevan a cabo estas acciones. Esta forma de resolver problemas luce familiar y lógica y ha sido utilizada por otras disciplinas científicas ya que en nuestra experiencia diaria nosotros manipulamos objetos” .

Identificación de Objetos y Clases

Para mostrar algunas de las principales ideas del modelo de objetos, se presenta a continuación una situación de la vida diaria.

Situación de Análisis Un niño de aproximadamente dos años de edad puede decirle a su papá: esta es mi mamita, estos son mis juguetes y señalar hacia un balón, dos camiones y tres soldaditos, esto es una silla, esto es una mesa, esto es un jabón, este es mi cepillo, etc. Incluso, muchas veces cuando se encuentra en el carro de su papá (VW Golf año 85), es capaz de decirle al mismo que arranque, que pite o que ponga la música. De igual forma, al interrogársele, el niño dice su nombre (Alejandro) y el de sus padres (Gloria y Alexis). También si a este niño se le indica que vaya a lavarse los dientes sin dudarlo seleccionará su propio cepillo (aún cuando no se pueda cepillar los dientes correctamente). Este mismo niño es capaz de encender y apagar un ventilador o un televisor e incluso en alguna ocasión apagar el carro de su papá. Aproximadamente con tres años de edad es capaz de decir entonces: “el carro de papá es rojo”, o que “el carro de tío es azul”, etc. Por lo general, en su casa y en un día normal, llegada la hora de dormir, el referido niño le dice a su mamá o a su papá: tengo sueño; entonces el receptor de este mensaje (mamá o papá) se ocupa de dormir al niño (o solicita la ayuda del otro) y para ello debe llevar a cabo una serie de acciones (prepararle la leche, cambiarle la ropa, acostarlo con la cabecita sobre la almohada, darle a tomar el vaso de leche e incluso acostarse a su lado hasta que se duerma).

PROGRAMACIÓN


7

Pregunta: ¿Por qué un niño es capaz de decir o hacer las cosas que se relacionan en la situación de análisis? Aún cuando no se tiene ningún conocimiento de psicología infantil, se puede asegurar que un niño es capaz de decir o hacer esas cosas porque desde edades muy tempranas los seres humanos son capaces de identificar y clasificar elementos o entidades (objetos) del mundo que le rodea. Incluso, de determinar las características y las funcionalidades (responsabilidades) de determinados elementos; así como relacionarse con el entorno y particularmente comunicarse con sus semejantes. Al igual que en el quehacer diario, en el modelo OO cobran vital importancia procesos lógicos del pensamiento como identificación y clasificación. Ejemplo: Determinar algunos de los objetos que aparecen en la situación de análisis presentada con anterioridad y las responsabilidades que aparezcan de forma explícita. Establezca además algún tipo de clasificación para los objetos hallados. La solución del ejemplo se presenta en la siguiente tabla:

Clasificación Objeto Responsabilidades

Niño Alejandro Nombre Edad Juguetes Cepillarse los dientes Encender y apagar algunos electrodomésticos

Mamá Gloria Nombre Dormir al niño

Papá Alexis Nombre Arrancar el carro Tocar el claxon Dormir al niño

Carro VW Marca Modelo Año de fabricación Color Arranca Pitar

Vale aclarar que en la situación planteada existen algunos objetos que no se han identificado, e incluso de los identificados no se señalaron todas sus responsabilidades con el objetivo de no sobrecargar mucho el texto. De forma natural, al extraer los objetos Alejandro, Gloria, Alexis y VW se han clasificado en Niño, Mamá, Papá y Carro respectivamente y se han determinado características y funcionalidades (responsabilidades) que corresponden a ellos. De forma general todos los niños de la colonia son ejemplares de la clasificación Niño, todos los padres de la clasificación Papá o Mamá y los carros ejemplares de Carro. En el modelo OO a estas clasificaciones

PROGRAMACIÓN


8

se les denomina clases. De cada clase se pueden tener varios ejemplares los cuales se denominan objetos. A continuación se presentan formalmente los conceptos de clase y objeto.

Clases y Objetos

En el modelo OO se combina la estructura y el comportamiento de los datos en una única entidad, los objetos. Los objetos son simplemente entidades que tienen sentido en el contexto de una aplicación (dominio del problema). Todos los objetos son ejemplares o instancias de alguna clase, los términos instancia y objeto son intercambiables. Los objetos de una misma clase tienen las mismas responsabilidades. Los objetos con las mismas responsabilidades pueden ser agrupados en una clase. Las clases son abstracciones que generalizan dominios de objetos. Un proceso básico que se enfrenta en la resolución de problemas es la abstracción, o sea la eliminación de los detalles irrelevantes. Centrándose únicamente en los aspectos esenciales del problema . Los objetos del mundo real son representados como objetos en el diseño y en la programación. En el modelo OO, toda entidad del dominio del problema se expresa a través del concepto de objeto y éstos se generalizan a través del concepto de clase. Se entiende por dominio del problema, al problema que se intenta resolver en términos de complejidades específicas, terminologías, retos, etc. Ejemplo: Determinar los objetos presentes en un juego de ajedrez. Comúnmente, como respuesta a este ejemplo se enuncia el peón, el caballo, la torre, etc., pero sin dudas estos son conceptos o abstracciones que agrupan a las piezas concretas que aparecen en el juego de ajedrez, es decir, peón, caballo y torre entre otras, constituyen clases, que entre sus responsabilidades tienen el color, la posición que ocupan, la forma de avanzar y comer, etc. Los objetos son entonces los 16 peones (8 negros y 8 blancos), los 4 caballos, las 4 torres, el tablero, etc. Durante una partida de ajedrez, dos peones negros que hayan sido comidos tienen exactamente las mismas características y sin embargo son objetos distintos. Precisamente, una de las características de los objetos que permite su identificación es su identidad. “Identidad significa que los datos son divididos en entidades discretas y distintas, denominadas objetos”. Además los objetos pueden ser concretos como el niño Alejandro de la sección anterior o conceptuales, como el método de Gauss para determinar raíces en sistemas de ecuaciones lineales. Todo objeto tiene su propia identidad, que le es inherente, significa que los objetos se distinguen por su propia existencia y no por las propiedades descriptivas que puedan tener. Es esto lo que lo diferencia de los otros objetos semejantes. En otras palabras, dos objetos son diferentes, incluso si todos los valores de sus características son idénticos. La forma de cada una de las piezas, el color, la manera de avanzar y comer, en conclusión, las características (forma y color) y funcionalidades (manera de avanzar y comer) de cada una de las piezas, que no son más que sus responsabilidades, facilitaron determinar los objetos en el ejemplo anterior.

PROGRAMACIÓN


9

Diseño Dirigido por Responsabilidades

El concepto de diseño dirigido por responsabilidades es importante en las etapas tempranas de la solución de problemas y cobra un alto valor notar que el comportamiento de los objetos se puede estructurar en términos de las responsabilidades de los mismos [6]. Es por ello que en la identificación de las clases y objetos presentes en la situación de análisis se ha considerado con fuerza la determinación de las mismas. Los objetos analizados en la situación de análisis de la sección 0.1 tienen un estado determinado en dependencia del valor de sus características. Por ejemplo, el niño tiene una edad determinada y al cumplir año esta aumenta en uno, de igual forma el carro del papá al pintarse puede cambiar de color. Al mismo tiempo, estos objetos tienen un comportamiento que viene dado por las acciones que pueden realizar. Por ejemplo, la mamá duerme al niño, el niño se cepilla los dientes, etc. Se puede concluir que el estado de un objeto viene dado por el valor de sus características y el comportamiento del objeto por las acciones u operaciones que realiza. Es decir las responsabilidades se pueden dividir en dos grupos, aquellas que determinan el estado (atributos) y las que determinan el comportamiento (métodos). Los atributos son valores almacenados por los objetos de una clase mientras que los métodos son secuencias de pasos para determinar un comportamiento. Los métodos pueden ser llamados (invocados) en principio, solamente desde dentro de la clase o a través de una instancia u objeto de la misma. Como se verá en secciones posteriores, es útil distinguir los métodos que tienen efectos colaterales, es decir, que pueden cambiar el estado del objeto (métodos de transformación), de los que apenas consultan el valor de algún atributo o realizan un cálculo funcional sin modificar ningún estado del objeto (método de consulta o acceso).

Relaciones entre Clases

Situación de Análisis La clase Niño tiene una responsabilidad que es “Cepillarse los dientes”, la cual es imposible realizar sin el uso de un objeto o instancia de una clase que se podría denominar Cepillo de dientes. Alejandro (instancia de la clase Niño) es hijo de Alexis (instancia de la clase Papá) y a su vez Alexis es padre de Alejandro. Aunque no se ha expresado explícitamente, las clases Niño, Mamá y Papá tienen responsabilidades comunes por lo que pueden a su vez ser agrupadas en una clase más general Persona.

Pregunta: ¿Existen las clases y los objetos de forma aislada? Claro está que no. En la situación anterior se muestra relaciones entre el niño y el cepillo de dientes, el niño y el padre, etc.

PROGRAMACIÓN


10

Es posible establecer relaciones entre dos clases por varias razones como se muestra más adelante. Una relación es una conexión entre elementos y entre las más importantes se tienen las dependencias, las asociaciones y las generalizaciones. Por otra parte, hasta el momento se han presentado algunos elementos básicos del modelo OO. Específicamente se ha hecho hincapié en los conceptos de clase, objeto y responsabilidades de éstos. Los mismos se han descrito con ejemplos y prosa. Sin embargo, esta forma no permite abordar tópicos más complejos como las relaciones entre clases. Es por ello que se precisa de un formalismo para expresar modelos de objetos que sea coherente, preciso y de fácil formulación. Las representaciones gráficas tienen gran importancia e influencia en la expresión de los conceptos. Por tanto, a partir de este momento se utilizarán los diagramas de clase, que constituyen una notación gráfica formal para la representación de las clases y sus relacionamientos. Estos a su vez son concisos, fáciles de entender y funcionan bien en la práctica. En la figura 0.1, se muestra el esquema general para la representación de una clase en la notación seleccionada. Nótese como esta notación deja clara la diferenciación entre los distintos tipos de responsabilidades dedicándole una sección a cada uno de ellos.

Diagrama de clase En la figura, se presenta una variante de representación de la clase Niño en la notación seleccionada. Note como en la representación de la clase Niño se han utilizado nombres simbólicos para denotar las responsabilidades. Por ejemplo, para la responsabilidad “Cepillarse los dientes”, el nombre simbólico (identificador) CepillarDientes. Por otra parte, los identificadores de atributos se han denotado comenzando en minúscula, mientras que los identificadores de los métodos comenzando con mayúscula. Todo esto de momento se verá como un simple convenio, sin embargo, en los siguientes capítulos resultará de gran utilidad.

Nombre de la clase

Atributos

Métodos

Responsabilidades

PROGRAMACIÓN


11

Diagrama de la clase Niño.

Relación de dependencia o uso

Situación de Análisis La clase Niño tiene una responsabilidad que se ha denotado CepillarDientes, la cual es imposible de realizar sin el uso de un objeto o instancia de una clase que podríamos denominar CepilloDientes.

Pregunta: ¿Qué tipo de relación se establece entre las clases Niño y CepilloDientes? Nótese que esta relación se establece en una sola dirección, en este caso las instancias de la clase Niño se auxilian o usan una instancia de la clase CepilloDientes para llevar a cabo (ejecutar) el método CepillarDientes. Este tipo de relación se denomina dependencia y establece una relación de uso que declara que un cambio en la especificación de un elemento (por ejemplo, la clase CepillarDientes) puede afectar a otro elemento que la utiliza (por ejemplo, la clase Niño), pero no necesariamente a la inversa. Las dependencias se usarán cuando se quiera indicar que un elemento utiliza a otro. Gráficamente, una dependencia se representa con una línea discontinua dirigida hacia el elemento del cual se depende como se muestra en la figura.

Relación de dependencia

Niño

nombre

edad

juguetes

CepillarDientes

EncenderElectrodoméstico

ApagarElectrodoméstico

Niño

….

CepilloDientes

….

PROGRAMACIÓN


12

Asociación

Situación de Análisis Alejandro (instancia de la clase Niño) es hijo de Alexis (instancia de la clase Papá) y a su vez Alexis es padre de Alejandro.

Pregunta: ¿Qué tipo de relación se establece entre las clases Niño y Papá? Nótese que entre las clases Niño y Papá existe una relación bidireccional donde todo objeto de la clase Niño es hijo de un objeto de la clase Papá y viceversa, todo Papá es padre de al menos un Niño. Este es un ejemplo de relación de asociación que se establece entre las clases Niño y Papá. Una asociación es una relación estructural que especifica que los objetos de una clase están conectados con los objetos de otra; dada una asociación entre dos clases, se puede navegar desde un objeto de una clase hasta un objeto de la otra y viceversa. Gráficamente, una asociación se representa como una línea continua que conecta a las clases involucradas como se muestra en la figura.

Relación de Asociación Las asociaciones interrelacionan clases y objetos y son intrínsecamente bidireccionales. A las asociaciones se les asigna un nombre (hijo) y este se lee en la dirección que indica el símbolo que le sucede ( ) o le precede ( ). Nótese además en el diagrama anterior la existencia de “ 1..* ” del lado de la clase Niño y de “ 1” del lado de la clase Papá. Esta es la forma de expresar que un Niño es hijo de un solo Papá (“ 1”) y todo Papá tiene uno o varios hijos (“ 1..*”). Estos cuantificadores de la relación son los que determinan la cardinalidad o multiplicidad de la misma. La cardinalidad o multiplicidad es un elemento muy importante que se debe tener en cuenta en las relaciones de asociación ya que ésta permite determinar cuántas instancias de un lado pueden estar presentes en una instancia del otro y viceversa.

Generalización

Situación de Análisis Aunque no se ha expresado explícitamente, las clases Niño, Mamá y Papá tienen responsabilidades comunes por lo que pueden a su vez ser agrupadas en una clase más general Persona.

Pregunta: ¿Qué tipo de relación se establece entre las clases Niño, Mamá, Papá y Persona?

1..* hijo

1 Niño

….

Papá

….

PROGRAMACIÓN


13

Como en la clase Persona se agrupan un conjunto de responsabilidades comunes a Niño, Mamá y Papá es posible decir que entre estas tres clases y Persona se puede establecer una relación “es un”. Por ejemplo, Niño “es una” Persona. Este tipo de relación se define como generalización. Esta nueva relación (“es un”) determina la existencia de superclases (Persona) que a su vez permiten establecer generalizaciones y de subclases (Niño, Mamá y Papá) que a la vez son nuevas clasificaciones (subdominios) dentro del dominio más general. Gráficamente, esta nueva relación se representa como una línea continua dirigida, con una punta de flecha vacía, apuntando a la superclase, como se ve en la figura.

Relación de Generalización

Clasificación de los atributos

Desde que fueron determinados los primeros objetos en la situación de análisis de la sección 0.1 se hizo énfasis en clasificarlos (Por ejemplo, Niño Alejandro). Pregunta: ¿Es posible clasificar los atributos de forma general? Claro que sí, de la misma forma que se han clasificado los objetos analizados anteriormente, se puede clasificar cualquier atributo de acuerdo a los valores que pueda almacenar y a las operaciones que se puedan realizar con estos valores, definiéndose de esta forma el concepto de tipo de dato. En la figura 0.6 se muestra una variante de la clase Niño donde se incluyen nuevos atributos que pudiera tener y posteriormente se determinará el tipo de dato de cada uno de ellos. Para clasificar los atributos de Niño se presenta la siguiente tabla donde se relacionan posibles valores a almacenar por cada uno.

Persona

….

Mamá

….

Niño

….

Papá

….

PROGRAMACIÓN


14

Atributos Valores

Nombre Alejandro ó Luis ó Ana ó … Edad 1 ó 2ó 3 ó 4 ó … Peso 16.5 ó 28 ó 35.5 ó … tieneSueño Si ó no juguetes Camión, soldadito, pelota, …

Variación de la clase Niño Como puede verse el atributo nombre toma como valores secuencias o combinaciones de letras (cadenas de caracteres), por el momento este tipo de valores se clasificará como tipo de dato cadena. Los atributos edad y peso toman valores numéricos, diferenciándose en que la edad toma valores del dominio de los números enteros (tipo de dato entero) y el peso toma valores reales (tipo de dato real). El atributo tieneSueño toma dos posibles valores (si ó no) que se pueden hacer corresponder con dos posibles estados (verdadero o falso) definiendo el tipo de dato lógico. Note que hasta el momento los atributos analizados pueden almacenar un único valor (a la vez) de su correspondiente tipo de dato. Sin embargo, el atributo juguetes puede almacenar varias instancias de la clase Juguete, todas bajo un mismo nombre (juguetes). Es decir, el tipo de dato del atributo juguetes es un conjunto de instancias de la clase Juguete que se denotará por Juguete[] (en general <TipoDeDato>[]). En la figura se refina la clase Niño, añadiéndose el tipo de dato de cada uno de sus atributos (declaración de los atributos). Pregunta: ¿Por qué unos tipos de dato se encuentran resaltados en negrita (cadena, entero, real y lógico) y otros no (Juguete)?

Niño

nombre

edad

peso

tienesueño

juguetes

…

PROGRAMACIÓN


15

Esto se debe a que existe a su vez una clasificación entre los tipos de dato en: simples (básicos, primarios o primitivos) (cadena, entero, real y lógico) y clases (Juguete). Por el momento estos tipos de dato serán utilizados en los ejemplos de las próximas secciones.

Tipos de datos en la clase Niño

Acceso a las responsabilidades de los objetos. Parametrización de los métodos

Hasta el momento se han identificado clases, objetos y relaciones entre las clases y los objetos, pero aún no se ha concretado nada sobre cómo los objetos acceden a sus responsabilidades. Para ello se utilizará la notación:

<objeto>.<responsabilidad> Utilizando dicha notación Alejandro puede acceder a su atributo nombre de la siguiente forma:

Alejandro.nombre y al método CepillarDientes de la forma:

Alejandro.CepillarDientes Nótese que tanto al atributo nombre como al método CepillarDientes se accede de forma semejante. Pregunta: ¿Qué sucedería si se tuviera un atributo y un método con el mismo identificador? Evidentemente no podría diferenciarse a cual de los dos se quiere acceder. Una variante de solución a este problema es colocar un par de paréntesis (“()”) al final de los métodos. En la figura 0.8 se muestra un refinamiento de la clase Niño incluyendo el nuevo convenio.

Situación de Análisis

Niño

cadena nombre

entero edad

real peso

lógico tienesueño

Juguete[] juguetes

…

PROGRAMACIÓN


16

Suponga que Alejandro tiene un hermano (Carlos) de apenas un año.

Pregunta: ¿Cómo Gloria (madre de ambos niños) podría dormir a Alejandro y a Carlos utilizando el método DormirNiño()? El método DormirNiño()debe ser capaz de dormir a cualquiera de los niños y por lo tanto debe tener la información de cual niño es al que se va dormir en un instante dado. El objeto Gloria tendría que invocar al método DormirNiño() informándole cual de los niños es el que se va a dormir. Por ejemplo, si desea dormir a Carlos:

Gloria.DormirNiño(Carlos). Note que en la definición de la clase Mamá no queda explícito que el método DormirNiño() necesite alguna información.

Refinamiento de la clase Niño en los métodos Pregunta: ¿Cómo definir en la clase Mamá la información que el método DormirNiño() necesita? De forma general esta información se coloca dentro de los paréntesis utilizando un identificador precedido de un tipo de dato como se muestra a continuación:

<identificador de método> ( <tipo de dato> <identificador> ) Por ejemplo, para el caso del método DormirNiño():

DormirNiño(Niño unNiño)

Niño

cadena nombre

entero edad

real peso

lógico tienesueño

Juguete[] juguetes

CepillarDientes()

EncenderElectrodoméstico()

ApagarElectrodoméstico()

PROGRAMACIÓN


17

La información que se le pasa a un método se denomina parámetro y en caso de ser más de uno, se separan por comas antecedidos de sus respectivos tipos de dato. No obstante, existen métodos que no necesitan parámetros y en su declaración mantienen los paréntesis vacíos (“()”). En la figura se refina la clase Niño, añadiendo los parámetros a los métodos (declaración de métodos).

Refinamiento de la clase Niño con parámetros en los métodos

Encapsulamiento

El acceso a las responsabilidades de los objetos tiene múltiples aristas. Por una parte el acceso a los métodos en principio siempre es de la misma forma:

<objeto>.<método>([<valores de los parámetros>])

Situación de Análisis Suponga la existencia de una clase Consola con un método Imprimir que permite mostrar por pantalla una cadena de caracteres como se muestra a continuación:

Consola

…

Imprimir(cadena mensaje) …

y se dispone de una instancia de la misma (consola).

Pregunta: ¿Cómo imprimir el nombre de Alejandro?

Niño

cadena nombre

entero edad

real peso

lógico tienesueño

Juguete[] juguetes

CepillarDientes(CepilloDientes c)

EncenderElectrodoméstico(Electrodoméstico e)

ApagarElectrodoméstico(Electrodoméstico e)

PROGRAMACIÓN


18

Consola.Imprimir(Alejandro.nombre) Otro es el caso cuando se habla de acceso a los atributos, pues se pueden usar sus valores como se mostró con anterioridad cuando se invocó un método del objeto consola para mostrar por pantalla el nombre de Alejandro; o se puede modificar como se muestra a continuación:

Alejandro.nombre = “Jorge” En este último caso se puede fácilmente perder la integridad del objeto propiamente dicho pues ahora a Alejandro se le ha cambiado su nombre. De forma análoga podría modificarse la edad de Alejandro de la siguiente forma:

Alejandro.edad = -5 este valor es entero (-5) pero que no pertenece al dominio de valores del atributo edad. A partir de las reflexiones anteriores es posible llegar a la conclusión de que es preciso disponer de mecanismos que permitan restringir el acceso a las componentes de los objetos para garantizar la integridad de los mismos, cobrando especial interés el concepto de encapsulamiento o encapsulación. A este mecanismo también se le denomina ocultación de la información y es la capacidad de ocultar los componentes internos de un objeto a sus usuarios y proporcionar una interfaz solamente para los componentes que se desee que el cliente tenga la posibilidad de manipular directamente. El mecanismo de encapsulamiento permite además, separar el qué del cómo, es decir, los objetos ofrecen a sus clientes una interfaz de qué es a lo que se puede acceder pero el cómo respecto a su funcionalidad interna queda oculto. Los procedimientos internos sobre cómo lleva a cabo un objeto un trabajo no son importantes mientras que ese objeto pueda desempeñar su trabajo. Características de la Programación Orientada a Objetos

Las características más importantes de la Programación Orientada a Objetos son la abstracción, el encapsulamiento y la herencia. Abstracción

La abstracción es una de las vías fundamentales por la que los humanos combatimos la complejidad.

Una abstracción denota las características esenciales de un objeto que lo distingue de todos los demás tipos de objeto y proporciona así fronteras conceptuales nítidamente definidas respecto a la perspectiva del observador.

Cuando vamos a aplicar la POO, lo primero que debemos hacer es cumplir con una vieja máxima de guerra: Divide y Vencerás. Es decir, lo que hacemos es seccionar nuestro código en grupos de código más pequeño que, al unirlos, hacen el trabajo. Un buen ejemplo de abstracción es el cuerpo humano, aunque el cuerpo es una unidad, está dividido en lo que conocemos por sistemas (el sistema respiratorio, el sistema linfático, cardiovascular, etcétera). Estos sistemas, a su vez están compuestos por otros más

PROGRAMACIÓN


19

pequeños: los órganos, y así sucesivamente. La abstracción nos permite dividir nuestro programa en distintos objetos que se agrupan para formar cosas más complejas.

Básicamente la abstracción es la capacidad de separar los elementos (al menos mentalmente) para poder verlos de forma singular. Como cuando describimos el cuerpo humano y decimos cabeza, brazo(s), pierna(s), etcétera.

Encapsulamiento Encapsulado u ocultamiento de información. Los objetos ocultan sus datos de los demás objetos

y permiten el acceso a dichos datos mediante sus propios métodos. El encapsulamiento es el proceso de almacenar en un mismo compartimento los elementos de

una abstracción que constituyen su estructura y su comportamiento. El ocultamiento de información es importante porque:

a) Separa el comportamiento del objeto de su implementación. b) Establece y refuerza las restricciones de acceso al objeto, al ocultar los detalles de su

implementación interna a los usuarios del mismo.

c) El usuario conoce las operaciones del objeto que puede solicitar, pero desconoce los detalles de cómo se llevan a cabo dichas operaciones. Todos los detalles específicos acerca de los datos del objeto y la codificación de sus operaciones están fuera del alcance del usuario.

d) Evita la corrupción de los datos de un objeto promoviendo la integridad del mismo. Si todos

los programas pudieran tener acceso a los datos en cualquier forma que quisieran los usuarios, los datos se podrían corromper y entonces ser utilizados de mala manera. El ocultamiento de información protege los datos del uso arbitrario de los usuarios y de posibles errores accidentales por parte del programador.

e) Es más fácil realizar cambios durante la implementación, la prueba y el mantenimiento del

software orientado a objetos, porque al modificar un objeto se cambia, al mismo tiempo, un tipo de objeto, afectando únicamente los métodos y las estructuras de datos asociados con dicho tipo de objeto, es decir, la modificación y la prueba de un tipo de objeto se puede efectuar de manera independiente.

En otras palabras, la encapsulación se encarga de mantener ocultos los procesos internos que necesita para hacer lo que sea que haga, dándole al programador acceso sólo a lo que necesita. Esto da dos ventajas iniciales: Lo que hace el usuario puede ser controlado internamente (incluso sus errores), evitando que todo colapse por una intervención indeseada. La segunda ventaja es que, al hacer que la mayor parte del código esté oculto, es posible hacer cambios y/o mejoras sin que eso afecte la manera en la que los usuarios van a utilizar el código. Sólo se tiene que mantener igual la forma de acceder a él.

PROGRAMACIÓN


20

Herencia La herencia es una relación entre clases en la que una clase comparte la estructura y/o el

comportamiento definidos en una (herencia simple) o más clases (herencia múltiple). La clase de la que otras heredan se denomina superclase. Análogamente, la clase que hereda de otra o más clases se denomina subclase.

La herencia define, por tanto, una jerarquía “de tipos” entre clases, en la que una subclase hereda de una o más superclases.

La herencia en una forma de reutilización del software en la que se crean clases nuevas a partir de clases ya existentes por medio de la absorción se sus atributos y comportamientos, sobreponiéndolos o mejorándolos con capacidades que las clases nuevas requieran.

Mediante la herencia se logra compartir el comportamiento y los atributos de las clases de objetos definidas previamente con extensiones de clases de objetos que reciben el nombre de subclases. Se dice que las subclases heredan las estructuras de datos y las operaciones de la clase de objetos a partir de la cual se derivan.

El hecho de que un tipo de objeto de alto nivel pueda especializarse en tipos de objeto de bajo nivel, permite la creación de una jerarquía de clases, subclases, sub-subclases, etc. Una clase permite la implementación de un tipo de objeto. Una subclase hereda propiedades de su clase padre, una sub-subclase hereda propiedades de las subclases, etc. Una subclase puede heredar las estructuras de datos y los métodos de su superclase; también puede tener sus propios métodos e incluso tipos de datos propios.

De manera más específica se tienen las siguientes definiciones. Una subclase es una clase que hereda las propiedades y los métodos de una clase existente. Una superclase es una clase de la cual otra clase hereda propiedades y métodos. Herencia simple es cuando una clase se deriva de una superclase. Herencia múltiple es cuando una clase se deriva de más de una superclase.

Ventajas del Paradigma Orientado a Objetos

Reutilización. Permite la reusabilidad de código y la herencia ahorrando dinero y empleando menos tiempo de desarrollo.

El principio de la reutilización plantea la necesidad de creación de bibliotecas de clases de propósito general que puedan ser utilizadas por los usuarios sin tener que volver a implementarlas, debido a que la creación de código que ya existe repercute en un costo innecesario. Lo que se pretende es minimizar tanto la repetición de código como la documentación relacionada con el desarrollo de estas bibliotecas.

El análisis y diseño orientado a objetos buscan lograr la reutilización masiva de las clases de

objetos. Una biblioteca de clases contiene la implementación reutilizable de tipos de objetos, su intención es logar el máximo grado de reutilización en el desarrollo de software. El software para las bibliotecas de clases debe ayudar a los diseñadores a encontrar, adaptar y utilizar las clases que necesiten.

PROGRAMACIÓN


21

Por estas razones, un objetivo fundamental de la Orientación a Objetos al construir software, es la reutilización masiva de bibliotecas de clases. Las clases son diseñadas y construidas de modo que se puedan adaptar y reutilizar en muchos sistemas. Estabilidad. Las clases diseñadas para la reutilización y empleadas en repetidos casos, se vuelven estables y por consiguiente es más fácil la creación de sistemas orientados a objetos, que usen o estén basados en dichas clases, siendo más probable su correcto funcionamiento. La forma de pensar en objetos es más natural. El diseñador piensa en términos de objetos y no en detalles de bajo nivel. Dado que el encapsulado separa el comportamiento del objeto de su implementación y hace que las clases complejas sean más fáciles de utilizar, el usuario de dichas clases sólo necesita conocer los tipos de objetos que puede emplear (ya sea para crear instancias directamente o para derivar clases nuevas), su comportamiento representado por los métodos públicos y los mecanismos de comunicación entre los objetos. Al usuario de una clase no se le permite el acceso al “interior” de los objetos. Si una clase fue diseñada de tal manera que no cumple con las expectativas del usuario, éste debe derivar una clase nueva de alguna existente o crearla desde sus inicios. Nuevos mercados para el software. Las compañías de software deben proporcionar bibliotecas de software para áreas específicas, que se adapten con facilidad a las necesidades de la organización que las utiliza. El software actual incorpora clases y paquetes encapsulados de muchos y distintos proveedores. Programación más sencilla. Los programas se crean a partir de piezas pequeñas. El software se construye a partir de objetos de comportamiento específico. Los propios objetos de pueden construir a partir de otros, que a su vez pueden estar formados por otros objetos. Los objetos pueden ser complejos desde el punto de vista interno, pero los analistas del software no tienen que comprender toda esa complejidad (a menos que los diseñen). Les basta conocer el comportamiento de los objetos y su forma de uso.

Herencia y Polimorfismo A continuación se menciona como se podrían utilizar la herencia y el polimorfismo para crear una

clase base abstracta llamada Paralelogramo y derivar a partir de ésta las subclases Rectángulo y Cuadrado (ver figura 1.7).

Un Rectángulo es un Paralelogramo porque sus lados opuestos son paralelos dos a dos; es decir,

el concepto de paralelogramo se aplica al objeto rectángulo y por lo tanto éste se clasifica como miembro o instancia de la clase Paralelogramo. Los cuadrados, romboides y rombos también son clasificados como paralelogramos.

Todos, Rectángulos, Cuadrados, Romboides y Rombos, son instancias de la clase Paralelogramo porque tienen la propiedad de que sus lados opuestos son paralelos dos a dos. Sin embargo, debe observarse que los rectángulos, cuadrados, romboides y rombos tienen, a su vez, atributos y comportamientos propios (los rectángulos tienen los cuatro ángulos iguales y los lados contiguos desiguales, los cuadrados tienen los cuatro ángulos iguales y los cuatro lados iguales, los romboides tienen los lados y los ángulos contiguos desiguales, y los rombos tienen los cuatro lados iguales y los ángulos contiguos desiguales), por lo que éstos pueden ser definidos como subclases de la clase

PROGRAMACIÓN


22

paralelogramo. Cada una de estas subclases tendrá sus estructuras de datos y métodos propios, además de los que herede de su clase padre.

La herencia en una forma de reutilización del software en la que se crean clases nuevas a partir de clases ya existentes por medio de la absorción se sus atributos y comportamientos, sobreponiéndolos o mejorándolos con capacidades que las clases nuevas requieran.

Mediante la herencia se logra compartir el comportamiento y los atributos de las clases de objetos definidas previamente con extensiones de clases de objetos que reciben el nombre de subclases. Se dice que las subclases heredan las estructuras de datos y las operaciones de la clase de objetos a partir de la cual se derivan.

El hecho de que un tipo de objeto de alto nivel pueda especializarse en tipos de objeto de bajo nivel, permite la creación de una jerarquía de clases, subclases, sub-subclases, etc. Una clase permite la implementación de un tipo de objeto. Una subclase hereda propiedades de su clase padre, una sub-subclase hereda propiedades de las subclases, etc. Una subclase puede heredar las estructuras de datos y los métodos de su superclase; también puede tener sus propios métodos e incluso tipos de datos propios.

De manera más específica se tienen las siguientes definiciones. Una subclase es una clase que hereda las propiedades y los métodos de una clase existente. Una superclase es una clase de la cual otra clase hereda propiedades y métodos. Herencia simple es cuando una clase se deriva de una superclase. Herencia múltiple es cuando una clase se deriva de más de una superclase.

El polimorfismo se define como la habilidad de los objetos de diferentes clases, que están relacionados mediante la herencia, para responder en forma diferente al mismo mensaje; es decir, al llamado o solicitud de una operación implementada por un método de manera diferente para cada tipo de objeto. Aún así, aunque los métodos sean distintos, llevan a cabo el mismo propósito operativo. La palabra polimorfismo se aplica a una operación que adopta varias formas de implementación.

La herencia y el polimorfismo, dan la posibilidad de que un Tipo de Dato Abstracto (TDA) pase por alto el comportamiento heredado de un tipo a un subtipo, al permitir la redefinición del método de una operación heredada en el subtipo. Por ejemplo, si las clases Rectángulo, Cuadrado, Romboide y Rombo se derivan de la clase base Paralelogramo (cuadrilátero o polígono de cuatro lados con los lados opuestos paralelos dos a dos), entonces cada instancia de las clases derivadas también son instancias de la clase base y por lo tanto no tendrían que repetir el comportamiento heredado de Paralelogramo. Si dentro de las estructuras de datos de la clase Paralelogramo se define un arreglo de cuatro puntos para almacenar las coordenadas de los vértices del paralelogramo y la operación exhibir se implementa mediante un método que conecte los cuatro vértices del paralelogramo y lo muestre en pantalla, entonces dicha operación también se aplicaría a los rectángulos, cuadrados, romboides y rombos; es decir, las clases Rectángulo, Cuadrado, Romboide y Rombo heredan la operación exhibir de la clase Paralelogramo y no tienen que repetirla o redefinirla. Sin embargo, aunque todas las operaciones de Paralelogramo se aplican a sus subclases, el método operativo puede ser diferente; por ejemplo, el método para calcular el perímetro de un paralelogramo, un romboide o un rectángulo podría definirse como dos veces la suma de la longitud de sus lados adyacentes, pero el método para calcular el perímetro de un cuadrado o un rombo podría definirse como cuatro veces la longitud de cualquiera de sus lados. En este caso es necesario redefinir la operación que calcula el perímetro en las subclases Cuadrado y Rombo.

Para ilustrar los conceptos de herencia y polimorfismo tomemos como ejemplo algunas de las clases descritas en el párrafo anterior: Paralelogramo, Rectángulo y Cuadrado. En UML la herencia se modela

PROGRAMACIÓN


23

con diagramas de clases en los que se colocan relaciones de generalización para indicar que una clase se deriva de otra. Por ejemplo, la figura 1.7 indica que las clases Rectángulo y Cuadrado se derivan de la clase abstracta Paralelogramo y por tanto que éstas pueden heredar datos y comportamiento de la clase Paralelogramo.

Prácticas

NOMBRE DE LA PRÁCTICA: Requerimientos de Información

UNIDAD TEMÁTICA: I. Fundamentos de Programación orientada a objetos.

TEMA: Fundamentos de la POO.

OBJETIVO DE LA PRÁCTICA: Diseñar el diagrama de clase de los ejercicios planteados

TIEMPO DE LA PRÁCTICA: 2 Hrs FECHA:

DESCRIPCIÓN:

El alumno analizará y diseñará el diagrama de clase de los ejercicios propuestos, identificar claramente atributos y métodos, escribiéndolos correctamente en el diagrama. Problemas sugeridos:

1. Calcular el sueldo de los empleados de una empresa, por cada empleado se tienen los datos: nombre, número de horas trabajadas, cuota que se le paga por hora. Cada quincena se requiere emitir un cheque con el nombre del empleado y sueldo que se debe pagar.

2. Calcular el área y perímetro de un círculo.

3. Calcular las raíces de una ecuación cuadrática usando la formula general.

Las prácticas se van revisando en clase, pero deberán guardarlas también para ir integrando su portafolio de evidencias

MATERIALES Y EQUIPOS:

Computadora

PROCEDIMIENTO:

1. Las prácticas se realizan de manera individual

2. Si da tiempo se revisa la práctica en salón, si no, se entregará para la siguiente sesión

como tarea.

CUESTIONARIO

REFERENCIAS

PROGRAMACIÓN


24

II. Unidad Temática II Ambiente de desarrollo de la POO.

Objetivo: El alumno operará las funciones principales de un entorno de desarrollo previamente seleccionado, para ejecutar una aplicación.


Generalidades de la herramienta de desarrollo.

Identificar los diferentes tipos de entornos de desarrollo para los lenguajes de programación existentes.

Seleccionar el entorno de desarrollo acorde al lenguaje de programación.

Analítico. Ordenado. Sistemático. Proactivo

Características de la interfaz de desarrollo.

Identificar las funciones principales (crear, abrir, guardar, compilar, ejecutar, depurar) de operación en los entornos de desarrollo de programación.

Operar las funciones principales del entorno de desarrollo de programación.

Analítico. Ordenado. Sistemático. Proactivo

Resultado de aprendizaje: Generará un proyecto, a partir de un código dado, y demostrará el manejo de las funciones principales del entorno de desarrollo: crear, abrir, guardar, compilar, ejecutar, depurar.

PROGRAMACIÓN


25

II. Unidad Temática II Ambiente de desarrollo de la POO

Plataforma de desarrollo Visual Studio .NET

Una aplicación en .Net esta compuesta por toda una estructura de archivos necesarios para su ejecución, por lo que es importante conocer la ubicación de dichos archivos.

PROGRAMACIÓN


26

Esta estructura la puedes observar en la sección Explorador de Soluciones Ventana superior derecha dentro de la aplicación.

Formas de iniciar una nueva aplicación

Menu File New Project Icono en la Barra de Herramientas Hot Keys Control+Shift+ N

PROGRAMACIÓN


27

Proyecto nuevo, antes de continuar ….

Seleccionar Lenguaje C# y Aplicación de Windows, la ubicación es muy importante ya que es la que determina en donde se almacenará tu proyecto. Ambiente de trabajo

Ubicación del proyecto

PROGRAMACIÓN


28

Dinámica de trabajo

Al abrir un proyecto se debe considerar: El diseño del formulario (la vista o interfaz que recibirá el usuario) El código (la programación de la interfaz)

Lenguajes

Botón de ejecutar

Tipos de Aplicaci

Properties, ventana

de propiedades,

PROGRAMACIÓN


29

Controles visuales

Propiedades (Características) – Color – Tamaño – Altura – Fondo

Eventos (Reacción acciones) – Poner rojo – Cerrar – Agrandar

Control: Label

Sirve para mostrar un mensaje en pantalla (en el formulario), es un control de Salida. Propiedades Básicas

– Name – Text – Visible – TextAlign – Font – Size – Location – Image – Cursor – BackColor

PROGRAMACIÓN


30

Control: TextBox Sirve para leer / mostrar un mensaje en pantalla (en el formulario), es un control de Entrada / Salida. Propiedades Básicas

– Name – Text – Visible – TextAlign – Font – Size – Location – Image – Cursor – BackColor

Control: Button Le muestra un botón al usuario para que este haga clic y realice alguna acción. Puede contener solo texto o, también, una pequeña imagen. Propiedades básicas

– Name – Text – Visible – TextAlign – Font – Size – Location – BackgroundImage – Cursor – Dock – BackColor

PROGRAMACIÓN


31

III. Unidad Temática III Programación orientada a objetos.

Objetivo: El alumno codificará clases empleando el paradigma de la programación orientada a objetos para el desarrollo de aplicaciones.


Estructura básica de una clase.

Identificar la estructura básica de una clase, las instrucciones y su sintaxis para la salida de datos, buenas prácticas de programación y errores de compilación. Identificar el punto de inicio de una clase (método main).

Codificar programas básicos con salida de datos, utilizando buenas prácticas de programación y corrigiendo errores de compilación.

Analítico. Ordenado. Sistemático. Coherente. Proactivo. Asertivo

Aspectos léxicos. Identificar los tipos de datos y palabras reservadas. Identificar la sintaxis de la declaración de atributos (variables y constantes), operadores, comentarios, literales, expresiones.

Establecer atributos (variables y constantes) usando diversos tipos de datos, expresiones y operaciones y palabras reservadas.


Clases y Objetos. Identificar la sintaxis de la creación de clases y métodos (constructor, estáticos y no estáticos). Identificar la sintaxis de la declaración de objetos y la comunicación entre objetos y relación con modos de acceso.

Codificar clases que implementen métodos y la comunicación entre objetos.


Estructuras de control. Identificar la sintaxis y el funcionamiento de las diferentes estructuras de control.

Codificar métodos empleando las estructuras de control.


PROGRAMACIÓN


32


Encapsulamiento. Explicar el encapsulamiento a través del funcionamiento y sintaxis de los modificadores de acceso (private, protected, public) y los métodos mutator y acceso.

Codificar clases empleando propiedades de los diferentes modificadores de acceso y métodos de acceso.


Herencia. Identificar la sintaxis de la herencia, método virtual, método sobrescrito, clases abstractas, interfaces, clases terminales (finales/selladas).

Codificar clases que implementen la herencia.


Polimorfismo. Identificar el funcionamiento del polimorfismo de componentes (sobrecarga y sobre escritura) y de referencias (casting).

Codificar clases que implementen el polimorfismo.


Resultado de aprendizaje: Codificará una aplicación que incluya: clases ( atributos y métodos), empleando estructuras de control, encapsulamiento, herencia y polimorfismo.

PROGRAMACIÓN


33

Unidad Temática III Programación Orientada a Objetos Definición de una clase y sus miembros La sintaxis básica para definir una clase es: Donde: <modificadoralcance> La explicación de los modificadores de alcance se revisara en el apartado 1.1.2.. <nombreClase> Es el identificador de la plantilla o clase. Y los miembros de una clase son: <Atributos> Son las variables o campos definidos que actúan como características de la clase.

Estas variables solo son conocidas en todo el código interno de dicha clase. <Propiedades> Es un canal de acceso (para leer o escribir) a un atributo de la clase con el código

exterior. Su función es enlazar valores a un atributo por medio de los bloques: set (colocar ó asignar) y get (obtener).

Se construye una propiedad por cada Atributo que se desee comunicar. <Métodos> Es un conjunto de instrucciones a las que se les asocia un nombre de modo que si

se desea ejecutarlas basta hacer referencia dicho nombre en vez de tener que escribirlas

La definición de los miembros que componen una clase es opcional. Ejemplo 1:

class A { } Definición de una clase vacía, de nombre “A”

Sintaxis para crear Atributos

<modificadoralcance> class <nombreClase> {

<Atributos> <Propiedades> <Métodos>

}

PROGRAMACIÓN


34

Ejemplo: class articulo { string nombre; // Campo para almacenar el nombre del articulo int cantidad; // Campo para almacenar la cantidad de artículos double precio; // Campo para almacenar el precio de un articulo } Definición de la clase articulo en la cual se definen 3 atributos (campos) Sintaxis para crear Propiedades

Los atributos definidos en una clase no tienen comunicación con el código externo. Si se desea tener comunicación a un atributo, se crea una propiedad. Cada propiedad esta vinculada con un atributo, por lo que el <tipodato> de la propiedad es el mismo que el del atributo a vincular. No es valido que <nombrepropiedad> sea el mismo nombre del atributo. Ejemplo: class articulo { string nombre; // Atributo int cantidad; // Atributo double precio; // Atributo

} // fin de la clase articulo

PROGRAMACIÓN


35

El ejemplo muestra la clase articulo con 3 atributos y 2 propiedades: prop_nombre que vincula al atributo nombre prop_precio que vincula al atributo peso Ahora es posible dar valores a estos atributos desde un lugar externo (a la clase) por medio de las propiedades correspondientes. Observe que faltaría definir una propiedad para el atributo cantidad (que es posible definirla), pero la intención es mostrar que pueden existir atributos que no necesariamente tienen una propiedad, ya que el uso de estas variables seria para el control interno de la clase. Al definir las propiedades, es posible omitir alguno de los 2 descriptores de acceso (get o set).

public string prop_nombre // propiedad vinculada al atributo nombre {

get { return nombre; // regresa el valor del atributo nombre

} // cuando la propiedad es consultada set {

nombre = value; // asigna el valor al atributo nombre } // cuando la propiedad es asignada

} // fin de la declaración de la propiedad prop_nombre

public double prop_precio // propiedad vinculada al atributo peso {

get { return precio; // regresa el valor del atributo peso

} //cuando la propiedad es consultada set {

precio = value; // asigna el valor al atributo peso } // cuando la propiedad es asignada

} // fin de la declaración de la propiedad prop_precio

PROGRAMACIÓN


36

Ejemplo: public string prop_nombre // propiedad vinculada al atributo nombre

{ get {

return nombre; // regresa el valor del atributo nombre } // cuando la propiedad es consultada

} // fin de la declaración de la propiedad prop_nombre La propiedad solo puede ocuparse para consulta del atributo, no tiene descripción alguna para la asignación. Ejemplo: public double prop_precio // propiedad vinculada al atributo peso

{ set {

precio = value; // asigna el valor al atributo peso } // cuando la propiedad es asignada

} // fin de la declaración de la propiedad prop_precio La propiedad solo puede ser utilizada para asignar valores, no para consultarlos.

Sintaxis para crear Métodos

<modificadoralcance> La explicación de los modificadores de alcance se revisara después. <tipodevuelto> Es el tipo de dato que el método regresara al finalizar su ejecución.

En caso de no regresar nada se indica como tipo void. Solo en caso de devolver un valor, dentro de las instrucciones es necesario incluir la instrucción: return <valor> ; donde el <valor> es el dato o la variable que el método devuelve como respuesta.

PROGRAMACIÓN


37

<parametros> Es la información necesaria que se necesita para realizar las instrucciones del método.

Si el método no requiere información para ejecutar las instrucciones, solo se dejan los paréntesis vacíos.

En caso de necesitar información, se define cada dato requerido como una variable y se declara en ese momento.

- Ejemplo: double porcentaje( double total, double pctg ) { double resultado;

resultado = total * (pctg / 100.0 ) ; return resultado; // resultado es el valor a ser regresado

} Método porcentaje, necesita dos datos para procesar las instrucciones, regresa un valor de tipo double. - Ejemplo: void area( double base, double altura ) { res = ( base * altura ) / 2.0 ; } Método area, realiza un calculo, pero no devuelve ningún valor. Necesita 2 datos para procesar sus instrucciones. La variable res previamente tuvo que haber sido declarada. - Ejemplo: void incrementa() { cont ++; } Método incrementa, aumenta un valor de la variable cont. No necesita información extra ni regresa ningún resultado. La variable cont se declaro previamente.

Creación de objetos Una vez terminada la clase, es posible crear objetos a partir de ella.

PROGRAMACIÓN


38

Sintaxis para crear un objeto

<nombreTipo> Es el nombre de la clase, de la cual se quiere generar un objeto <nombreobjeto> Es el nombre del objeto, el cual cuenta con todas las características definidas en

la clase de la cual es generado. Ejemplo: articulo OB1 = new articulo(); Objeto de nombre OB1, que proviene de la clase articulo. Una vez generado el objeto, se puede tener acceso a los miembros de la clase por medio del operador “.” Ejemplo: OB1.prop_nombre = “Libreta” ; // Asignación del valor “Libreta” al atributo nombre

// (de la clase articulo), a través de la propiedad // prop_nombre

MessageBox.Show(OB1.prop_nombre); // Consulta de la propiedad prop_nombre OB1. calculla_total(); // Se invoca al método calcula_total de la clase articulo

Ámbito o alcance de los miembros. Los miembros de una la clase pueden ser campos, propiedades y métodos, cada miembro tiene una accesibilidad asociada, que controla a qué código se le permite el acceso a los miembros de nuestra clase. Hay cinco posibles formas de las cuales retomaremos solo algunas para efectos de este curso:

Modificador Descripción

public Acceso no limitado. Cualquier código puede acceder a un elemento public.

protected Acceso limitado desde la propia clase o desde tipos derivados de la propia clase.

internal Acceso limitado al propio programa

protectedinternal Acceso limitado al propio programa o a tipos derivados de la propia clase

private Acceso limitado a la propia clase

PROGRAMACIÓN


39

Puesto que uno de los pilares principales de la programación orientada a objetos es la ocultación de datos, y para mantener una API (Application Programming Interface - Interfaz de Programación de Aplicaciones) lo más simple posible, se recomienda siempre el uso de private salvo cuando esté justificado el uso de un modificador distinto. Reglas:

Los espacios de nombre siempre son públicos (implícitamente).

Las clases siempre son públicas (implícitamente).

Los miembros de clase son privadas por predeterminación.

Los modificadores se anteponen a la definición de espacios de nombres, clases o miembros de clase. Ejemplo: public class alumno // define una clase con alcance publico { public string nombre; // Define el campo nombre de tipo publico private double calif1, calif2; // Define 2 atributos privados private double promedio; // Define un campo de forma privada public double calificacion1 // Define la propiedad calificacion1 de tipo public

{ set { calif1 = value; }

}

public double calificacion2 // Define la propiedad calificacion2 de tipo public {

set { calif2 = value; }

} public void promediar() // define método promediar de tipo public

{ promedio = (calif1 + calif2 ) / 2.0; } private string muestrapromedio() // define el método muestra de tipo privado { return (“ Promedio “ + Convert.To String( promedio )); }

PROGRAMACIÓN


40

}// fin de clase alumno Realizando una recopilación del ejemplo anterior, se ha definido:

Las flechas de la izquierda indican que la propiedad calificacion1 vincula valores al atributo calf1, así como calificacion2 vincula a calif2. Las flechas de la derecha indican que:

nombre, por haber sido declarado atributo publico es alcanzable desde afuera de la clase, por lo tanto es operable desde afuera en los dos sentidos (asignación y consulta).

calificacion1 y calificacion2, son propiedades publicas (alcanzable desde afuera), pero solo tienen habilitado su modulo de asignación, por lo tanto una vez asignado sus valore, estos no pueden ser consultados.

promediar, es un método alcanzable desde afuera (public).

Note que los demás miembros que no tienen flecha son porque quedaron declarados de tipo privado, por lo que no tienen comunicación alguna con el exterior (de forma directa). En este caso, los miembros de la clase declarados de tipo private son desconocidos e inoperables en el exterior. Un ejemplo de crear un objeto a partir de esta clase es:

alumno estudiante = new alumno(); estudiante ya es un objeto que cumple con todas las especificaciones de la clase alumno. El objeto estudiante puede:

estudiante.nombre = “Crispin”; // modificar su nombre

PROGRAMACIÓN


41

MessageBox.Show( estudiante.nombre ); // Consultar y mostrar el nombre

Los miembros que fueron declarados de tipo private no pueden ser invocados en este momento, pues quedaron aislados internamente en la clase y fuera de ella no son conocidos. Observe que el atributo calif1 no es alcanzado desde este punto de forma directa. Sin embargo es posible tener alcance a el por medio del descriptor de acceso (propiedad) calificacion1, ya que la propiedad si se especifico de tipo public. Sucede lo mismo con calificacion2 y calif2. estudiante.calificacion1 = 9.8; // asigna un valor al atributo calif1 estudiante.calificacion2 = 8.3; // asigna un valor al atributo calif2 Una vez que los atributos calif1 y calif2 tienen valores, se puede invocar la instrucción para calcular su promedio. estudiante.promediar(); El método muestrapromedio no es alcanzable por lo que es imposible invocarlo desde este punto de implementación. La forma en que se puede solucionar es cambiar en la clase, el modificador de alcance del método muestrapromedio por tipo public.

public string muestrapromedio() // Ahora el método tiene alcance publico { return (“ Promedio “ + Convert.To String( promedio )); }

La forma de invocarlo seria: MessageBox.Show ( estudiante.muestrapromedio() ); El modificador de alcance protected es utilizado en el tema de Herencia, por lo que para una mejor explicación y ejemplos del modificador se dejara pendiente. El concepto de Espacio de Nombres Para manejar eficientemente la información que se tiene almacenada en una computadora es necesario organizarla comúnmente en archivos, los cuales ordenamos dentro de directorios, de esta manera conservamos una jerarquía de directorios que nos permiten administrar los datos de manera adecuada. Del mismo modo que los archivos se organizan en directorios, las clases se organizan en espacio de nombres (namespace).

PROGRAMACIÓN


42

Los espacios de nombres son un modo sencillo y muy eficaz de tener perfectamente organizadas todas las clases, tanto las que proporciona el .NET Framework como las que podamos escribir nosotros al elaborar los programas. Por ejemplo, las clases más comúnmente usadas en Visual Studio .NET de cualquier aplicación se hallan en el espacio de nombres llamado System, las de acceso a bases de datos en System.Data, las de realización de operaciones de entrada/salida en System.IO, etc. Los namespace forman una jerarquía lógica, lo cual quiere decir que se pueden anidar. Por ejemplo dentro del namespace System se encuentra el namespace Collections que incluye tipos como ArrayList, BitArray, Queue y Snack. Para ver algunos de los espacios de nombres con Visual Studio .NET, abra un programa que tenga elaborado en C#, una vez hecho esto, se debe mostrar el explorador de objetos (Objet Browser), utilice las opciones del Menú Ver (View) y seleccione Examinador de Objetos (Object Browser), o bien con la combinación de teclas Ctrl+Alt+J, o simplemente presione F2) , se verá una pantalla como la que se muestra en la Figura 1.2.1.1.

Espacios de Nombres vistos desde el Explorador de Objetos

Lo que se muestra en la Figura parte de la biblioteca de clases del Framework .NET, organizadas en árbol. Los espacios de nombres (namespace) se encuentran precedidos por el símbolo {}. Como ya habíamos mencionado, existen de forma predefinida un conjunto de espacios de nombres que la misma plataforma .Net proporciona pero si observa con cuidado hay dos namespace: Arreglos y ArreglosProperties que se encuentran desplegados, estos espacios de nombres fueron de una aplicación diseñada en C#. Por lo tanto, nosotros también podemos definir nuestros propios espacios de nombres, en los cuales podremos organizar de manera adecuada nuestras clases.

PROGRAMACIÓN


43

a) b) Espacios de Nombres de Framework .Net y Espacios de Nombres Generados por el usuario

Los espacios de nombres también permiten usar en un mismo programa varias clases con igual nombre siempre y cuando pertenezcan a espacios diferentes. La idea es que cada fabricante defina sus tipos dentro de un espacio de nombres propio, para que así no haya conflictos, si se diera el caso de que varios fabricantes definen clases con el mismo nombre y se quieren usar a la vez en un mismo programa. Obviamente para que esto funcione no han de coincidir los nombres de los espacios de cada fabricante, y una forma de conseguirlo es dándoles el nombre de la empresa fabricante, o su nombre de dominio en Internet, etc. Ejemplo: Es muy común que las empresas de desarrollo de software den el mismo nombre a sus clases, sin embargo es mucho menos probable que los espacios de nombres coincidan, si seguimos las recomendaciones de Microsoft , que consiste en comenzar por llamar al espacio de nombres igual que se llama la compañía y a continuación el nombre del namespace , por ejemplo: Si tenemos una empresa NINFO y una empresa PRUA y en ambas empresas de desarrollo de software tienen una clase Vectores podemos definir dos espacios de nombres como NINFO_Matematicas y PRUA_Matematicas, aunque ambos espacios de nombres tengan una clase Vectores ésta podrá diferenciarse debido a que están en distintos espacios de nombres. En la siguiente tabla se muestran algunos de los espacions de nombres del Framework .NET

Nombre de Espacios de Nombres ¿Qué almacena?

System Tipos Básicos

System.Collections Colecciones

namespace

proporcionados por .NET

namespace generados

por el usuario

PROGRAMACIÓN


44

System.Data Acceso a Datos (ADO.NET)

System.IO Operaciones de E/S

System.NET Tipos E/S de Red

System.Reflection Reflexión

System.Runtime.Remoting Ejecución Remota

System.Runtime.Serialization Serialización de objetos

System.Security Acceso y ejecución seguros

System.Web Soporte http y ASP.NET

System.Windows.Forms Aplicaciones Windows

Definición de Espacios de Nombres Para definir un espacio de nombres se utiliza la siguiente sintaxis:

Los <miembros > aquí definidos serán los elementos contenidos en el espacio de nombres llamado <nombreEspacio> (para formar dicho nombre se sugiere que éste sea descriptivo y que cumpla las reglas de identificadores en el lenguaje C#). Además de clases estos miembros pueden ser también interfaces, estructuras, tipos enumerados y delegados (estos temas serán tratados más adelante). A continuación se muestra un ejemplo en el que definimos una clase de nombre ClaseMuestra perteneciente a un espacio de nombres llamado EspacioEjemplo: El verdadero nombre de una clase, al que se denomina nombre completamente calificado, es el nombre que le damos al declararlo, este está formado por la concatenación de todos los espacios de nombres a

namespace EspacioEjemplo

{

class ClaseMuestra

{

//miembros de la clase

}

}

PROGRAMACIÓN


45

los que pertenece, ordenados del más externo al más interno y seguido cada uno de ellos por un punto (carácter .) Por ejemplo, el verdadero nombre de la clase ClaseMuestra antes definida es:

Si no definimos una clase dentro de una definición de espacio de nombres, se considera que ésta pertenece al llamado espacio de nombres global y su nombre completamente calificado coincidirá con el identificador que tras la palabra reservada class le demos en su definición (nombre simple). Es posible incluir como miembros de un espacio de nombres a otros espacios de nombres. Es decir, como se muestra el siguiente ejemplo es posible anidar espacios de nombres Código [2] La ClaseMuestra tendrá como nombre completamente calificado a:

Lo que se ha definido es una clase ClaseMuestra perteneciente al espacio de nombres EspacioEjemplo2 que, a su vez, pertenece al espacio EspacioEjemplo Importación de espacios de nombres ¿Por qué utilizar la sentencia using? Seguramente en el curso anterior recuerdas haber visto este tipo de sentencias con la palabra using que por default las coloca el lenguaje C# al principio del código de nuestros programas, pues bien antes de pasar a explicaciones formales hagamos un ejemplo suponiendo que no tenemos dicha sentencia, por ejemplo si se desea crear un objeto de la clase: ClaseMuestra tendríamos que usar el nombre completo calificado (recuerda que se deben poner los nombres de espacios de nombres- si es que hay anidados- y el nombre de la clase) quedando entonces:

namespace EspacioEjemplo

{

namespace EspacioEjemplo2

{

class ClaseMuestra

{ //contenido de la clase}

}

}

PROGRAMACIÓN


46

Efectivamente se coloca el nombre del espacio de nombres más externo (EspacioEjemplo) separado por un punto, y enseguida el miembro de este espacio de nombres que para el ejemplo resulta ser otro espacio de nombres (EspacioEjemplo2) y por último el nombre de nuestra clase (ClaseMuestra). No obstante, dado que los espacios de nombres pueden tener un nivel de anidamiento extenso (antes de llegar a la clase requerida), esto puede implicar escribir demasiado código, ya que se debe indicar la ruta completa, esto puede resultar muy tedioso pues a medida que existan más espacios de nombres anidados habrá que escribir nombres muy largos, ya que la intensión final es usar la clase (en nuestro ejemplo la ClaseMuestra), por ello es que Visual Studio (C# en nuestro caso) incorpora la directiva using, para que una vez colocado el espacio de nombres (anidado o simple) pueda usar únicamente los nombres de mis clases. Sentencia using C# incluye un mecanismo de importación de espacios de nombres que simplifica la tarea y se basa en una sentencia que usa la siguiente sintaxis:

Estas sentencias siempre aparecen en la definición de espacio de nombres antes que cualquier definición de miembros de la misma. Permiten indicar cuáles serán los espacios de nombres que se usarán implícitamente dentro de ese espacio de nombres. A los miembros de los espacios de nombres así importados se les podrá referenciar sin usar calificación completa. Así, aplicando esto al ejemplo anterior quedaría:

PROGRAMACIÓN


47

La directiva using se puede colocar al principio del programa, con lo cual afectaría a todos los espacios de nombres que se definan en dicho programa, o bien dentro de los espacios de nombres, pero siempre antes de cualquier definición de miembro de dicho espacio de nombres, con lo cual afectaría solamente a los miembros del espacio de nombres donde se haya puesto. Veamos un ejemplo :

PROGRAMACIÓN


48

O podemos escribir el ejemplo anterior como sigue: En el primer caso (código 1) no habrá error, ya que Show es un método de la clase Windows.Forms.MessageBox , y using afecta a los dos espacios de nombres (Espacio1 y Espacio2) al estar escrito al principio del programa. Sin embargo, en el segundo ejemplo (código 2) el compilador nos avisaría de que no encuentra Show en ninguno de los espacios de nombres, dado que using sólo es conocido dentro de Espacio1 al estar escrito en este bloque.

using

System.Wi

namespace Espacio1{

using System.Windows.Forms;

class Ejemplo{

…

public void Saludo()

{

MessageBox.Show (“ Hola”);

}

}

}

namespace Espacio2 {

…

public void Saludo()

{

MessageBox.Show (“ Hola de nuevo”);

}

}

}

PROGRAMACIÓN


49

El código con llaves

Las llaves { } sirven para delimitar un área de bloque de código. Si hay una llave que abre, debe haber una que cierra

namespace n1{ class c1{ Bloque de Instrucciones1 } struct s1{ Bloque de Instrucciones2 } num e1{ Bloque de Instrucciones3 } } Comentarios

Los comentarios son líneas que escribimos en el código para proporcionar información de lo que estamos haciendo.

Los comentarios no son compilados ni interpretados, solo son considerados por el programador // Esta es una forma de hacerlo en una sola linea /* ®®®®®®®®®®®®®®®®®® ® Comentario utilizando ® múltiples líneas

PROGRAMACIÓN


50

®®®®®®®®®®®®®®®®®® */ Identificadores

Se usan para dar nombres a los elementos de un programa como variables, constantes y métodos.

Consta de caracteres letras, números y _ Sensible a mayúsculas y minúsculas Palabras reservadas:

Tipos de datos básicos

PROGRAMACIÓN


51

Variables

Una variable en C# representa la localización en memoria donde una instancia de un tipo es guardada. Se declaran al inicio de bloque de código y tienen un ámbito asociado.

Sintaxis:

Tipodedato var1 *, var2 *, var3,….+,+ ; Ejemplo: int x, y ; double z; string s1; Nota.- Cualquier variable que no esté declarada, no podrá ser usada y el compilador marcará el error. Declaración de variables inicializadas

int x = 23; double n1 = 34.5; float g = 45.0; string ident = “Rocio”; string passwd = “abejamaya”; int a, b, c = 0;

Ámbito de una variable

Conjunto de código donde una variable es visible y conocida.

Código 1

PROGRAMACIÓN


52

Operadores y su precedencia

Operadores Lógicos And && Or || Not ~

Conversión de tipos de datos ( cadena )

Cadena a enteros string cambio = “45”; int valor; valor = Convert.ToInt16( cambio); Variante valor = int.Parse( cambio);

Cadena a decimal

PROGRAMACIÓN


53

string peso = “68.9”; double cantidad; cantidad = Convert.ToDouble( peso ); Variante cantidad = double.Parse( peso );

Conversión de tipos de datos ( Entero )

Entero a Cadena int edad = 18; string mensaje; mensaje = Convert.ToString( edad ); variante mensaje = edad.ToString();

Entero a Decimal int altura = 100; double cantidad; cantidad = Convert.ToDouble( altura );

Conversión de tipos de datos ( Decimal )

Decimal a Cadena double metros = 7.6; string marca; mensaje = Convert.ToString( metros ); variante mensaje = metros.ToString();

Decimal a entero double presion = 23.4; int dato; dato = Convert.ToInt16( presion );

Estructuras de control

a) Alternativa simple (if)

La sintaxis de esta estructura sintáctica es la siguiente: if (<condición>) {

<bloque de instrucciones>; }

PROGRAMACIÓN


54

La semántica de esta instrucción es la siguiente: se evalúa la expresión lógica <condición>, si el resultado de su evaluación es verdadero (true) se ejecuta el <bloque de instrucciones >. La instrucción condicional if refleja que en un punto dado del programa se quiere ejecutar alternativamente (en dependencia de la evaluación de una condición), un conjunto de instrucciones.

b) Alternativa doble (if-else)

La sintaxis de esta variante sintáctica de la estructura if se puede expresar de la siguiente forma: if (<condición>) {

<bloque de instrucciones 1>; } else {

<bloque de instrucciones 2>; } La semántica de esta variante es la siguiente: El <bloque de instrucciones 1> se ejecuta en caso de que se cumpla la <condición>, en otro caso se ejecuta entonces el <bloque de instrucciones 2>. Al comparar las diferentes variantes presentadas en esta sección es posible concluir que la estructura de control alternativa if puede ser descrita de la siguiente forma (dado el carácter opcional de la cláusula else): if (<condición>) {

<bloque de instrucciones 1>; } [else {

<bloque de instrucciones 2>; }] Nota: Cabe aclarar que un bloque de instrucciones puede comenzar a su vez con otro if.

c) Alternativa múltiple (switch)

Con el objetivo de hacer más legibles y claros los códigos de implementación de los algoritmos donde se tienen múltiples casos, la mayoría de los lenguajes brinda una instrucción de alternativa múltiple (switch case) cuya sintaxis se muestra seguidamente:

PROGRAMACIÓN


55

switch (<expresión>) { case <valor 1>: <bloque de instrucciones 1> [break] case <valor 2>: <bloque de instrucciones 2> [break] case <valor n>: <bloque de instrucciones n> [break] [default: <bloque de instrucciones default> [break]] } La semántica de esta instrucción es muy simple: si al evaluarse <expresión> toma <valor 1> entonces se ejecuta <bloque de instrucciones 1>; si al evaluarse <expresión> toma <valor 2> entonces se ejecuta <bloque de instrucciones 2> y así sucesivamente hasta <valor n>. De no coincidir la evaluación con alguno de las valores predeterminados y existir la rama default (note que es opcional), entonces se ejecutará <bloque de instrucciones default>. La instrucción break es obligatoria excepto cuando exista una instrucción return en el respectivo bloque de instrucciones. Este break indica que después de ejecutar el bloque de instrucciones que lo precede se salta a la próxima instrucción después del switch. Nota: Existen otros recursos que se pueden utilizar y con los que es posible obtener resultados similares a break pero en el presente texto no se presentan pues constituyen una mala práctica de programación. Los valores indicados en cada rama del switch han de ser expresiones constantes que produzcan valores de algún tipo básico entero, de una enumeración, de tipo char o de tipo string. Además, no puede haber más de una rama con el mismo valor. Para ejemplificar esta nueva estructura sintáctica se define a continuación una variante del método DíasMes: public int DíasMes() { switch (mes) {

case 4: return 30; case 6: return 30; case 9: return 30; case 11: return 30; case 2 : if (bisiesto( ))

return 29; else

return 28; default: return 30;

} }

PROGRAMACIÓN


56

En el caso que varias ramas coincidan en sus respectivos bloques de instrucciones, éstas se pueden agrupar como se muestra seguidamente: public int DíasMes() {

switch (mes) {

case 4: case 6: case 9: case 11: return 30; case 2 : if (bisiesto( ))

return 29; else

return 28; default: return 30;

} }

d) Estructura de control FOR

Uno de los ciclos más conocidos y usados es el basado en la instrucción for y que suele estar controlado por un contador o variable de control y que tiene la siguiente sintaxis: for (<instrucciones 1>; <expresión>; <instrucciones 2>)

<instrucciones>

La semántica de esta instrucción es la siguiente:

<instrucciones 1>; se ejecutará una sola vez al inicio del cic lo, generalmente se realizan

inicializaciones y declaraciones de variables puesto que como se dijo con anterioridad, esta solo

se ejecuta una vez. En caso de que se quiera realizar o ejecutar mas de una instrucción en este

momento, dichas instrucciones se deben separar por comas (“,”).

<expresión>; es evaluada en cada ciclo y en dependencia del valor que devuelva, dependerá que

el bucle continúe ejecutándose (valor de la evaluación true) o no (false). Es válido destacar o

advertir que de no colocarse nada en esta parte, el ciclo tomará como true el valor devuelto por

lo que en principio se podrá repetir infinitamente.

<instrucciones 2>; es ejecutado siempre en cada ciclo al terminar de ejecutar todas las

instrucciones que pertenecen al bucle for en cuestión. Por lo general puede contener alguna

actualización para las variables de control. Análogamente a < instrucciones 1> en caso de querer

ejecutar en este momento más de una instrucción se deben separar por comas.

Ejemplo: Implementar el algoritmo propuesto con anterioridad para el cálculo del promedio.

PROGRAMACIÓN


57

public double Promedio() {

double suma = 0; for (uint i = 0; i < notas.Length; i++)

suma += notas[i]; return suma / notas.Length;

} Situación de análisis En esta variante de implementación el recorrido del arreglo notas es desde el primer elemento hasta el último. Ejemplo: ¿Implementar el método promedio haciendo el recorrido inverso del arreglo notas? {

double suma = 0; for (int i = notas.Length - 1; i >= 0; i--)

suma += notas[i]; return suma / notas.Length;

}

e) Estructura de control While

A veces no es posible saber de antemano el número de veces que se va a repetir la ejecución de una posición de código mientras una cierta condición sea cierta. En realidad como se ha visto en esta sección, la instrucción for es un bucle condicional, aunque su uso más habitual está asociado con un contador. Para definir estos ciclos condicionales es posible utilizar la estructura de control while cuya sintaxis es la siguiente: while <condición>

<instrucciones>

Esta estructura de control permite realizar un bucle (<instrucciones>) que se repetirá mientras la <condición> sea cierta, o dicho de otra manera, el bucle terminará cuando la <condición> sea falsa. Cabe señalar que con esta estructura la <condición> se chequea siempre al principio del bucle por lo que si la primera vez que se evalúa <condición>, es falsa, el ciclo no llegará nunca a ejecutarse. Ejemplo: Obtener la suma de los números del 1 al 10. {

int i = 0, suma=0; while ( i < 10) { Suma+=i;

PROGRAMACIÓN


58

i++; }

return suma; }

f) Estructura do-while

La estructura de control do-while es otra sentencia de iteración en la que la condición se evalúa por primera vez después de que las instrucciones del ciclo se hayan ejecutado. Esto quiere decir que las sentencias del bucle do-while, al contrario que las del ciclo while, al menos se ejecutan una vez. La sintaxis de esta estructura es la siguiente: do {

<instrucciones>; }while <condición>; Ejemplo: Para resolver el mismo ejercicio del ejemplo anterior: {

int i = 0, suma=0; do { Suma+=i;

i++; }while ( i < 10); return suma;

}

Encapsulamiento

La encapsulación se puede imaginar como una envoltura que rodea a los datos de las clases de C#, permitiendo proteger y ocultar (encapsular) dichos datos dentro de una clase y a la vez denegando el acceso desde código externo. El objetivo es proteger los datos de un uso inadecuado. Por ejemplo: class ArticuloTienda {

public string Descripcion; public double Costo; public int Cantidad;

}

PROGRAMACIÓN


59

En este ejemplo, los miembros Descripcion, Costo y Cantidad son expuestos (por el modificador public) y cualquier persona podría ver /alterar dichos datos. Existe el riesgo de que alguien registre valores erróneos por malicia o descuido. Por ejemplo, suponga que un usuario le asigna el valor -200 al campo Cantidad, el compilador no provocaría ningún error, ya que un tipo de dato int es capaz de almacenar valores negativos, sin embargo lógicamente no es posible que registremos valores negativos dentro de este campo. La solución consiste en “encapsular” a los miembros (con el modificador private) y crear un mecanismo de acceso de manera indirecta y validada. class ArticuloTienda {

private string Descripcion; private double Costo; private int Cantidad; //Código para accesar de manera indirecta al atributo Cantidad public void AsignaCantidad ( int ValorCantidad) { if (ValorCantidad < 0) Cantidad = 0; else Cantidad = ValorCantidad; }

} El método AsignaCantidad permite asignar un valor al atributo Cantidad eliminando el error de valores negativos en dicho campo. Para asignar valores validos al atributo Costo, se puede sugerir implementar un método similar. El modificador private permite el acceso (de lectura y modificación) a un atributo con uso exclusivo dentro de la clase donde fue definido. El ocultamiento de información es importante porque:

a) Separa el comportamiento del objeto de su implementación. b) Establece y refuerza las restricciones de acceso al objeto, al ocultar los detalles de su

implementación interna a los usuarios del mismo.

c) El usuario conoce las operaciones del objeto que puede solicitar, pero desconoce los detalles de cómo se llevan a cabo dichas operaciones. Todos los detalles específicos acerca de los datos del objeto y la codificación de sus operaciones están fuera del alcance del usuario.

d) Evita la corrupción de los datos de un objeto promoviendo la integridad del mismo. Si todos

los programas pudieran tener acceso a los datos en cualquier forma que quisieran los

PROGRAMACIÓN


60

usuarios, los datos se podrían corromper y entonces ser utilizados de mala manera. El ocultamiento de información protege los datos del uso arbitrario de los usuarios y de posibles errores accidentales por parte del programador.

e) Es más fácil realizar cambios durante la implementación, la prueba y el mantenimiento del

software orientado a objetos, porque al modificar un objeto se cambia, al mismo tiempo, un tipo de objeto, afectando únicamente los métodos y las estructuras de datos asociados con dicho tipo de objeto, es decir, la modificación y la prueba de un tipo de objeto se puede efectuar de manera independiente.

En otras palabras, la encapsulación se encarga de mantener ocultos los procesos internos que necesita para hacer lo que sea que haga, dándole al programador acceso sólo a lo que necesita. Esto da 2 ventajas iniciales: Lo que hace el usuario puede ser controlado internamente (incluso sus errores), evitando que todo colapse por una intervención indeseada. La segunda ventaja es que, al hacer que la mayor parte del código esté oculto, es posible hacer cambios y/o mejoras sin que eso afecte la manera en la que los usuarios van a utilizar el código. Sólo se tiene que mantener igual la forma de acceder a él.

Herencia Algunas clases sirven como punto de partida para generar una nueva, tomando prestada la definición de la primera. La herencia es una relación entre clases en la que una clase comparte la estructura y/o el comportamiento definidos en una (herencia simple) o más clases (herencia múltiple). La clase de la que otras heredan se denomina superclase. Análogamente, la clase que hereda de otra o más clases se denomina subclase. La flecha en el diagrama anterior apunta desde la clase derivada a la clase base (clase padre), así, puede haber más de una clase derivada (clase hija). La herencia define, por tanto, una jerarquía “de tipos” entre clases, en la que una subclase hereda de una o más superclases. La herencia es uno de los pilares fundamentales en los que se basa la programación orientada a objetos, ésta nos permite definir nuevas clases a partir de otras ya definidas, permitiendo una forma de reutilización del software en la que se crean clases nuevas a partir de clases ya existentes por medio de la

Base

(Superclase)

Derivada

(Subclase)

PROGRAMACIÓN


61

absorción se sus atributos y comportamientos, sobreponiéndolos o mejorándolos con capacidades que las clases nuevas requieran. Mediante la herencia se logra compartir el comportamiento y los atributos de las clases de objetos definidas previamente con extensiones de clases de objetos que reciben el nombre de subclases. Se dice que las subclases heredan las estructuras de datos y las operaciones de la clase de objetos a partir de la cual se derivan. El hecho de que un tipo de objeto de alto nivel pueda especializarse en tipos de objeto de bajo nivel, permite la creación de una jerarquía de clases, subclases, sub-subclases, etc. Una clase permite la implementación de un tipo de objeto. Una subclase hereda propiedades de su clase padre, una sub-subclase hereda propiedades de las subclases, etc. Una subclase puede heredar las estructuras de datos y los métodos de su superclase; también puede tener sus propios métodos e incluso tipos de datos propios. De manera más específica se tienen las siguientes definiciones. Una subclase es una clase que hereda las propiedades y los métodos de una clase existente. Una superclase es una clase de la cual otra clase hereda propiedades y métodos. Herencia simple es cuando una clase se deriva de una superclase. Herencia múltiple es cuando una clase se deriva de más de una superclase. La herencia es una relación donde un objeto es derivado desde otro objeto. Cuando un objeto es heredado, todas sus propiedades y métodos son automáticamente incluidos en el nuevo objeto. Las clases que derivan de otras se definen usando la siguiente sintaxis:

La clase derivada hereda las propiedades de la clase base y es posible agregar o reemplazar métodos y propiedades según sea necesario.

En C#, el operador “:”, define la herencia e implementación de interfaces. La clase base siempre debe estar en el extremo derecho en la declaración de clase como se muestra en el código.

C# no admite herencia múltiple, lo que significa que las clases no pueden heredar de más de una clase. Recuerde que una clase es un tipo de dato definido por el usuario así un tipo(clase) más que describir las restricciones de un conjunto de objetos; también tiene una relación con otros tipos(clases). Dos tipos pueden tener características y conductas en común, pero un tipo puede contener más características que otra y puede también controlar más mensajes (o controlarlos de forma diferente). La herencia expresa esta similitud entre tipos usando el concepto de tipos bases y tipos derivados. Un tipo base contiene todas las características y conductas que son compartidas entre los tipos derivados a partir de éste. Por lo cual se crea un tipo base para representar lo central de las ideas acerca de algunos objetos en un sistema de software. Desde el tipo base, se derivan otros tipos para expresar las formas diferentes que el objeto principal puede realizarse.

class <nombreClaseDerivada>:<nombreClaseBase> { <miembrosDerivada>

}

PROGRAMACIÓN


62

Ejemplo: Tenemos la clase persona como se muestra a continuación:

Persona

- _Nombre - _Edad - _CURP

+ Nombre – get() + Edad – get() + CURP –get()

A partir de ella podemos crear a la clase Trabajador de la siguiente forma: class Trabajador:Persona { int _Sueldo; public Sueldo { get { return _Sueldo } } } Los objetos de esta clase Trabajador contarán con los mismos miembros que los objetos Persona y además incorporarán un nuevo campo llamado Sueldo que almacenará el dinero que cada trabajador gane.

Polimorfismo La palabra polimorfismo significa “múltiples formas”, por lo tanto, podríamos definir en el ámbito de programación que el polimorfismo es “la capacidad de poder enviar un mismo mensaje a objetos totalmente diferentes, y que cada uno de estos objetos responda de manera diferente”. Pongamos por ejemplo las clases hombre, vaca y perro, si a todos les damos la orden Come, cada uno de ellos sabe cómo hacerlo y realizará este comportamiento a su modo. Veamos otro ejemplo. Tomemos las clases barco, avión y coche, todas ellas derivadas de la clase padre vehículo; si les enviamos el mensaje Desplázate, cada una de ellas sabe cómo hacerlo.

PROGRAMACIÓN


63

La herencia permite que una clase derivada redefina el comportamiento especificado para una clase base. Supongamos la clase base Animal, haciendo alusión a animales genéricos, con un método HacerSonido abstract class Animal { public abstract void HacerSonido(); } En seguida creamos 2 clases de animales específicos, por ejemplo Perro y Gato partiendo de la clase Animal class Gato : Animal { public override void HacerSonido() { Console.WriteLine (“miau”); } } class Perro : Animal { public override void HacerSonido() { Console.WriteLine (“guaf”); } } Cada clase tiene implementado su método HacerSonido(), anulando al método de la clase base Animal. El poliformismo es la capacidad de la POO de llamar correctamente al método anulado en función de que clase lo está llamando, cuando se trabaja con una colección de objetos derivados. Por ejemplo, suponga una colección de animales Zoo, el cual se le agrega un perro y 2 gatos. ArrayList Zoo = new ArrayList [3]; Gato Sasha = new Gato(); Gato Koshka = new Gato(); Perro Milou = new Perro(); Zoo es una colección polimórfica, porque almacenará objetos de clases derivadas de la clase Animal. Zoo.Add(Milou); Zoo.Add(Sasha); Zoo.Add(Koshka); Es posible recorrer el arreglo Zoo, invocando el método HacerSonido()

PROGRAMACIÓN


64

foreach (Animal x in Zoo) { x.HacerRuido(); } El resultado ante este código, será: guaf miau miau Lo que ha ocurrido es que c# recorre el arreglo invocando la versión correcta de HacerSonido() cuando se tiene a un Perro ó cuando es un Gato

PROGRAMACIÓN


65

Unidad Temática IV Arreglos. Objetivo: El alumno implementará arreglos, para manejar conjuntos de elementos.


Definición de Arreglos.

Explicar el funcionamiento de un arreglo.


Manejo de arreglos

Identificar la declaración de los tipos de arreglos (de datos primitivos y de objetos). Explicar el procedimiento para la manipulación de arreglos.

Codificar aplicaciones mediante arreglos.


Resultado de Aprendizaje: Entregará en un medio electrónico: Código fuente, ejecutable de una aplicación que implemente el uso

de arreglos de elementos.

PROGRAMACIÓN


66

Definición de Arreglos Un arreglo o vector es un tipo especial de variable que es capaz de almacenar en su interior y de manera ordenada uno o varios datos de un determinado tipo. Cada uno de estos valores se identifica mediante un número al cual se llama índice. Así, para acceder al primer elemento del arreglo habría que usar el índice cero, para el segundo el índice uno, para el tercero el índice dos, y así sucesivamente. Una analogía que se puede utilizar es pensar una serie de jaulas numeradas dentro de un zoológico, en cada jaula podremos guardar un animal (información). Si en algún momento una persona habla acerca de un animal, bastara con conocer el nombre del zoológico y el número de jaula para poder identificar a dicha especie. En una computadora, un arreglo es representado como un segmento de memoria que tiene un número determinado de celdas, capaz de almacenar valores del mismo tipo en cada una de sus celdas. Para consultar un solo elemento dentro de un arreglo se utiliza un número índice, que ubica la posición de la celda donde se encuentra. El índice permite acceder de forma individual a los elementos de un arreglo, determinando cual es la celda a consultar o escribir (asignar). Para consultar un dato almacenado en un arreglo, se utiliza la sintaxis:

Nombre_arreglo[ índice ]

Ejemplo: Muebles

0 1 2 3

Arreglo Lineal “Muebles”

Manejo de Arreglos Vamos a ver cómo se declara un arreglo:

tipo[] variable;

Bien, como pueden observar es muy parecido a como se declara una variable normal, sólo que hay que poner corchetes detrás del tipo. En efecto, en la declaración de un array en C# los corchetes se colocan detrás del tipo y no detrás de la variable. Esta pequeña diferencia sintáctica se debe a una importante diferencia semántica: aquí los arrays son objetos derivados de la clase System.Array. Por lo tanto, y esto es muy importante, cuando declaramos un array en C# este aún no se habrá creado, es decir, no se habrá reservado aún memoria para él. En consecuencia, los arrays de C# son todos dinámicos, y antes de poder usarlos habrá que instanciarlos, como si fuera cualquier otro objeto.

“mesa” “silla” “sillón” “banco”

PROGRAMACIÓN


67

Veamos un breve ejemplo:

string[] nombres; // Declaración del array

nombres = new string[3]; // Instanciación del array

En efecto, el array nombres será utilizable únicamente a partir de su instanciación. En este ejemplo, el número 3 que está dentro de los corchetes indica el número total de elementos de que constará el array. Los arrays de C# están basados en cero, esto es, el primer elemento del array es cero. Por lo tanto, en este caso, el último elemento sería 2 y no 3, ya que son tres los elementos que lo componen (0, 1 y 2). Veamos un ejemplo algo más completo y después lo comentamos: Podemos declarar e instanciar un arreglo utilizando la sintaxis de un solo renglón como se muestra a continuación: <tipoDatos>[ ] <nombreArreglo> = new <tipoDatos>[<númeroDatos>]; Para el ejemplo anterior la declaración e instanciación en una solo línea quedaría:

string[] nombres = new string[3];

Si queremos almacenar 100 elementos de tipo int se declara así: int[] numeros = new int[100]; Aunque también sería posible definir el tamaño de arreglo de forma separada a su declaración de este modo: int[] numeros; numeros = new int[100]; Si se crea un arreglo con la sintaxis hasta ahora explicada todos sus elementos tendrían el valor por defecto de su tipo de dato. Si queremos darles otros valores al declarar la tabla, hemos de indicarlos entre llaves usando esta sintaxis: <tipoDatos>[] <nombreTabla> = new <tipoDatos>[] {<valores>}; Han de especificarse tantos <valores> como número de elementos se desee que tenga el arreglo, y si son más de uno se han de separar entre sí mediante comas (,) Nótese que ahora no es necesario indicar el número de elementos de un arreglo pues el compilador puede deducirlo del número de valores especificados. Por ejemplo, para declarar un arreglo de cuatro elementos de tipo int con valores 5,1,4,0 se podría hacer lo siguiente: int[] valores = new int[] {5,1,4,0}; Incluso se puede compactar aún más la sintaxis declarando el arreglo así: int[] valores = {5,1,4,0};

PROGRAMACIÓN


68

La sintaxis de la declaración e inicialización de un arreglo es bastante flexible, como se puede observar en los ejemplos anteriores, por lo que se puede como ya se ha hecho anteriormente declarar un arreglo sin inicializarlo y posteriormente inicializarlo. Ejemplo:

string[] Nombres; Nombres= new string[3]; Nombres*+=”Eduardo”; Nombres*+=”Daniel”; Nombres*+=”Gabriel”; También es posible declararlo e inicializarlo directamente , sin utilizar el operador new : string[] Nombres= ,“Eduardo”,”Daniel”,”Gabriel”-;

Además, podemos crear arreglos cuyo tamaño se pueda establecer dinámicamente a partir del valor de cualquier expresión que produzca un valor de tipo entero. Por ejemplo, para crear una arreglo cuyo tamaño sea el valor indicado por una variable de tipo int (luego su valor será de tipo entero) se haría: int numero = 5; ... int[] Arrreglo_dinamica = new int[numero]; A la hora de acceder a los elementos almacenados en un arreglo basta indicar entre corchetes, y a continuación de la referencia a la misma, la posición que ocupe en el arreglo el elemento al que se desea acceder. Cuando se haga hay que tener en cuenta que en C# los arreglos se indexan desde 0, lo que significa que el primer elemento del arreglo ocupará su posición 0, el segundo ocupará la posición 1, y así sucesivamente para el resto de elementos. Por ejemplo: int[] valores = new int[4]; valores[0] = 5; valores[1]++; // Por defecto se inicializó a 0, luego ahora el valor de valores[1] pasa a ser 1 valores[2] = valores[0] – valores[1]; // valores[2] pasa a valer 4, pues 5-1 = 4 // El contenido del arreglo será {5,1,4,0}, pues tabla[3] se inicializó por defecto a 0. Hay que tener cuidado a la hora de acceder a los elementos de un arreglo ya que si se especifica una posición superior al número de elementos que pueda almacenar este se producirá una excepción de tipo System.OutOfBoundsException. Para evitar este tipo de excepciones puede consultar el valor de Length que está asociado al arreglo y contiene el número de elementos de la misma. Por ejemplo, para asignar un 7 al último elemento de la tabla anterior se haría: valores[valores.Length – 1] = 7; // Se resta 1 porque valores.Length devuelve 4 pero el último // elemento del arreglo es valores[3]

PROGRAMACIÓN


69

Como hemos podido observar para acceder a un elemento del arreglo basta con colocar el índice del elemento entre corchetes, (recuerde que el índice comienza en cero) por ejemplo: int[] numeros = new int[10]; // El índice comienza en Cero!!! numeros[4]=28; //asignan un 28 en la posición 5 numeros[8-1]= 90; // asigna en la posición 6 un 90 int i= 2; numeros[i++]= 300; //asigna un 300 en la posición 2 En C# , los arreglos son objetos. Además todos los arreglos, de cualquier tipo, derivan de la clase System.Array, que es el tipo base abstracto de todos los tipos de arreglos. La clase System.Array proporciona muchos métodos y propiedades para manipular arreglos. Por ejemplo para obtener la longitud de un arreglo se utiliza la propiedad Length. El siguiente código asigna la longitud del arreglo Enteros , que es 5 a la variable longitud: int[] Enteros ={1,2,3,4,5}; int longitude = Enteros.Length; Las propiedades y métodos más importantes son los siguientes: Length: devuelve el número de elementos de un arreglo. GetLength: Obtiene la longitud de una determinada dimensión cuando el arreglo es multidimensional. Por ejemplo, para obtener el número de elementos de la primera dimensión: Int longitud= OtroArreglo.GetLength(0; Sort y Reverse: Estos métodos permiten ordenar un arreglo de modo ascendente o descendente. Por ejemplo, si nuestro arreglo se llama Numeros tenemos: Array.Sort (Numeros); //Ordena de forma ascendente Array.Reverse (Numeros) // Ordena de forma descendente El hecho de que un arreglo haya sido inicializado no quiere decir que sea inamovible. Si un arreglo que ya contiene datos se vuelve a instanciar, el arreglo volverá a estar vacío, y obtendrá las dimensiones de la nueva instanciación. Bien, todos estos arreglos que hemos explicado hasta el momento son arreglos unidimensionales, es decir, que tienen una sola dimensión (un solo índice). Sin embargo esto no soluciona aún todas las necesidades del programador. Pongamos, por ejemplo, que queremos almacenar las combinaciones de las ocho columnas de una quiniela de fútbol en un arreglo. ¿Cómo lo hacemos? Pues bien, el mejor modo es utilizar un arreglo multidimensional.

PROGRAMACIÓN


70

Declaración y acceso a Arreglos multidimensionales Los arrays multidimensionales son aquellos que constan de dos o más dimensiones, es decir, que cada elemento del arreglo viene definido por dos o más índices. En esta unidad nos enfocaremos a los arreglos de dos dimensiones conocidos comúnmente como matrices. Una matriz es aquella cuyos elementos se encuentran organizados en una estructura de dos dimensiones. Para definirlas se utiliza una sintaxis similar a la usada para declarar arreglos, pero separando las dimensiones mediante comas (,) Por ejemplo, un matriz de tipo int que conste de 12 elementos puede tener éstos distribuidos en dos dimensiones formando una estructura 3x4 similar a una matriz de la forma: 1 2 3 4 5 6 7 8 9 10 11 12 Esta matriz se podría declarar así: int[,] Matriz = new int[3,4] {{1,2,3,4}, {5,6,7,8}, {9,10,11,12}}; En realidad no es necesario indicar el número de elementos de cada dimensión de la matriz ya que pueden deducirse de los valores explícitamente indicados entre llaves, por lo que la definición anterior es similar a esta: int[,] Matriz = new int[,] {{1,2,3,4}, {5,6,7,8}, {9,10,11,12}}; Incluso puede reducirse aún más la sintaxis necesaria quedando tan sólo: int[,] Matriz = {{1,2,3,4}, {5,6,7,8}, {9,10,11,12}}; Sintaxis para declarar una matriz en general: <tipoDatos>[ , ] <nombrematriz> = new <tipoDatos>[<numeroDatos1>, <numeroDatos2>]; Si lo que deseamos es declarar una matriz sin indicar sus elementos:

string[,] alumnos = new string[2,4];

Este array es bidimensional y serviría para almacenar una lista de alumnos por aula, esto es, tenemos dos aulas (el primer índice del arreglo es 2) y cuatro alumnos en cada una (el segundo índice es 4). Veamos un poco de código y una tabla para tener una idea de cómo se almacena esto:

alumnos[0,0]="Lalo";

alumnos[0,1]="Mario";

PROGRAMACIÓN


71

alumnos[0,2]="Juan";

alumnos[0,3]="Pepe";

alumnos[1,0]="Lola";

alumnos[1,1]="María";

alumnos[1,2]="Juana";

alumnos[1,3]="Pepa";

Recapitulando, con más ejemplos: // Una matriz de 3 renglones por 2 columnas observe como se definen éstos int[,] num = new int[3,2] { {80,90},{200,300},{120,140}}; // Matriz de 2 renglones por 2 columnas de cadenas string*,+ nombres = new string*2,2+ , ,“Juan”,”Ana”-,,“Alberto”,”Diana”-,-; Se puede omitir el tamaño: int[,] num = new int[,] { {80,90},{200,300},{120,140}}; string*,+ nombres = new string *,+ , ,“Juan”,”Ana”-,,“Alberto”,”Diana”-,-; También la cláusula new si se inicializa: int[,] num = { {80,90},{200,300},{120,140}}; string*,+ nombres = , ,“Juan”,”Ana”-,,“Alberto”,”Diana”-,-; Y para declara e instanciar las matrices anteriores sin especificar elementos almacenados: int[,] num = new int[3,2]; string[,] nombres = new string[2,2]; El acceso a los elementos de una tabla multidimensional es muy sencillo: sólo hay que indicar los índices de la posición que ocupe en la estructura de la tabla el elemento al que se desee acceder. El siguiente código se declara un arreglo y se asigna 27 al elemento localizado en [1,1] y al [4][1]: int[,] numeros = { {1,9},{2,3},{7,5} ,{2,8},{6,9} }; numeros[1][1]=27; numeros[4][1]=27; Para comprender mejor como se afectan los elementos veámoslo de forma grafica Matriz Original:

1 9

2 27

7 5

2 8

6 27

1,1

4,1

PROGRAMACIÓN


72

Unidad Temática V Manejo de Excepciones. Objetivo: El alumno controlará errores en tiempo de ejecución a través de excepciones para generar programas robustos.


Concepto y tipos de excepciones.

Identificar los diferentes tipos de excepciones y la jerarquía de clases correspondientes a estas.

Enlistar los tipos de excepciones y jerarquía de clases.

Analítico. Ordenado. Sistemático. Coherente. Proactivo. Asertivo.

Manejo de excepciones.

Identificar la sintaxis de las cláusulas para el manejo de excepciones (try, catch, final, throw y throws).

Controlar las excepciones generadas a través de las clausulas apropiadas en el manejo de errores en tiempo de ejecución.


Creación y lanzamiento de excepciones.

Reconocer la estructura para la generación de excepciones y su lanzamiento.

Operar (crear, lanzar y manejar) excepciones.


Resultado de Aprendizaje: Entregará en un medio electrónico: Código fuente, Ejecutable de una aplicación que integre el control de errores en tiempo de ejecución, a través de excepciones.

PROGRAMACIÓN


73

Concepto y tipos de excepciones. Los errores causados por un programa de computadora pueden ser clasificados dentro de tres grupos

principales:

Tiempo de diseño, Ejecución, y lógico.

El error en tiempo de diseño es el más fácil de encontrar y arreglar.

Un error de este tipo ocurre cuando se escribe código no siguiendo las reglas del lenguaje de programación.

Son fáciles de encontrar debido a que Visual Estudio .NET no solo indica donde está, sino que parte de la línea es incompresible para el lenguaje.

Los errores en tiempo de ejecución son más difíciles de ubicar, debido a que Visual Studio no proporciona una ayuda para encontrar el error hasta que este ocurre en la ejecución del programa.

Estos errores ocurren cuando un programa intenta alguna cosa ilegal, como acceder a datos que no existen o recursos para los cuales no se tienen los permisos adecuados.

Este tipo de errores puede causar que el programa se cuelgue a menos que sean manejados adecuadamente.

El tercer tipo de error, el error lógico, es frecuentemente el más insidioso para ubicar, debido a que por si mismo puede no manifestarse como un problema en todo el programa.

Un programa con un error lógico simplemente significa que la salida u operación del programa no es exactamente como se esperaba.

Lo anterior puede ser ocasionado por un cálculo incorrecto o tener una opción de menú habilitada cuando se quería deshabilitar, etc.

Excepciones integradas

Un error en tiempo de ejecución en C#.NET genera una exception.

Una excepción es una respuesta a una condición de error que el programa ha generado.

Tipos de excepciones

Existen cientos de clases de excepción construidas dentro del entorno .NET, la figura siguiente muestra la ventana de diálogo de excepciones que se encuentra en el menú Depurar.

PROGRAMACIÓN


74

Buscando en el árbol mostrado por la ventana se pueden encontrar eventualmente todas las clases que generan excepciones del entorno .NET que pueden ser manejadas según el tipo de error que se desea controlar en un orden específico o genérico.

Manejo de excepciones. El manejo de un error es una sección de código de C#.NET que permite detectar excepciones y ejecutar los pasos necesarios para recuperar el control después del error. Considere el siguiente bloque de código dentro del evento clic de un botón. private void button1_Click(object sender, EventArgs e) { string cadena = "cochinos"; button1.Text = cadena.Substring (10,1); } El código está intentando desplegar el onceavo carácter en la cadena “cochinos”. La cadena sólo contiene

ochos caracteres y una excepción es generada al momento de ejecutar el evento, como lo muestra la

siguiente imagen.

PROGRAMACIÓN


75

Lo primero que debe notarse es el hecho de que el mensaje ocurre en tiempo de ejecución como un tipo de excepción no controlada.

Esto significa que la línea de código que ha generado el error no esta contenida dentro de un bloque de manejo de excepción.

La segunda pieza de información es que la excepción es del tipo ArgumentOutOfRangeException.

Los errores pueden ser clasificados en grupos, en el caso anterior el mensaje indica que el objeto excepción generado es de dicha clase, la cual es descendiente de la clase Exception.

La información adicional indica algunas notas específicas sobre la naturaleza del error, para el ejemplo, el índice –startIndex no puede ser mayor que la longitud de la cadena.

Estructura de una excepción El siguiente código contiene el mismo problema que en la sección anterior pero contiene una forma

simple de atrapar el error que se produce.

private void button1_Click(object sender, EventArgs e) { string cadena = "cochinos"; try { button1.Text = cadena.Substring(10, 1); } catch { button1.Text = "Error"; } }

El código intenta hacer lo mismo que el código anterior, pero esta vez la sentencia de la cadena “defectuosa” es envuelta entre el bloque try … Catch …

Este bloque representa el manejo básico de una excepción. Si algún código después de la sentencia Try genera una excepción, el control del programa automáticamente salta al código después de la sentencia Catch.

PROGRAMACIÓN


76

Si excepciones no son generadas en el código bajo la sentencia Try, entonces el bloque Catch es pasado por alto.

Cuando el código es ejecutado, ArgumentOutOfRangeException se genera y el código no termina con un mensaje. En su lugar, la propiedad text del botón establece la palabra “Error”, y el programa continúa con su ejecución.

Una variación en el manejo de excepciones es el siguiente:

private void button1_Click(object sender, EventArgs e) { string cadena = "cochinos"; try { button1.Text = cadena.Substring(10, 1); } catch (Exception oEx) { button1.Text = oEx.Message; } }

En esta ocasión, la excepción genera una instancia de la clase Exception y localiza dicha instancia en una variable llamada oEX.

Tener la variable de una instancia de excepción es útil debido a que ofrece el texto del problema, que es desplegado en un mensaje.

De hecho, desplegar el mensaje de la excepción dentro de una ventana es mucho mejor que hacerlo durante la ejecución del programa con una excepción no controlada.

Note que el control de la excepción anterior no diferencia entre los diferentes tipos de errores, si alguna excepción es generada dentro del bloque Try, entonces el bloque Catch es ejecutada.

Es posible escribir un control de excepción que maneje diferentes clases de errores, por ejemplo vea el siguiente código.

private void button2_Click(object sender, EventArgs e) { try { button2.Text = listBox1.SelectedItem.ToString(); } catch (NullReferenceException oEx) { MessageBox.Show("Por favor selecciona un elemento del ListBox"); MessageBox.Show(oEx.Message); } catch (Exception oEx) { MessageBox.Show("Otro error" + oEx.Message); } }

PROGRAMACIÓN


77

Este código intenta tomar el item seleccionado en un ListBox y lo despliega en el texto de un botón. Si ningún item es seleccionado en el ListBox, entonces NullReferenceException será generada, y se usa la información para indicarle al usuario que debe hacer una selección de item en el ListBox. Si algún otro tipo de excepción es generada, el código despliega el texto del mensaje de error.

Observe que, el control de excepción más específico se encuentra primero y el control de excepción más general posteriormente.

El programador debe tener cuidado en el orden de establecer el control de las excepciones.

Además la variable oEX es reutilizada en cada bloque de excepción.

Lo anterior es posible debido a que la sentencia Catch en realidad sirve como una declaración de la variable y la variable oEX tiene un alcance local sólo dentro del bloque Catch.

Finalmente, la instancia de la excepción es declarada en cada bloque Catch con alcance también dentro de su bloque.

Cuando una excepción es generada y manejada por una sentencia Catch, la ejecución del código es transferida inmediatamente al primer bloque de control de excepción Catch relevante y entonces continua fuera del bloque Try … Catch …

Algunas veces, puede ser necesario ejecutar algún tipo de limpieza antes de moverse fuera del bloque de control de excepción.

Considere el siguiente código: private void LeerArchivoTexto(string nombreArchivo) { StreamReader flujoLectura; string linea; Boolean valorB = false; listBox1.Items.Clear(); flujoLectura = new StreamReader(nombreArchivo); try { while (!valorB) { linea = flujoLectura.ReadLine(); if (linea == null) valorB = true; else listBox1.Items.Add(linea); } flujoLectura.Close(); } catch (Exception oEx) { MessageBox.Show(oEx.Message); } }

PROGRAMACIÓN


78

Este método intenta leer el contenido de un archivo de texto y colocar el resultado dentro de un ListBox, línea por línea.

Mucho del código de lectura es envuelto dentro de un controlador de excepción genérico. Si alguna excepción es encontrada en el ciclo principal, entonces la línea flujoLectura.Close( ) dentro del vecindario nunca será ejecutada.

Lo anterior significa que el flujo del archivo nunca será apropiadamente cerrado, posiblemente conduciendo a una fuga de recurso.

Afortunadamente, existe un tipo adicional de bloque disponible en el control de una excepción que específicamente permite evitar este tipo de problema.

Este nuevo bloque es llamado el bloque Finally. El código dentro de un bloque Finally siempre se ejecuta, si alguna excepción es generada o no.

Considere el siguiente código modificado respecto al anterior: private void LeerArchivoTexto(string nombreArchivo) { StreamReader flujoLectura; string linea; Boolean valorB = false; listBox1.Items.Clear(); flujoLectura = new StreamReader(nombreArchivo); try { while (!valorB) { linea = flujoLectura.ReadLine(); if (linea == null) valorB = true; else listBox1.Items.Add(linea); } } catch (Exception oEx) { MessageBox.Show(oEx.Message); } finally { flujoLectura.Close(); } }

En este caso, si alguna excepción dentro del ciclo de lectura del archivo ocurre será manejada con una ventana de mensaje, y entonces el objeto StreamReader es cerrado dentro del bloque Finally.

La sentencia de cerrar se ejecuta si el código dentro del bloque Try … Catch se ejecuta o falla.

PROGRAMACIÓN


79

Esto permite garantizar que ciertos recursos o controles son apropiadamente dispuestos cuando ya no son necesitados.

Creación y lanzamiento de excepciones.

Conforme se es más hábil en la escritura de clases, probablemente se encuentre uno con la necesidad crear excepciones propias.

Imagine escribir el código para una propiedad de cierta clase de tipo entero que tiene un cierto rango.

Si un desarrollador está usando la clase e intenta configurar la propiedad a un valor más allá del rango, es posible que se quiera informar al desarrollador que ha proporcionado un valor inválido.

La mejor forma para informarle de este problema es enviándole una excepción.

Suponga escribir la clase CtaCredito, para llevar el control de cuentas bancarias.

Se introduce el titular de la cuenta y un importe para el crédito que necesita asignar.

No obstante, dicho crédito no podrá sobrepasar el valor de 2500; así que, para controlar tal circunstancia, se crea adicionalmente, la clase CreditoException, que heredando de Exception, contendrá información en uno de sus miembros, sobre la excepción producida en cuanto al importe que se intentó asignar a la cuenta.

// esta clase contiene la información sobre un error // producido en un objeto CtaCredito class CreditoException : Exception { private readonly String mDescription; public CreditoException(String lsDescription) { mDescription = lsDescription; } public string Descripsion { get { return mDescription; } } } class CtaCredito { private string mTitular; private readonly double mDisponible; //propiedad Titular public string Titular {

PROGRAMACIÓN


80

get { return mTitular; } set { mTitular = value; } } //propiedad Credito de solo lectura public double Credito { get { return mDisponible; } } /* en este método, si se intenta asignar un importe superior al permitido, se lanza una excepción, utilizando un objeto de la clase CreditoException, heredado de Exception */ public void AsignarCredito(double ldbCredito) { if (ldbCredito > 2500 ) throw new CreditoException("Límite disponible: 2500 - se intento asignar " + Convert .ToString (ldbCredito )); else mDisponible = ldbCredito; } }

El esquema del proceso es el siguiente: cuando al método AsignarCredito( ), de un objeto CtaCredito, se intente asignar un valor no permitido, se genera un nuevo objeto CreditoException y se lanza a través de la palabra clave throw, que es la encargada de emitir las excepciones en el entorno de ejecución. El uso de estas clases sería:

Agregar un botón con el texto: Uso de Exception Personalizada. Agregar un label con el texto: Mensajes.

Evento clic del botón //crear un objeto de la nueva clase CtaCredito CtaCredito oCredito = new CtaCredito(); try {

PROGRAMACIÓN


81

//asignar valores a propiedades oCredito.Titular = "Nancy lopez"; oCredito.AsignarCredito(1000); //no hay error en la expresion anterior label1.Text = "El crédito actual de: " + oCredito.Titular + " es de: " + Convert.ToString(oCredito.Credito); //la siguiente instruccion produce un error oCredito.AsignarCredito(5000); } catch (CreditoException oExep) { //manipulador para las excepciones producidas sobre un objeto CtaCredito label1.Text = oExep.Descripsion; } finally { MessageBox.Show("El controlador de errores ha finalizado"); }

REFERENCIAS

Pérez Chávez Roger, Fernández Orquin Antonio, Pérez Suárez Airel, Hernández León Raudel ,

“Programación orientada a objetos con C#”, Universidad de ciencias informáticas, septiembre

2003

Jeff Ferguson, Brian Patterson, Jason Beres, Pierre Boutquin y Meeta Gupta, ”La biblia de C#”,

Ediciones Anaya Multimedia, 2003

Notas de materias de programación de cursos anteriores

PROGRAMACIÓN


82

ANEXOS

2. Anexo 1. Lista de cotejo de la materia.

LISTA DE COTEJO 1 GENERAL DE LA MATERIA

Conocimiento o Habilidad Acreditado

Si No

Unidad Temática: Fundamentos de Programación Orientada a Objetos

Describir los conceptos de clase y objeto Diseñar los atributos de una clase (campos y métodos) para objetos de un modelo real Describir los conceptos de abstracción, herencia, encapsulamiento y polimorfismo

Unidad Temática : Ambiente de desarrollo de la POO

Operar las funciones de crear, abrir, guardar, ejecutar y depurar una aplicación Windows en Visual Studio 2008 para el lenguaje de programación C#

Unidad Temática: Programación Orientada a Objetos

Codificar programas que utilicen una clase para mostrar datos en una aplicación Windows Codificar programas que utilicen una clase para implementar un proceso de un objeto a través de métodos

Codificar programas que utilicen una clase para implementar un proceso de un objeto utilizando estructuras de control (selección y repetición)

Codificar programas que ilustren el encapsulamiento de información de una clase por medio de los modificadores de acceso

Codificar programas que ilustren la herencia de campos al menos entre dos clases Codificar programas que implementen el polimorfismo por herencia.

Unidad Temática: Arreglos

Codificar programas que manipulen arreglos de una y dos dimensiones, utilizando buenas prácticas de programación, es decir, usar clases con sus miembros privados

Unidad Temática: Manejo de excepciones

Codificar programas que controlen excepciones generadas en tiempo de ejecución Codificar programas que ilustren la creación, el lanzar y manejar excepciones personalizadas.

PROGRAMACIÓN


83

Anexo 2 Rúbrica para portafolio del alumno

Rúbrica para Portafolio de Evidencias

Nombre del maestro/a: _________________________________

Nombre del Alumno: _______________________________________

Indicador o variable Descripción Porcentaje

Portada

La portada deberá tener cuando menos el nombre de la universidad, el logo, el nombre de la

materia, la leyenda "Portafolio de evidencias", nombre del alumno, número de registro, grupo y

nombre del profesor.

10%

índice El índice deberá tener los nombres de las

prácticas y la página 10%

Introducción

Deberá contener una redacción explicando los temas vistos en las prácticas, anécdotas o

experiencias vividas a lo largo del cuatrimestre, etc.

10%

Presentación y limpieza

Ortografía sin errores, redacción clara, coherente. Prácticas ordenadas y con limpieza

10%

Contenido

El orden que deberá tener el portafolio por CADA práctica será: 1. Redacción del ejercicio 2. Formulario(s) 3. Código de la(s) clase(s) 4.

Código del formulario(s)

60%

Total 100%

PROGRAMACIÓN


84

Anexo 3. Rúbrica para exposiciones

Nombre del Equipo: _______________________________________

CATEGORIA 100 75 50 25

Totales

Nombre del maestro/a: _________________________________

Rúbrica para Exposiciones

Habla Claramente

Postura del Cuerpo y

Contacto Visual

Contenido

LÍmite-Tiempo

Volumen

PROGRAMACIÓN


85

Anexo 4. Rúbrica para evaluar el “Ser”

Nombre del Maestro/a: ________________________________________

Nombre del Alumno: ________________________________________

CATEGORIA 100 75 50 25

1. Analítico

2. Coherente

3. Sistemático

4. Crítico

5. Honesto

6. Responsable

TOTA LES 0 0 0 0

Rúbrica SER

DEPARTAMENTO DE DISEÑO E IMAGEN - … · PROGRAMACIÓN TECNOLOGÍAS DE LA INFORMACIÓN Y...

Documents

Transcript of DEPARTAMENTO DE DISEÑO E IMAGEN - … · PROGRAMACIÓN TECNOLOGÍAS DE LA INFORMACIÓN Y...