tabla de contenidos -...

Introducción a la Programación en C#

www.educacionIT.com.ar | Tel. (54) (011) 5032-2650 Página 1 Lavalle 648 – 4 to Piso – Capital Federal Copyright 2005 educacionIT. Todos los derechos están reservados.

Tabla de contenidos

1. INTRODUCCIÓN A .NET...................................................................................................................................4 1.1. OBJETIVOS ........................................................................................................................................................ 4

1.1.1. Mapa del Curso........................................................................................................................................4 1.2. QUE ES .NET .................................................................................................................................................... 5 1.3. QUE ES C# (SHARP) .......................................................................................................................................... 6

2. ENTORNO DE DESARROLLO .........................................................................................................................7 2.1. OBJETIVOS ........................................................................................................................................................ 7

2.1.1. Mapa del Curso........................................................................................................................................7 2.2. EL COMPILADOR ............................................................................................................................................... 8 2.3. LOS ARCHIVOS FUENTES (“*.CS”)..................................................................................................................... 8 2.4. COMO ESTÁ FORMADO EL FRAMEWORK .NET ................................................................................................. 9

3. SINTAXIS Y SEMÁNTICA DE C# ..................................................................................................................11 3.1. OBJETIVOS ......................................................................................................................................................11

3.1.1. Mapa del Curso......................................................................................................................................11 3.2. VARIABLES Y CONSTANTES ............................................................................................................................12

3.2.1. Que es una variable ...............................................................................................................................12 3.2.2. Que es una constante .............................................................................................................................13

3.3. TIPOS DE DATO ...............................................................................................................................................15 3.3.1. Introducción ...........................................................................................................................................15 3.3.2. Tipos de datos básicos ...........................................................................................................................18

3.4. CONSTRUCCIONES DEL LENGUAJE..................................................................................................................19 3.4.1. Introduccion ...........................................................................................................................................19 3.4.2. Sentencias...............................................................................................................................................19 3.4.3. Bloques de código ..................................................................................................................................19

3.5. OPERADORES ..................................................................................................................................................21 3.5.1. Que es un operador................................................................................................................................21 3.5.2. Que es un Operador?.............................................................................................................................22 3.5.3. Operaciones aritméticas ........................................................................................................................22 3.5.4. Operaciones lógicas...............................................................................................................................22 3.5.5. Operaciones relacionales ......................................................................................................................23 3.5.6. Operaciones de asignación....................................................................................................................23 3.5.7. Operaciones con cadenas ......................................................................................................................24 3.5.8. Operador condicional............................................................................................................................24

3.6. INSTRUCCIONES DE CONTROL DE FLUJO .........................................................................................................26 3.6.1. Introduccion ...........................................................................................................................................26 3.6.2. Instrucción if...else.................................................................................................................................27 3.6.3. Instrucción switch ..................................................................................................................................28 3.6.4. Instrucción while....................................................................................................................................30 3.6.5. Instrucción do...while.............................................................................................................................32 3.6.6. Instrucción for........................................................................................................................................33 3.6.7. Instrucción break ...................................................................................................................................35 3.6.8. Instrucción continue...............................................................................................................................35 3.6.9. Instrucción return ..................................................................................................................................36 3.6.10. Instrucción goto ...................................................................................................................................37

3.7. COMENTARIOS ................................................................................................................................................39 3.7.1. Que es un comentario ............................................................................................................................39 3.7.2. Utilización de comentarios ....................................................................................................................39



4. ARREGLOS .........................................................................................................................................................41 4.1. OBJETIVOS ......................................................................................................................................................41

4.1.1. Mapa del Curso......................................................................................................................................41 4.1.2. Descripción ............................................................................................................................................42 4.1.3. Metas ......................................................................................................................................................42

4.2. INTRODUCCION ...............................................................................................................................................43 4.3. ARREGLOS DE UNA DIMENSION ......................................................................................................................43 4.4. OPERACIONES DE ACCESO A ARREGLOS .........................................................................................................44

5. INTRODUCCIÓN A LA PROGRAMACIÓN VISUAL ................................................................................45 5.1. OBJETIVOS ......................................................................................................................................................45

5.1.1. Mapa del Curso......................................................................................................................................45 5.2. QUE ES LA PROGRAMACIÓN VISUAL ...............................................................................................................46 5.3. LOS WINDOWS FORMS ...................................................................................................................................46 5.4. COMPONENTES ...............................................................................................................................................47 5.5. PROPIEDADES .................................................................................................................................................47 5.6. EVENTOS.........................................................................................................................................................48

6. LABORATORIOS...............................................................................................................................................49 6.1. OBJETIVOS ......................................................................................................................................................49

6.1.1. Mapa del Curso......................................................................................................................................49 6.2. RECOMENDACIONES .......................................................................................................................................50 6.3. LAB 1 - UTILIZACIÓN DE LA ESTRUCTURA DE CONTROL IF............................................................................50

6.3.1. Ejercicio 1 ..............................................................................................................................................50 6.3.2. Ejercicio 2 ..............................................................................................................................................50 6.3.3. Ejercicio 3 ..............................................................................................................................................51

6.4. LAB 2 - UTILIZACIÓN DE LA ESTRUCTURA DE CONTROL WHILE ..................................................................52 6.4.1. Ejercicio 1 ..............................................................................................................................................52 6.4.2. Ejercicio 2 ..............................................................................................................................................52 6.4.3. Ejercicio 3 ..............................................................................................................................................52 6.4.4. Ejercicio 4 ..............................................................................................................................................52 6.4.5. Ejercicio 5 ..............................................................................................................................................52 6.4.6. Ejercicio 6 ..............................................................................................................................................52 6.4.7. Ejercicio 7 ..............................................................................................................................................53 6.4.8. Ejercicio 8 – BONUS!............................................................................................................................53 6.4.9. Ejercicio 9 – BONUS!............................................................................................................................53

6.5. LAB 3 - UTILIZACIÓN DE LA ESTRUCTURA DE CONTROL FOR .......................................................................54 6.5.1. Ejercicio 1 ..............................................................................................................................................54 6.5.2. Ejercicio 2 ..............................................................................................................................................54 6.5.3. Ejercicio 3 ..............................................................................................................................................54 6.5.4. Ejercicio 4 ..............................................................................................................................................54 6.5.5. Ejercicio 5 ..............................................................................................................................................54 6.5.6. Ejercicio 6 ..............................................................................................................................................54 6.5.7. Ejercicio 7 ..............................................................................................................................................55 6.5.8. Ejercicio 8 ..............................................................................................................................................55 6.5.9. Ejercicio 9 ..............................................................................................................................................55 6.5.10. Ejercicio 10 – BONUS!........................................................................................................................56 6.5.11. Ejercicio 11 – BONUS!........................................................................................................................56

6.6. LAB 4 - UTILIZACIÓN DE VECTORES ..............................................................................................................57 6.6.1. Ejercicio 1 ..............................................................................................................................................57 6.6.2. Ejercicio 2 ..............................................................................................................................................57 6.6.3. Ejercicio 3 – BONUS!............................................................................................................................58

6.7. LAB 5 – INTRODUCCIÓN A INTERFAZ GRAFICA DE USUARIO.........................................................................59 6.7.1. Ejercicio 1 ..............................................................................................................................................59 6.7.2. Ejercicio 2 ..............................................................................................................................................61



7. INTRODUCCIÓN AL PARADIGMA DE OBJETOS ...................................................................................62 7.1. OBJETIVOS ......................................................................................................................................................62

7.1.1. Mapa del Curso......................................................................................................................................62 7.1.2. Descripción ............................................................................................................................................63 7.1.3. Metas ......................................................................................................................................................63

7.2. ACERCA DE ESTE CAPITULO - IMPORTANTE .............................................................................................64 7.3. CONCEPTOS ....................................................................................................................................................64

7.3.1. Introducción ...........................................................................................................................................64 7.3.2. Por que Objetos? ...................................................................................................................................65 7.3.3. Objetos como Tipos de Datos ................................................................................................................66 7.3.4. Conceptos básicos (clase, objeto, encapsulación)................................................................................66 7.3.5. Propiedades (variables).........................................................................................................................67 7.3.6. Métodos (funciones)...............................................................................................................................68

7.4. HERENCIA .......................................................................................................................................................69 7.4.1. Introducción ...........................................................................................................................................69 7.4.2. Características .......................................................................................................................................70

7.5. VISIBILIDAD....................................................................................................................................................71 7.5.1. Encapsulamiento....................................................................................................................................71 7.5.2. Miembros Públicos, Privados y Protegidos..........................................................................................71



1. Introducción a .NET

1.1. Objetivos

1.1.1. Mapa del Curso


2. Entorno de Desarrollo

3. Sintaxis y Semántica de C#

4. Arreglos

5. Introducción a la Programación Visual

6. Laboratorio

7. Introducción al Paradigma de Objetos



1.2. Que es .NET Realmente, el concepto de .NET (“dotNET” o “punto NET”) es demasiado amplio, así que

lo resumiremos en pocas palabras : Es una plataforma de desarrollo multi-lenguaje, que

está pensada para correr sobre distintos entornos operativos, y que pretende unificar los

distintos paradigmas de la programación (escritorio, cliente-servidor, WEB, etc.) en un

mismo ambiente de trabajo.

.NET está formado por cuatro componentes principales, a saber :

1. El CLR (Common Language Runtime). Es el entorno de ejecución para las

aplicaciones que pueden haber sido escritas en alguno de los diferentes

lenguajes que cumplen con los requisitos sintácticos y semánticos de .NET .-

2. El MSIL (Microsoft Intermediate Language). Representa el código objeto al que

es transformado el código fuente escrito en cualquiera de los lenguajes

aceptados por .NET. Estos , que luego va a ser compilado a nativo por el

compilador JIT (Just In Time) que provee la CLR en tiempo de ejecución.

3. La biblioteca de clases .NET Framework . Es una extensísima colección de clases

base, para todos los propósitos imaginables, que es aceptada y usada por todos

los lenguajes e IDEs que corren sobre .NET

4. El entorno de programación (IDE) . Es el ambiente de trabajo propiamente dicho

que puede constar de herramientas de de diseño, editores, debugeadores y

diversos asistentes, para que el programador pueda diseñar, escribir y probar

sus aplicaciones. Existen varios (Sharp Develop, RAD Studio, etc.), pero

nosotros en este curso y posteriores usaremos el propio de Microsoft : Visual

Studio.



1.3. Que es C# (Sharp)

C# (se pronuncia “se sharp”), es un lenguaje que pretende reunir lo mejor de los

diversos lenguajes que compilan a nativo(C/C++, Object Pascal, ADA, etc.), y de

aquellos interpretados (Java, Perl, etc.) en uno solo, y que además, pueda correr sobre

diversos sistemas operativos. Al respecto, existe un proyecto paralelo al desarrollo de

.NET de Microsoft, que se denomina “Mono” que transportó el lenguaje C# y gran parte

del framework .NET a Unix/Linus/Solaris.

C# toma gran parte de la sintaxis de C/C++, y muchas de las características de Eiffel

(un lenguaje de laboratorio que ideó Bertrand Meyer), poniendo a disposición del

desarrollador un potente lenguaje 100% orientado a objetos. Si bien el CLR, acepta

muchos otros lenguajes, el framework .NET está 100% escrito en C# ; por lo tanto ES

EL LENGUAJE BASE PARA .NET.




2.1. Objetivos





4. Arreglos


6. Laboratorio




2.2. El compilador Cuando se instala en cada computadora el SDK de Microsoft .NET, se crea el directorio

c:\WINDOWS\Microsoft.NET\Framework\v2.0.50727\ , dentro del cual se alojan los

compiladores de línea. En nuestro caso el compilador para C# es “csc.exe” que puede

ser invocado desde la línea de comandos (Inicio|Ejecutar|cmd). Cuando se invoca al

compilador pasándole como parámetro un nombre de archivo cualquiera con la

extensión “.cs”, convierte a este en un archivo *.exe (ejecutable), pero este NO es un

ejecutable NATIVO (es decir autónomo), sino que necesita del framework .NET con el

CLR instalado en la misma maquina, para poder correr.

2.3. Los archivos fuentes (“*.cs”) Los archivos de “código fuente” no son mas que archivos de texto plano, que contienen

las líneas del programa en C#, con las instrucciones que cada programador quiere que

la aplicación lleve a cabo. Deben cumplir con las normas sintácticas del lenguaje, caso

contrario, el compilador detecta los errores y no genera el ejecutable.

Veamos un ejemplo :



/*

* Nombre de archivo : saludo.cs

* Autor : Claudio Zwitkovits

* /

// Clase de inicio del programa

public class Hola

{

// “Main” indica la ejecucion del programa

public static void Main()

{

// escribir en la consola

System.Console.WriteLine(“Hola a todos !!!”) ;

}

}

Para compilar este programa, solo hay que ir a la línea de comandos y tipear :

csc saludo.cs y esto generará el ejecutable “saludo.exe” que mostrará en la consola

el mensaje “Hola a todos !!!”

2.4. Como está formado el framework .NET

La arquitectura del framework .NET, es la implementación del CLI (Common Language

Runtime) por parte de Microsoft para los lenguajes C#, Visual Basic, J#, ASP, y Jscript,

mas varios paquetes que dan soporte a interfaces de usuario, acceso a datos , XML y

WEB agrupadas en una Librería de Clase Base (BCL) que está formada por cientos de

tipos de datos. Esta librería está escrita en MSIL, por lo que puede usarse desde

cualquier lenguaje cuyo compilador genere MSIL. A través de las clases suministradas

en ella es posible desarrollar cualquier tipo de aplicación, desde las tradicionales

aplicaciones de ventanas, consola o servicio de Windows NT hasta los novedosos

servicios Web y páginas ASP.NET..



Dada su amplitud ha sido necesario organizar las clases en ella incluida en espacios de

nombres que agrupen clases con funcionalidades similares. Por ejemplo, los espacios de

nombres más usados son:

Espacio de nombres Utilidad de los tipos de datos que contiene

System Tipos muy frecuentemente usados, como los los tipos básicos, tablas, excepciones, fechas, números aleatorios, recolector de basura, entrada/salida en consola, etc.

System.Collections Colecciones de datos de uso común como pilas, colas, listas, diccionarios, etc.

System.Data Manipulación de bases de datos. Forman la denominada arquitectura ADO.NET.

System.IO Manipulación de archivos y otros flujos de datos. System.Net Realización de comunicaciones en red. System.Reflection Acceso a los metadatos que acompañan a los módulos de

código. System.Runtime.Remoting Acceso a objetos remotos. System.Security Acceso a la política de seguridad en que se basa el CLR. System.Threading Manipulación de hilos de ejecución. System.Web.UI.WebControls Creación de interfaces de usuario basadas en ventanas

para aplicaciones Web. System.Windows.Forms Creación de interfaces de usuario basadas en ventanas

para aplicaciones estándar. System.XML Acceso a datos en formato XML.




3.1. Objetivos





4. Arreglos


6. Laboratorio




3.2. Variables y constantes

3.2.1. Que es una variable

Una variable reperesenta una posición en memoria en el que se puede almacenar un

valor de un determinado tipo al que se le da un cierto nombre. Para poderla utilizar sólo

hay que definirla indicando cual será su nombre y cual será el tipo de datos que podrá

almacenar, lo que se hace siguiendo la siguiente sintaxis:

<tipoVariable> <nombreVariable>;

Una variable puede ser definida dentro de una definición de clase, en cuyo caso se la

denominaría campo. También puede definirse como un variable local a un método,

que es una variable definida dentro del código del método a la que sólo puede accederse

desde dentro de dicho código. Otra posibilidad es definirla como parámetro de un

método, que son variables que almacenan los valores de llamada al método y que, al

igual que las variables locales, sólo puede ser accedidas desde código ubicado dentro del

método. El siguiente ejemplo muestra como definir variables de todos estos casos:

Class GestorClientesApp{

public static void Main(){

string Nombre; // Declaración de la variable nombre, que es de tipo string

Console.Write("¿Cómo se llama el cliente? ");

Nombre = Console.ReadLine();

Console.WriteLine("Mi cliente se llama {0}", Nombre);

}

}



En este sencillo programa, el compilador reservará memoria para la variable Nombre.

En la ejecución del mismo primero preguntaría por el nombre del cliente y, después de

haberlo escrito nosotros, nos diría cómo se llama. Algo así (“Mi cliente se llama Antonio”

es lo que hemos escrito nosotros durante la ejecución del programa):

¿Cómo se llama el cliente? Antonio

Mi cliente se llama Antonio

También podemos inicializar el valor de una variable en el momento de declararla, sin

que esto suponga un obstáculo para poder modificarlo después:

int num=10;

3.2.2. Que es una constante

De otro lado tenemos las constantes también hacen que el compilador reserve un

espacio de memoria para almacenar un dato, pero en este caso ese dato es siempre el

mismo y no se puede modificar durante la ejecución del programa.Un ejemplo claro

sería almacenar el valor de pi en una constante para no tener que poner el número en

todas las partes donde lo podamos necesitar. Se declaran de un modo similar a las

variables, basta con añadir la palabra const en la declaración.

Ejemplo:



using System;

namespace Circunferencia1{

class CircunferenciaApp{

public static void Main(){

const double PI=3.1415926; // Esto es una constante

double Radio=4; // Esto es una variable

Console.WriteLine("El perímetro de una circunferencia de radio {0} es {1}", Radio,

2*PI*Radio);

Console.WriteLine("El área de un círculo de radio {0} es {1}", Radio,

PI*Math.Pow(Radio,2));

}

}

}

La salida en la consola de este programa sería la siguente:

El perímetro de una circunferencia de radio 4 es 25,1327408

El área de un círculo de radio 4 es 50,2654816



3.3. Tipos de dato

3.3.1. Introducción El sistema de tipos de datos suele ser la parte más importante de cualquier lenguaje

de programación. El uso correcto de los distintos tipos de datos es algo fundamental

para que una aplicación sea eficiente con el menor consumo posible de recursos.

Actualmente, muchos de los lenguajes orientados a objetos proporcionan los tipos

agrupándolos de dos formas: los tipos primitivos del lenguaje, como números o

cadenas, y el resto de tipos creados a partir de clases. Esto genera muchas dificultades,

ya que los tipos primitivos no son y no pueden tratarse como objetos, es decir, no se

pueden derivar y no tienen nada que ver unos con otros. Sin embargo, en C# (más

propiamente en .NET Framework) contamos con un sistema de tipos unificado, el CTS

(Common Type System), que proporciona todos los tipos de datos como clases

derivadas de la clase de base System.Object (incluso los literales pueden tratarse como

objetos). Sin embargo, el hacer que todos los datos que ha de manejar un programa

sean objetos puede provocar que baje el rendimiento de la aplicación. Para solventar

este problema, .NET Framework divide los tipos en dos grandes grupos: los tipos valor

y los tipos referencia.

Cuando se declarara variable que es de un tipo valor se está reservando un espacio de

memoria en la pila (stack) para que almacene los datos reales que contiene esta

variable. Por ejemplo en la declaración:

int num =10;

Se está reservando un espacio de 32 bits en la pila (una variable de tipo int es un objeto

de la clase System.Int32), en los que se almacena el 10, que es lo que vale la variable.

Esto hace que la variable “num” se pueda tratar directamente como si fuera de un tipo

primitivo en lugar de un objeto, mejorando notablemente el rendimento. Como

consecuencia, una variable de tipo valor nunca puede contener null (referencia nula).

Durante la ejecución de un programa, la memoria se distribuye en tres bloques: la pila,

(stack), el montón (heap) y la memoria global. La pila es una estructura en la que los

elementos se van apilando, de modo que el último elemento en entrar en la pila es el

primero en salir (estructura LIFO, o sea, Last In First Out). El montón es un bloque de



memoria contiguo en el cual la memoria no se reserva en un orden determinado como

en la pila, sino que se va reservando aleatoriamente según se va necesitando. Cuando el

programa requiere un bloque del montón, este se sustrae y se retorna un puntero

(varaible que contiene direcciones de memoria) al principio del mismo. La memoria

global es el resto de memoria de la máquina que no está asignada ni a la pila ni al

montón, y es donde se colocan el método main y las funciones que éste invocará.

En el caso de una variable que sea de un tipo referencia, lo que se reserva es un

espacio de memoria en el montón para almacenar el valor, pero lo que se devuelve

internamente es una referencia al objeto, es decir, un puntero a la dirección de memoria

que se ha reservado. En este caso, una variable de un tipo referencia sí puede contener

una referncia nula (null).

¿Porqué esta “separación” de tipos y posiciones de memoria?, porque una variable de un

tipo valor funcionará como un tipo primitivo siempre que sea necesario, pero podrá

funcionar también como un tipo referencia, es decir como un objeto, cuando se necesite

que sea un objeto. Hacer esto en otros lenguajes, como Java, es imposible, dado que los

tipos primitivos en Java no son objetos. Mas adelante ampliaremos estos conceptos.

Los tipos de datos básicos son ciertos tipos de datos tan comúnmente utilizados en la

escritura de aplicaciones que en C# se ha incluido una sintaxis especial para tratarlos.

Por ejemplo, para representar números enteros de 32 bits con signo se utiliza el tipo de

dato System.Int32 definido en la BCL, aunque a la hora de crear un objeto a de este tipo

que represente el valor 2 se usa la siguiente sintaxis:

System.Int32 a = 2;

Dado lo frecuente que es el uso de este tipo también se ha predefinido en C# el alias int

para el mismo, por lo que la definición de variable anterior queda así de compacta:

int a = 2;

System.Int32 no es el único tipo de dato básico incluido en C#. En el espacio de nombres

System se han incluido todos estos:

Tipo Descripción Bits Rango de valores Alias

SByte Bytes con signo 8 [-128, 127] Sbyte

Byte Bytes sin signo 8 [0, 255] byte

Int16 Enteros cortos con signo 16 [-32.768, 32.767] short

UInt16 Enteros cortos sin signo 16 [0, 65.535] ushort

Int32 Enteros normales 32

[-2.147.483.648, 2.147.483.647]

Int

UInt32 Enteros normales sin signo 32 [0, 4.294.967.295] uint



Int64 Enteros largos 64

[-9.223.372.036.854.775.808, 9.223.372.036.854.775.807]

Long

UInt64 Enteros largos sin signo 64

[0-18.446.744.073.709.551.615]

Ulong

Single Reales con 7 dígitos de precisión 32 [1,5×10-45 - 3,4×1038] Float

Double Reales de 15-16 dígitos de precisión 64 [5,0×10-324 - 1,7×10308] double

Decimal Reales de 28-29 dígitos de precisión 128 [1,0×10-28 - 7,9×1028] decimal

Boolean Valores lógicos 32 true, false Bool

Char Caracteres Unicode 16 [‘\u0000’, ‘\uFFFF’] Char

String Cadenas de caracteres Variable El permitido por la memoria String

Object Cualquier objeto Variable Cualquier objeto Object



3.3.2. Tipos de datos básicos Pese a su sintaxis especial, en C# los tipos básicos son tipos del mismo nivel que

cualquier otro tipo del lenguaje. Es decir, heredan de System.Object y pueden ser

tratados como objetos de dicha clase por cualquier método que espere un

System.Object, lo que es muy útil para el diseño de rutinas genéricas que admitan

parámetros de cualquier tipo y es una ventaja importante de C# frente a lenguajes

similares como Java donde los tipos básicos no son considerados objetos.

El valor que por defecto se le da a los campos de tipos básicos consiste en poner a cero

todo el área de memoria que ocupen. Esto se traduce en que los campos de tipos

básicos numéricos se inicializan por defecto con el valor 0, los de tipo bool lo hacen con

false, los de tipo char con ‘\u0000’ (carácter nulo), y los de tipo string y object con null.

Para los casos de los tipos de variables numéricas se puede especificar (durante la

asignación de un valor), el tipo de dato numérico de ese valor mediante el uso de

sufijos

Los sufijos para los valores literales de los distintos tipos de datos numéricos son los

siguientes:

• L (mayúscula o minúscula): long ó ulong, por este orden;

• U (mayúscula o minúscula): int ó uint, por este orden;

• UL ó LU (independientemente de que esté en mayúsuculas o minúsculas):

ulong;

• F (mayúscula o minúscula): single;

• D (mayúscula o minúscula): double;

• M (mayúscula o minúscula): decimal;



3.4. Construcciones del lenguaje

3.4.1. Introduccion Cuando se desarrolla un programa, luego de declarar las variables, constantes, clases,

etc., se debe especificar que hacer con/entre estos elementos, para ello iremos

escribiendo : líneas (para C# cada línea de código termina con un “;” – punto y coma).

3.4.2. Sentencias Una sentencia es una orden que se le da al programa para realizar una tarea específica,

esta puede ser: mostrar un mensaje en la pantalla, declarar una variable (para reservar

espacio en memoria), inicializarla, llamar a un método, etc. Para C# cada sentencia

termina con un “;” (punto y coma) . Normalmente, las sentencias se ponen unas debajo

de otras, aunque sentencias cortas pueden colocarse en una misma línea. He aquí

algunos ejemplos de sentencias :

int x=10;

usingSystem.IO;

Console.WriteLine("Hola Mundo");

En C#, los caracteres espacio en blanco se pueden emplear libremente.Es muy

importante para la legibilidad de un programa la colocación de unas líneas debajo de

otras empleando tabuladores. El editor del IDE nos ayudará plenamente en esta tarea

sin apenas percibirlo

3.4.3. Bloques de código Un bloque de código es un grupo de sentencias que se comportan como una unidad. Se

los usa para indicar el comienzo y fin de un conjunto de líneas (sentancias) de código.

Por lo general, se los usa para delimitar namespaces, clases, estructuras, enumerados y



métodos. Un bloque de código está limitado por las llaves de apertura “{“ y cierre “}”.

He aquí un ejemplo de uso :

Static void main() {

Linea1;

Linea2;

}

Cada una de esas líneas, implica una expresión que el compilador de C# analizará,

verificando que su sintaxis sea la correcta. Para ello disponemos de los operadores.



3.5. Operadores

3.5.1. Que es un operador Un operador en C# es un símbolo formado por uno o más caracteres que permite

realizar una determinada operación entre uno o más datos y produce un resultado.

A continuación se describen cuáles son los operadores incluidos en el lenguaje

clasificados según el tipo de operaciones que permiten realizar, aunque hay que tener

en cuenta que C# permite la redefinición del significado de la mayoría de los operadores

según el tipo de dato sobre el que se apliquen, por lo que lo que aquí se cuenta se

corresponde con los usos más comunes de los mismos:

• Un operador es una expresión que produce otro valor (así como las

funciones o construcciones que devuelven un valor).

• Existen operadores de comparación, de negación o de incremento y

decremento.

• Las operaciones matemáticas se comportan de igual manera en PHP. Las

operaciones * y / tienen precedencia sobre la suma y la resta y se pueden

utilizar paréntesis para expresiones mas complejas.

• Un operador es un símbolo especial que indica al compilador que debe

efectuar una operación matemática o lógica.

• En todo lenguaje de programación existen un conjunto de operadores que

permiten realizar operaciones con los datos. Nos referimos a operaciones

aritméticas, comparaciones, operaciones lógicas y otras operaciones (por

ejemplo, concatenación de cadenas, operaciones algebraicas entre valores

números, etc.).



3.5.2. Que es un Operador? • Un operador es un símbolo especial que indica al compilador que debe

efectuar una operación matemática o lógica.

• En todo lenguaje de programación existen un conjunto de operadores que

permiten realizar operaciones con los datos. Nos referimos a operaciones

aritméticas, comparaciones, operaciones lógicas y otras operaciones (por

ejemplo, concatenación de cadenas, operaciones algebraicas entre valores

números, etc.).

3.5.3. Operaciones aritméticas Los operadores aritméticos incluidos en C# son los típicos de suma (+), resta (-

), producto (*), división (/) y módulo (%) También se incluyen operadores de

“menos unario” (–) y “más unario” (+).

3.5.4. Operaciones lógicas Se incluyen operadores que permiten realizar las operaciones lógicas típicas:

“and” (&& y &), “or” (|| y |), “not” (!) y “xor” (^)

Los operadores && y || se diferencia de & y | en que los primeros realizan

evaluación perezosa y los segundos no. La evaluación perezosa consiste en

que si el resultado de evaluar el primer operando permite deducir el resultado

de la operación, entonces no se evalúa el segundo y se devuelve dicho

resultado directamente, mientras que la evaluación no perezosa consiste en

evaluar siempre ambos operandos. Es decir, si el primer operando de una

operación && es falso se devuelve false directamente, sin evaluar el segundo;

y si el primer operando de una || es cierto se devuelve true directamente, sin

evaluar el otro.



3.5.5. Operaciones relacionales Se han incluido los tradicionales operadores de igualdad (==), desigualdad (!=),

“mayor que” (>), “menor que” (<), “mayor o igual que” (>=) y “menor o igual

que” (<=)

3.5.6. Operaciones de asignación Para realizar asignaciones se usa en C# el operador =, operador que además

de realizar la asignación que se le solicita devuelve el valor asignado. Por

ejemplo, la expresión a = b asigna a la variable a el valor de la variable b y

devuelve dicho valor, mientras que la expresión c = a = b asigna a las variables

c y a el valor de b (el operador = es asociativo por la derecha)

También se han incluido operadores de asignación compuestos que permiten

ahorrar tecleo a la hora de realizar asignaciones tan comunes como:

temperatura = temperatura + 15; // Sin usar asignación compuesta

temperatura += 15; // Usando asignación compuesta

Las dos líneas anteriores son equivalentes, pues el operador compuesto +=

asigna a su primer operando el valor que tenía más el de su segundo

operando (o sea, le suma el segundo operando) Como se ve, permite

compactar bastante el código.

Aparte del operador de asignación compuesto +=, también se ofrecen

operadores de asignación compuestos para la mayoría de los operadores

binarios ya vistos. Estos son: +=, -=, *=, /=, %=, &=, |=, ^=, <<= y >>=. Nótese que

no hay versiones compuestas para los operadores binarios && y ||.

Otros dos operadores de asignación incluidos son los de incremento(++) y

decremento (--) Estos operadores permiten, respectivamente, aumentar y

disminuir en una unidad el valor de la variable sobre el que se aplican. Así,

estas líneas de código son equivalentes:

temperatura = temperatura + 1; //Sin asignación compuesta ni incremento

temperatura += 1; //Usando asignación compuesta



temperatura++; //Usando incremento

Si el operador ++ se coloca tras el nombre de la variable (como en el ejemplo)

devuelve el valor de la variable antes de incrementarla, mientras que si se

coloca antes, devuelve el valor de ésta tras incrementarla; y lo mismo ocurre

con el operador --. Por ejemplo:

c = b++; // Se asigna a c el valor de b y luego se incrementa b

c = ++b; // Se incrementa el valor de b y luego se asigna a c

La ventaja de usar los operadores ++ y -- es que en muchas máquinas son más

eficientes que el resto de formas de realizar sumas o restas de una unidad,

pues el compilador puede traducirlos en una única instrucción en código

máquina1.

3.5.7. Operaciones con cadenas Para realizar operaciones de concatenación de cadenas se puede usar el mismo

operador que para realizar sumas, ya que en C# se ha redefinido su significado

para que cuando se aplique entre operandos que sean cadenas o que sean una

cadena y un carácter lo que haga sea concatenarlos. Por ejemplo, ″Hola″+″

mundo″ devuelve ″Hola mundo″, y ″Hola mund″ + ′o′ también.

3.5.8. Operador condicional Es el único operador incluido en C# que toma 3 operandos, y se usa así:

<condición> ? <expresión1> : <expresión2>

El significado del operando es el siguiente: se evalúa <condición> Si es cierta se

devuelve el resultado de evaluar <expresión1>, y si es falsa se devuelve el

resultado de evaluar <condición2>. Un ejemplo de su uso es:

b = (a>0)? a : 0; // Suponemos a y b de tipos enteros



En este ejemplo, si el valor de la variable a es superior a 0 se asignará a b el

valor de a, mientras que en caso contrario el valor que se le asignará será 0.

Hay que tener en cuenta que este operador es asociativo por la derecha, por lo

que una expresión como a?b:c?d:e es equivalente a a?b:(c?d:e)

No hay que confundir este operador con la instrucción condicional if que se

tratará en el Tema 8:Instrucciones, pues aunque su utilidad es similar al de

ésta, ? devuelve un valor e if no.



3.6. Instrucciones de control de flujo

3.6.1. Introduccion Hemos visto hasta ahora que los programas van ejecutando las líneas de código con

orden. Sin embargo, hay muchas situaciones en las que es preciso alterar ese orden, o

bien puede ocurrir que sea necesario que se efectúen una serie de operaciones que

pueden ser distintas en otras circunstancias. Por ejemplo, si el programa pide una clave

de acceso, deberá continuar con la ejecución normal en caso de que la clave introducida

por el usuario sea correcta, y deberá salir del mismo en caso contrario. Pues bien: para

todas estas cuestiones que, por otra parte, son muy frecuentes, tenemos las

Instrucciones de control de flujo.

En C# contamos con varios tipos de estas instrucciones :

• Las instrucciones condicionales (if…else, switch) son instrucciones que

permiten ejecutar bloques de instrucciones sólo si se da una determinada

condición.

• Las instrucciones iterativas (while, do, for, foreach) son instrucciones que

permiten ejecutar repetidas veces una instrucción o un bloque de instrucciones

mientras se cumpla una condición. Es decir, permiten definir bucles donde

ciertas instrucciones se ejecuten varias veces.

• Las instrucciones de salto (break, continue, return, goto) permiten variar el

orden normal en que se ejecutan las instrucciones de un programa, que consiste

en ejecutarlas una tras otra en el mismo orden en que se hubiesen escrito en el

fuente.



3.6.2. Instrucción if...else La instrucción if permite ejecutar ciertas instrucciones sólo si de da una determinada

condición. Su sintaxis de uso es la sintaxis:

if (<condición>) {

<instruccionesIf>

}

Else {

<instruccionesElse>

}

El significado de esta instrucción es el siguiente: se evalúa la expresión <condición>, que

ha de devolver un valor lógico. Si es cierta (devuelve true) se ejecutan las

<instruccionesIf>, y si es falsa (false) se ejecutan las <instruccionesElse> La rama else es

opcional, y si se omite y la condición es falsa se seguiría ejecutando a partir de la

instrucción siguiente al if. En realidad, tanto <instruccionesIf> como <instruccionesElse>

pueden ser una única instrucción o un bloque de instrucciones.

Un ejemplo de aplicación de esta instrucción es esta variante del HolaMundo:



using System;

class HolaMundoIf

{

public static void Main(String[] args)

{

if (args.Length > 0) {

Console.WriteLine(“Hola {0}!”, args[0]) ;

}

Else {

Console.WriteLine(“Hola mundo!”);

}

}

}

Si ejecutamos este programa sin ningún argumento veremos que el mensaje que se

muestra es ¡Hola Mundo!, mientras que si lo ejecutamos con algún argumento se

mostrará un mensaje de bienvenida personalizado con el primer argumento indicado.

3.6.3. Instrucción switch La instrucción switch permite ejecutar unos u otros bloques de instrucciones según el

valor de una cierta expresión. Su estructura es:

switch (<expresión>)

{

case valor1: Sentencias1; <siguiente accion>;



default: Sentencias4;

}



El significado de esta instrucción es el siguiente: se evalúa <expresión>. Si su valor es

<valor1> se ejecuta el <bloque1>, si es <valor2> se ejecuta <bloque2>, y así para el resto de

valores especificados. Si no es igual a ninguno de esos valores y se incluye la rama

default, se ejecuta el <bloqueDefault>; pero si no se incluye se pasa directamente a

ejecutar la instrucción siguiente al switch.

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.

En realidad, aunque todas las ramas de un switch son opcionales siempre se ha de

incluir al menos una. Además, la rama default no tiene porqué aparecer la última si se

usa, aunque es recomendable que lo haga para facilitar la legibilidad del código.

El elemento marcado como <siguienteAcción> colocado tras cada bloque de instrucciones

indica qué es lo que ha de hacerse tras ejecutar las instrucciones del bloque que lo

preceden. Puede ser uno de estos tres tipos de instrucciones:

goto case <valori>; goto default; break;

Si es un goto case indica que se ha de seguir ejecutando el bloque de instrucciones

asociado en el switch a la rama del <valori> indicado, si es un goto default indica que se

ha de seguir ejecutando el bloque de instrucciones de la rama default, y si es un break

indica que se ha de seguir ejecutando la instrucción siguiente al switch.

El siguiente ejemplo muestra cómo se utiliza switch:

using System;

class HolaMundoSwitch



{


{

if (args.Length > 0)

switch(args[0]) {

case “José”: Console.WriteLine(“Hola José. Buenos días”); break;

case “Paco”: Console.WriteLine(“Hola Paco. Me alegro de verte”); break;

default: Console.WriteLine(“Hola {0}”, args[0]); break;

}

else

Console.WriteLine(“Hola Mundo”);

}

}

Este programa reconoce ciertos nombres de personas que se le pueden pasar como

argumentos al lanzarlo y les saluda de forma especial. La rama default se incluye para

dar un saludo por defecto a las personas no reconocidas.

3.6.4. Instrucción while La instrucción while permite ejecutar un bloque de instrucciones mientras se de una

cierta instrucción. Su sintaxis de uso es:

while (<condición>) {

<instrucciones>

}



Su significado es el siguiente: Se evalúa la <condición> indicada, que ha de producir un

valor lógico. Si es cierta (valor lógico true) se ejecutan las <instrucciones> (sentencia) y se

repite el proceso de evaluación de <condición> y ejecución de <instrucciones> hasta que

deje de serlo. Cuando sea falsa (false) se pasará a ejecutar la instrucción siguiente al

while. En realidad <instrucciones> puede ser una única sentencia o un bloque de

sentencias.

Un ejemplo cómo utilizar esta instrucción es el siguiente:

using System;

class HolaMundoWhile

{


{

int actual = 0;


while (actual < args.Length)

{

Console.WriteLine(“¡Hola {0}!”, args[actual]);

actual = actual + 1;

}

else

Console.WriteLine(“¡Hola mundo!”);

}

}

En este caso, si se indica más de un argumento al llamar al programa se mostrará por

pantalla un mensaje de saludo para cada uno de ellos. Para ello se usa una variable

actual que almacena cuál es el número de argumento a mostrar en cada ejecución del



while. Para mantenerla siempre actualizada lo que se hace es aumentar en una unidad

su valor tras cada ejecución de las <instrucciones> del bucle.

Por otro lado, dentro de las <instrucciones> de un while pueden utilizarse las siguientes

dos instrucciones especiales:

• break;: Indica que se ha de abortar la ejecución del bucle y continuarse

ejecutando por la instrucción siguiente al while.

• continue;: Indica que se ha de abortar la ejecución de las <instrucciones> y

reevaluarse la <condición> del bucle, volviéndose a ejecutar las <instrucciones> si

es cierta o pasándose a ejecutar la instrucción siguiente al while si es falsa.

3.6.5. Instrucción do...while La instrucción do...while es una variante del while que se usa así:

Do {

<instrucciones>

} while(<condición>);

La única diferencia del significado de do...while respecto al de while es que en vez de

evaluar primero la condición y ejecutar <instrucciones> (sentencia) sólo si es cierta,

do...while primero ejecuta las <instrucciones> y luego mira la <condición> para ver si se ha

de repetir la ejecución de las mismas. Por lo demás ambas instrucciones son iguales, e

incluso también puede incluirse break; y continue; entre las <instrucciones> del do...while.



do ... while está especialmente destinado para los casos en los que haya que ejecutar

las <instrucciones> al menos una vez aún cuando la condición sea falsa desde el principio,

como ocurre en el siguiente ejemplo:

using System;

class HolaMundoDoWhile

{

public static void Main()

{

String leído;

Do {

Console.WriteLine(“Clave: “);

leído = Console.ReadLine();

} while (leído != “José”);

Console.WriteLine(“Hola José”);

}

}

Este programa pregunta al usuario una clave y mientras no introduzca la correcta (José)

no continuará ejecutándose. Una vez que introducida correctamente dará un mensaje de

bienvenida al usuario.

3.6.6. Instrucción for La instrucción for realiza un bucle determinado número de veces. Consta de tres partes

La sentencia inicialización se ejecuta al comienzo del ciclo

La condición que se evalúa al entrar al buclé y luego al comienzo de cada iteración.

La modificación se ejecuta al final de cada iteración, y previene que no se entre un

bucle infinito (se ejecuta al final de cada iteración).

escribir los tipos de bucles más comúnmente usados en programación. Su sintaxis es:

for (<inicialización>; <condición>; <modificación>) {

<instrucciones>

}



El significado de esta instrucción es el siguiente: se ejecutan las instrucciones de

<inicialización>, que suelen usarse para definir e inicializar variables que luego se usarán

en <instrucciones> (sentencias). Luego se evalúa <condición>, y si es falsa se continúa

ejecutando por la instrucción siguiente al for; mientras que si es cierta se ejecutan las

<instrucciones> indicadas, luego se ejecutan las instrucciones de <modificación> -que como

su nombre indica suelen usarse para modificar los valores de variables que se usen en

<instrucciones>- y luego se reevalúa <condición> repitiéndose el proceso hasta que ésta

última deje de ser cierta.

En <inicialización> puede en realidad incluirse cualquier número de instrucciones que no

tienen porqué ser relativas a inicializar variables o modificarlas, aunque lo anterior sea

su uso más habitual. En caso de ser varias se han de separar mediante comas (,), ya

que el carácter de punto y coma (;) habitualmente usado para estos menesteres se usa

en el for para separar los bloques de <inicialización>, <condición> y <modificación> Además,

la instrucción nula no se puede usar en este caso y tampoco pueden combinarse

definiciones de variables con instrucciones de otros tipos.

Con <modificación> pasa algo similar, ya que puede incluirse código que nada tenga que

ver con modificaciones pero en este caso no se pueden incluir definiciones de variables.

Como en el resto de instrucciones hasta ahora vistas, en <instrucciones> puede ser tanto

una única instrucción como un bloque de instrucciones. Además, las variables que se

definan en <inicialización> serán visibles sólo dentro de esas <instrucciones>.

La siguiente clase es equivalente a la clase HolaMundoWhile ya vista solo que hace uso

del for para compactar más su código:



using System;

class HolaMundoFor

{


{


for (int actual = 0; actual < args.Length; actual++)

Console.WriteLine(“¡Hola {0}!”, args[actual]);

else

Console.WriteLine(“¡Hola mundo!”);

}

}

Al igual que con while, dentro de las <instrucciones> del for también pueden incluirse

instrucciones continue; y break; que puedan alterar el funcionamiento normal del bucle.

3.6.7. Instrucción break Ya se ha visto que la instrucción break sólo puede incluirse dentro de bloques de

instrucciones asociados a instrucciones iterativas o instrucciones switch e indica que se

desea abortar la ejecución de las mismas y seguir ejecutando a partir de la instrucción

siguiente a ellas. Se usa así:

break;

Cuando esta sentencia se usa dentro de un try con cláusula finally, antes de abortarse la

ejecución de la instrucción iterativa o del switch que la contiene y seguirse ejecutando

por la instrucción que le siga, se ejecutarán las instrucciones de la cláusula finally del try.

Esto se hace para asegurar que el bloque finally se ejecute aún en caso de salto.

Además, si dentro una cláusula finally incluida en de un switch o de una instrucción

iterativa se usa break, no se permite que como resultado del break se salga del finally.

3.6.8. Instrucción continue Ya se ha visto que la instrucción continue sólo puede usarse dentro del bloque de

instrucciones de una instrucción iterativa e indica que se desea pasar a reevaluar



directamente la condición de la misma sin ejecutar el resto de instrucciones que

contuviese. La evaluación de la condición se haría de la forma habitual: si es cierta se

repite el bucle y si es falsa se continúa ejecutando por la instrucción que le sigue. Su

sintaxis de uso es así de sencilla:

continue;

En cuanto a sus usos dentro de sentencias try, tiene las mismas restricciones que break:

antes de salir de un try se ejecutará siempre su bloque finally y no es posible salir de un

finally incluido dentro de una instrucción iterativa como consecuencia de un continue.

3.6.9. Instrucción return Esta instrucción se usa para indicar cuál es el objeto que ha de devolver un método. Su

sintaxis es la siguiente:

return <objetoRetorno>;

La ejecución de esta instrucción provoca que se aborte la ejecución del método dentro

del que aparece y que se devuelva el <objetoRetorno> al método que lo llamó. Como es

lógico, este objeto ha de ser del tipo de retorno del método en que aparece el return o

de alguno compatible con él, por lo que esta instrucción sólo podrá incluirse en métodos

cuyo tipo de retorno no sea void, o en los bloques get de las propiedades o indizadores.

De hecho, es obligatorio que todo método con tipo de retorno termine por un return.

Los métodos que devuelvan void pueden tener un return con una sintaxis espacial en la

que no se indica ningún valor a devolver sino que simplemente se usa return para indicar

que se desea terminar la ejecución del método:

return;

Nuevamente, como con el resto de instrucciones de salto hasta ahora vistas, si se

incluyese un return dentro de un bloque try con cláusula finally, antes de devolverse el

objeto especificado se ejecutarían las instrucciones de la cláusula finally. Si hubiesen

varios bloques finally anidados, las instrucciones de cada uno es ejecutarían de manera

ordenada (o sea, del más interno al más externo) Ahora bien, lo que no es posible es

incluir un return dentro de una cláusula finally.



3.6.10. Instrucción goto La instrucción goto permite pasar a ejecutar el código a partir de una instrucción cuya

etiqueta se indica en el goto. La sintaxis de uso de esta instrucción es:

goto <etiqueta>;

Como en la mayoría de los lenguajes, goto es una instrucción maldita cuyo uso no se

recomienda porque dificulta innecesariamente la legibilidad del código y suele ser fácil

simularla usando instrucciones iterativas y selectivas con las condiciones apropiadas. Sin

embargo, en C# se incluye porque puede ser eficiente usarla si se anidan muchas

instrucciones y para reducir sus efectos negativos se le han impuesto unas restricciones:

• Sólo se pueden etiquetar instrucciones, y no directivas preprocesado, directivas

using o definiciones de miembros, tipos o espacios de nombres.

• La etiqueta indicada no pueda pertenecer a un bloque de instrucciones anidado

dentro del bloque desde el que se usa el goto ni que etiquete a instrucciones de

otro método diferente a aquél en el cual se encuentra el goto que la referencia.

Para etiquetar una instrucción de modo que pueda ser destino de un salto con goto

basta precederla del nombre con el que se la quiera etiquetar seguido de dos puntos (:)

Por ejemplo, el siguiente código demuestra cómo usar goto y definir una etiqueta:

using System;

class HolaMundoGoto

{ public static void Main(string[] args)

{

for (int i=0; i<args.Length; i++)

{

if (args[i] != “salir”)

Console.WriteLine(args[i]);

else

goto fin:

}

fin: ;



}

}

Este programa de ejemplo lo que hace es mostrar por pantalla todos los argumentos

que se le pasen como parámetros, aunque si alguno de fuese salir entonces se dejaría

de mostrar argumentos y se aborta la ejecución de la aplicación. Véase además que este

ejemplo pone de manifiesto una de las utilidades de la instrucción nula, ya que si no se

hubiese escrito tras la etiqueta fin el programa no compilaría en tanto que toda etiqueta

ha de preceder a alguna instrucción (aunque sea la instrucción nula)

Nótese que al fin y al cabo los usos de goto dentro de instrucciones switch que se vieron

al estudiar dicha instrucción no son más que variantes del uso general de goto, ya que

default: no es más que una etiqueta y case <valor>: puede verse como una etiqueta un

tanto especial cuyo nombre es case seguido de espacios en blanco y un valor. En ambos

casos, la etiqueta indicada ha de pertenecer al mismo switch que el goto usado y no vale

que éste no la contenga pero la contenga algún switch que contenga al switch del goto.



3.7. Comentarios

3.7.1. Que es un comentario Un comentario es texto que se incluye en el código fuente para facilitar su lectura a los

programadores y cuyo contenido es, por defecto, completamente ignorado por el

compilador. En C# hay dos formas de escribir comentarios. La primera consiste en

encerrar todo el texto que se desee comentar entre caracteres /* y */ siguiendo la

siguiente sintaxis: /*<texto>*/

3.7.2. Utilización de comentarios Estos comentarios pueden abarcar tantas líneas como sea necesario. Por ejemplo:

/*

Esto es un comentario

que ejemplifica cómo se escribe comentarios de varias líneas

*/

No es posible anidar comentarios de este tipo. Es decir, no vale escribir comentarios

como el siguiente:

/* Comentario contenedor /* Comentario contenido */ */

Dado que muchas veces los comentarios que se escriben son muy cortos y no suelen

ocupar más de una línea, C# ofrece una sintaxis alternativa más compacta para la

escritura este tipo de comentarios en las que se considera como indicador del comienzo

del comentario la pareja de caracteres // y como indicador de su final el fin de línea. Por

tanto, la sintaxis que siguen estos comentarios es: // <texto>



Y un ejemplo de su uso es:

// Este es un comentario de una sola línea

Estos comentarios de una sola línea sí que pueden anidarse sin ningún problema. Por

ejemplo, el siguiente comentario es perfectamente válido:

// Comentario contenedor // Comentario contenido



4. Arreglos

4.1. Objetivos





4. Arreglos


6. Laboratorio




4.1.2. Descripción En este capitulo usted verá:

• Una introducción a los vectores

• Creación de los vectores

• Usos de los vectores

4.1.3. Metas Al final de este capitulo usted será capaz de:

• Dominar los conceptos de vectores

• Conocer la utilización de los vectores



4.2. Introduccion Hasta ahora hemos aprendido un montón de cosas con respecto a las variables, pero

siempre teníamos que saber con antelación el número de variables que el programa iba

a necesitar. Sin embargo, habrá situaciones en las que no sea posible determinar este

número hasta que el programa no se esté ejecutando. Pues bien, para solucionar estas

dificultades contamos con los arrays.

4.3. Arreglos de una dimension Un array es una variable que puede almacenar varios valores simultáneamente. Cada

uno de estos valores se identifica mediante un número al cual se llama índice. Así, para

acceder al primer elemento del array habría que usar el índice cero, para el segundo el

índice uno, para el tercero el índice dos, y así sucesivamente. Se lo decalra de la

siguiente forma :

tipo[] variable;

Es muy parecido a como se declara una variable normal, sólo que hay que poner

corchetes detrás del tipo. En C# 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, en consecuencia, antes de poder usarlos habrá que

instanciarlos, como si fuera cualquier otro objeto. 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, y

podrá tener un maximo de tres elementos (0, 1 y 2). Notesé que indice del array

comienza de CERO (0) y NO de uno (1), por lo cual el índice del último elemento es

siempre el TotalElementos menos uno (3-1=2)



4.4. Operaciones de acceso a arreglos Una array es un conjunto de ordenado de objetos de tamaño fijo. Para acceder

a cualquier elemento de este conjunto se aplica el operador postfijo [] sobre la

tabla para indicar entre corchetes la posición que ocupa el objeto al que se

desea acceder dentro del conjunto. Es decir, este operador se usa así:

[<posiciónElemento>]

Un ejemplo de su uso en el que se asigna al elemento que ocupa la posición 3

en una tabla de nombre tablaPrueba el valor del elemento que ocupa la posición

18 de dicha tabla es el siguiente:

arrayPrueba[3] = arrayPrueba[18];



5. Introducción a la Programación visual

5.1. Objetivos





4. Arreglos


6. Laboratorio




5.2. Que es la programación visual

Hasta ahora, todos los ejemplos que hemos visto y hecho, fueron aplicaciones de

“consola”, es decir, el usuario interactúa con una interfaz de pantalla plana de

caracteres, que no tiene ningún contenido gráfico. Ademas, el tipo de programación que

se aplica a estas interfaces es imperativa, puesto que es el programador quien le

impone las opciones al usuario final.

Pero desde el advenimiento de las computadoreas “Apple” (Macintoch), con su interface

gráfica, y luego pasando por los sucesivos Windows (3, 95, 98, 2000, XP, Vista) , la

interfaz gráfica de usuario (GUI) pasó a ser el standard en el 90 % de las computadoras.

Este tipo de interface, permite interactuar al usuario con un programa de una forma

visual, y ademas, el usuario final es quien decide que hacer con una determinada

aplicación o cualesquiera otra que tenga disponible. Por ello, en este tipo de interfaces,

la programación es por eventos, es decir el programador escribe el código para cada

evento que produzca el usuario final.

5.3. Los Windows Forms

La plataforma .NET cuenta con una librería para interfaces gráficas: WinForms. Esta

librería provee un conjunto de componentes para “armar” formularios visuales.

El componente principal, es el “form” que cuenta con un encabezado, en donde están los

botones de cerrar, maximizar y minimizar; un borde que permite mover y cambiar de

tamaño el formulario; y un cuerpo (canvas) sobre el cual se van colocando los

componentes que conformarán la inteface visual propiamente dicha.



5.4. Componentes El IDE del Visual C# 2008 posee un “Cuadro de herramientas” (ToolBox), que contiene

una vasta colección de componentes y/o controles (visuales y no visuales), agrupados

por categorías.

La forma de trabajo habitual, es elegir uno o mas componentes de esta paleta e ir

arrastrando y soltando el/los controles sobre el formulario; luego cada uno de estos

tiene sus propiedades y eventos.

Los controles son lo esencial cuando se programa con ventanas ya que sin estos lo único

que podremos hacer será mostrar una ventana vacía y no tendríamos posibilidad de

permitirle al usuario una interacción con la solución.

Los controles que utilizaremos en este curso son:

Botón: Levanta un evento cuando el usuario clickea el botón.

Etiqueta: Provee información en tiempo de ejecución o texto descriptivo para un

control.

Caja de texto: Permite al usuario que escriba texto y provee edición multi-línea y

enmascara las palabras claves.

Todos estos y los demás controles (clases) tienen Propiedades, Metodos y Eventos.

5.5. Propiedades Las propiedades son el equivalente a variables que tienen los controles para poder fijar

sus características como tamaño, posición, color, fuente, etc. Estas propiedades se

pueden ver a través del “Inspector de propiedades” que contiene el IDE.



5.6. Eventos

Los eventos, son rutinas (procedimientos o funciones) que contienen los controles, para

cada uno de los posibles sucesos (hacer click en un botón, mover el Mouse, pulsar una

tecla, escribir un texto, etc.) que produzca el usuario.

El programador escribe en el cuerpo de la rutina la acción que va a llevar a cabo en caso

que se produzca ese evento (suceso). Por ejempplo, cuando el usuario cliquea sobre un

boton “cerrar”, el programador escribirá un “Form1.Close()” (cierre del formulario

activo), haciendo que el formulario desaparezca de pantalla. Los eventos, también se

encuentran en el “Inspector de propiedades” del IDE.



6. Laboratorios

6.1. Objetivos





4. Arreglos


6. Laboratorio




6.2. Recomendaciones • Para realizar los laboratorios se recomienda:

• Armar un archivo nuevo por cada ejercicio

• Tener el código fuente explicado en clase a mano para poder hacer referencia si

fuese necesario

• Tener los ejercicios ya realizados a mano para poder tomarlos como base si

fuese necesario

6.3. Lab 1 - Utilización de la estructura de control IF

6.3.1. Ejercicio 1 Dado el siguiente código:

Integer nro1 = 100, nro2 = 500, nro3 = 250;

Informar cual de los tres números es mayor

Requisito: se necesita tener conocimiento del operador de comparación = y la

utilización de if anidados


Integer a = 10, b=-2, c=5; // hay 2 nros positivos y 1 negativo

Informar la multiplicación de los dos números positivos




String usuario = “Pepito”;

String clave = “educacionIT”;

Informar los siguientes casos:

• si usuario=“pepito” y clave =”educacionIT” informar “Bienvenio pepito!”

• si usuario=”pepito” y clave no es “educacionIT” informar “El usuario no

coincide con la contraseña”

• si usuario no es “pepito” informar “El usuario no existe!”

Requisito: se necesita tener conocimiento de como armar una variable de tipo

String



6.4. Lab 2 - Utilización de la estructura de control WHILE

6.4.1. Ejercicio 1 Imprimir los números del 1 al 10 uno abajo del otro

6.4.2. Ejercicio 2 Imprimir los números del 1 al 10 salteando de a 2 uno abajo del otro


6.4.4. Ejercicio 4 Imprimir los números del 1 al 10 sin imprimir números 2,5 y 9 uno abajo del otro

Requisito: se necesita tener conocimiento del operador AND y del operador NOT

6.4.5. Ejercicio 5 Imprimir los números del 1 al 30 sin imprimir números entre el 10 y el 20 uno abajo

del otro

Requisito: se necesita tener conocimientos del operador OR

6.4.6. Ejercicio 6 Imprimir la suma de los números del 1 al 10



6.4.7. Ejercicio 7 Imprimir la suma de los números pares del 1 al 25

Requisito: se necesita tener conocimientos del operador RESTO

6.4.8. Ejercicio 8 – BONUS! Imprimir la multiplicación de los números impares que se encuentran entre -10 y 10

6.4.9. Ejercicio 9 – BONUS! Imprimir la suma de los números pares mayores a 9 y menores a 20 que se

encuentran entre el 1 y el 30



6.5. Lab 3 - Utilización de la estructura de control FOR


6.5.2. Ejercicio 2 Imprimir los números del 1 al 10 salteando de a dos uno abajo del otro


6.5.4. Ejercicio 4 Imprimir la suma de los números impares del 1 al 10

6.5.5. Ejercicio 5 Imprimir la suma de la multiplicación de los números del 1 al 5 con la resta de los

números del 1 al 5

6.5.6. Ejercicio 6 Imprimir la siguiente figura:

@

@

@

@




@

@@

@

@@

@


@

@@

@@@

@@@@

@@@@@


@@@@@

@@@@

@@@

@@

@



6.5.10. Ejercicio 10 – BONUS! Imprimir la siguiente figura:

@

@@

@@@

@@@@

@@@

@@

@

6.5.11. Ejercicio 11 – BONUS! Imprimir la siguiente figura:

@@@@@

@@@

@

@@@

@@@@@



6.6. Lab 4 - Utilización de Vectores

6.6.1. Ejercicio 1 Dado el vector [10,20,5,15,30,20]

a. informar el vector de la forma: "Indice: X, Valor: Y"

b. totalizar el vector e informar el total

c. informar el contenido de las posiciones impares (por ejemplo, las posiciones

1,3,5,etc)

d. informar el mayor número

e. informar cuantas veces aparece el número 20

6.6.2. Ejercicio 2 Dado el vector inflacion [0.8, 0.1, 0.3, 0.4, 0.3, 0.6, 0.5, 0.3, 0.7, 0.3, 0.2, 0.9]

Cada item del vector representa la inflación de un mes de tal manera que el

primeritem del vector que es 0.8 representa la inflación de Enero, y el ultimo item

del vector que es 0.9 representa la inflación de diciembre. Se pide:

a. informar la inflacion anual

b. informar la inflacion mas baja, junto con el numero de mes. Por ejemplo:

Mes 2 = 0.1

c. informar la inflacion mas alta, junto con el numero de mes. Por ejemplo:

Mes 12 = 0.9

d. informar el promedio de inflación (inflación total / 2)



6.6.3. Ejercicio 3 – BONUS! Agregar los cambios que resulten necesarios al ejercicio anterior para que en los puntos b y c se informe la inflación junto con el nombre del mes. Por ejemplo: Mes FEBRERO = 0.1



6.7. Lab 5 – Introducción a Interfaz Grafica de Usuario

6.7.1. Ejercicio 1

Etapa #1 - Construcción de la Interfaz Grafica

Armar la siguiente ventana en forma grafica:

La caja de texto para el usuario deber llamarse txtUsuario

La caja de texto para la contraseña debe llamarse txtContrasena

El boton de login debe llamarse btnLogin

El boton de limpiar debe llamarse btnLimpiar

La etiqueta que se encuentra debajo del boton login debe llamarse lblInformacion



Etapa #2 – Programación de Eventos

Se deberán programar los eventos de los botones para que realice un determinado

procesamiento en caso de ser presionados.

Al presionar el botón Limpiar se deberán limpiar:

• la caja de texto usuario

• la caja de texto contraseña

• la etitqueta correspondiente a la información

Al presionar el botón Login se deberá corrobar que sea un usuario valido. El usuario

valido es aquel que tiene usuario = “pepito” y contraseña = “educacionIT”.

Informar los siguientes casos:

• si usuario=“pepito” y clave =”educacionIT” informar en la etiqueta

información la frase “Bienvenio pepito!”

• si usuario=”pepito” y clave no es “educacionIT” informar en la etiqueta

información la frase “El usuario no coincide con la contraseña”

• si usuario no es “pepito” informar en la etiqueta información la frase “El

usuario no existe!”



6.7.2. Ejercicio 2 Construir una calculadora con una interface gráfica de usuario (con WinForms y los

controles que correspondan).

Esta deberá contener un display superior en donde se muestran los números

introducidos y su resultado, los diez dígitos (0 al 9) numéricos y las cuatro operaciones

básicas (+ , - , * , /) y el signo “=” (igual), como muestra la siguiente imagen:

Se debera programar que al presionar cualquiera de los numeros se debera ir llenando

el display con el numero presionado. Debe soportar agregar numeros con decimales

No es necesario realizar la programación de las operaciones suma, resta, multiplicación

y division




7.1. Objetivos





4. Arreglos


6. Laboratorio




7.1.2. Descripción En este capitulo usted verá:

• Conceptos del paradigma de programación orientado a objetos.

• Los conceptos sobre Clase y sobre Objetos.

• Los conceptos sobre Herencia de Clases

• Aspectos de ocultamiento de información y visibilidad.

7.1.3. Metas Al final de este capitulo usted será capaz de:

• Conocer las definiciones del paradigma de objetos.

• Dominar los conceptos de Clases, Objetos, Instancias y Herencias.

• Entender los conceptos básicos ocultamiento y visibilidad.



7.2. Acerca de este Capitulo - IMPORTANTE • En este capitulo se menciona la teoría de Objetos, a modo de introducción para

el próximo curso.

• El contenido de este capitulo es información opcional de estudio ya que no

forma parte del temario oficial del curso.

• Estos temas serán dictados desde CERO en el próximo curso. Sin necesidad de

tener conocimientos previos de Objetos.}

• El objetivo de este capitulo, es una breve introducción en los aspectos del

Paradigma de Objetos, adelantándose a los temas que se verán próximamente.

7.3. Conceptos

7.3.1. Introducción OOP (Programación orientada a objetos en ingles) revuela alrededor del concepto de

agrupar código y datos juntos en una misma unidad llamada clase. Este proceso es

usualmente referido es como encapsulamiento o información oculta.

Estas clases son esencialmente la representación de un set de funciones (llamadas

métodos) y variables (llamadas propiedades) designadas para trabajar juntas y

proveer una interfaz especifica.

Es importante entender que las clases son una estructura que no puede ser utilizada

directamente, estas deben ser instancia das en objetos, los cuales podrán así interactuar

con el resto de las aplicaciones.

Usted puede pensar en clases como un plano para crear un auto, mientras el objeto es

de hecho el auto en si mismo, ya que se puede crear en una línea de producción.

Podríamos decir que una clase es una fabrica de objetos.



7.3.2. Por que Objetos? La programación orientada a objetos tiende a ser una simple idea. Esta simple idea es:

en vez de crear estructuras de datos por un lado y código por el otro, la idea es asociar

piezas de código junto con los datos.

El mercado de lenguajes de programación, tiende a utilizar este paradigma ya que trae

innumerables ventajas con respecto a la programación estructurada.

A continuación se enumeran algunas de ellas:

• Escalabilidad: Capacidad de crecimiento. Que un sistema sea escalable,

significa que esta preparado para poder crecer sin limitaciones ni perjuicios. En

casos de desarrollo corporativos como por ejemplo el de un sistema bancario,

donde constantemente se necesitan agregar nuevos módulos y cambios en su

comportamiento, es necesario contar con lenguaje de programación que permita

fácilmente administrar estos tipos de desarrollos empresariales.

• Mantenimiento: Una de las principales características del paradigma de

objetivos, es su capacidad realizar cambios en el programa a muy bajo costo

(esfuerzo del programador). Gracias a una buena organización de las clases y sus

herencias es posible hacer pequeños pero importantes cambios que impacten luego

en todas las partes del sistema.

• Seguridad: Este paradigma posee lo que se denomina como encapsulamiento

y visibilidad lo cual permite establecer diferentes niveles de seguridad dentro de un

equipo de desarrolladores, organizando el trabajo en equipo y limitando la posible

existencia de errores o incongruencias cometidos por los programadores.

• Reutilización: A través de la correcta utilización de jerarquía de clases, y la

redefinición de funciones – polimorfismo, se puede reutilizar un importante

porcentaje de código, evitando escribir subprogramas parecidos dentro de un mismo

desarrollo.

• Simplicidad: Cuando el código de un programa desarrollado con le lenguaje

estructurado, crece indefinidamente, se llega a un punto donde el mismo se vuelve

confuso y engorroso. El paradigma de objetos provee simplicidad al poder organizar

la complejidad del mismo a través de su estructura de clases y objetos.



7.3.3. Objetos como Tipos de Datos • Para poder permitirnos almacenar funciones y datos como un típico lenguaje de

programación orientado a objetos, definiremos esta combinación como un genuino

tipo de datos soportado por el lenguaje como cualquier otro.

• Una vez que el tipo de dato fue definido, podremos crear la cantidad de objetos

como queramos.

• En la terminología OOP las clases son utilizadas para referir a un tipo de datos

que especifica datos y funciones en la misma instancia.

• El termino objeto referencia a una instancia individual de un tipo definido.

7.3.4. Conceptos básicos (clase, objeto, encapsulación) No por nada este paradigma se llama "programación orientada a objetos", es decir,

TODO en este tipo de programación se lleva a cabo con objetos. Pero... ¿Qué es un

objeto? Un objeto es un conjunto de campos (variables), métodos (funciones),

propiedades y eventos que se encuentran encapsulados e interactúan entre si para el

correcto funcionamiento de nuestro programa. Debemos entender los objetos como

abstracciones de la realidad con ciertas características representativas. Los podemos

visualizar como pequeños subprogramas que interactúan entre si. Estos objetos

representan (o deberían representar) ideas del mundo real, ideas concretas como

animales o personas, o abstractas como mecanismos para dibujar en la pantalla o

generar números aleatorios.

En la POO tenemos dos conceptos claves que deben ser entendidos, estos son los

conceptos de clase y objeto.

Las clases son módulos de código que contienen métodos, campos, propiedades y

eventos, las consideramos como los moldes o prototipos para los objetos. Ahora bien,

¿qué es un objeto exactamente?, un objeto es la instanciación de una clase, es decir, el

objeto representa la variable y la clase el tipo de dato.

Una clase puede ser instanciada múltiples veces, decimos que puede haber “n” cantidad

de objetos de una clase; en cambio un objeto corresponde tan solo a una clase.



Si tenemos una clase “Casa”, podemos tener infinita cantidad de instanciaciones

(objetos) de Casa, pero cada una tendrá sus valores individuales, aunque todas SEAN

Casa.

Decimos que un objeto ES una clase, cuando es una instanciación de esa clase; es decir,

si yo creo un objeto de la clase “Persona” y como nombre le asigno Juan, mi objeto

Juan ES Persona pero no ES Casa; al continuar con este ejemplo, podríamos crear más

instanciaciones de Persona y asignarles nombres como Pedro, Rubén, Ramiro, y todos

ellos tendrían algo en común, que SON Persona, a pesar de que cada objeto tenga sus

distintos valores, como por ejemplo, distinta altura, distinto peso, distinto color de

cabello (representados por lo campos).

Otro de los conceptos claves de la POO es la "encapsulación". ¿Esto qué significa?, que

nuestro código debe estar dividido en clases (que se instanciarán y pasarán a ser

objetos) las cuales son independientes en funcionalidad del resto del código. Por

ejemplo, una clase Math que posee gran cantidad de funciones matemáticas no tendrá

ningún tipo de dependencia con el objeto mostrarPorPantalla que se encarga de lo que

dice su nombre, por lo cual si ocurre algún error con los colores de la pantalla, sabremos

que sección del código (clase) debemos revisar.

Además la encapsulación nos permite disponer de una importante reutilizabilidad de

código, ya que al hacer un programa totalmente distinto, puedo incluir mi clase Math sin

siquiera modificarle una línea de código y ya dispongo de todas las funciones

matemáticas previamente creadas.

Debemos tener en cuenta que a la hora de codificar con POO, no habrá instrucción

alguna que este fuera de alguna clase, es decir, no hay ningún programa principal que

ejecuta librerías, sino objetos que invocan objetos e interactúan entre si. Disponemos de

una clase Main que es donde comienza el flujo del programa, y desde está clase

comienzan a instanciarse los objetos.

A continuación se explicará que son los campos, métodos, propiedades y eventos.

7.3.5. Propiedades (variables) Las propiedades son las variables contenidas por los objetos. Las clases definen los

propiedades y los objetos los instancian. Las variables de una clase definen las

características de sus objetos. Los campos podrían corresponder a un objeto Persona, el

cual representa a una persona con ciertas características como el nombre, apellido, edad



y altura. Se debe tener en cuenta que un objeto puede tener como propiedades otros

objetos, pero considerando a las clases como estructuras o tipos de datos (son muy

similares) se puede comprender mucho mejor.

La diferencia entre una clase y una estructura de memoria como puede ser un vector o

una matriz, es que una estructura solo almacena variables, es decir, sirve para crear

tipos de datos compuestos; en cambio una clase no solo agrupa variables sino también

funciones, llamadas métodos en el contexto de la POO; además de poseer muchas más

características que se irán explicando a lo largo del curso.

¿Por qué una propiedad debería ser privada y no pública?, si una propiedad es pública,

puede ser modificada y leída por cualquier objeto, lo cual puede resultar peligroso en

algunos casos. Entonces optamos por hacerlo privada, pero de alguna forma debemos

proveer interacción entre un objeto exterior y esa propiedad

Resumiendo: Las propiedades son las variables del objeto que definen sus

características (estados interno).

7.3.6. Métodos (funciones) Los métodos son funciones contenidas por el objeto que definen su comportamiento. Los

métodos pueden ser tanto privados como públicos, si son privados, tan solo podrán ser

accedidos desde dentro del objeto; en cambio si son públicos, podrán ser accedidos por

otros objetos

Un método puede ser público si queremos que pueda ser invocado por otro objeto o

privado si solo puede ser invocado por si mismo. Recordar que al ser funciones, los

métodos pueden devolver o no algún dato.

En resumen: Los métodos son funciones contenidas por un objeto que definen

su comportamiento.



7.4. Herencia

7.4.1. Introducción El mecanismo de herencia es otro de los conceptos clave de la POO, y uno de sus puntos

fuertes. Este mecanismo nos permite que una clase "herede de otra clase" o "extienda

otra clase" implementando todos los campos, métodos, propiedades y eventos de su

clase "padre". Este poderoso mecanismo no solo nos permite la reutilización de código

sino también la aplicación de ciertas prácticas de programación que combinadas con el

mecanismo "polimorfismo" (se verá en la próxima clase) logran generar aplicaciones de

gran potencia y reutilizabilidad.

Cuando una clase hereda de otra, todos los métodos, campos, eventos y propiedades

pasan a estar disponibles en la clase hija, es decir que partimos de todos estos

elementos e incluso podemos agregar nuevos o modificar estos ya heredados. Con las

clases heredadas ampliamos la descripción de un concepto de la vida real, lo volvemos

más específico. Se mencionará algo más sobre esto más adelante.

En lenguajes como PHP, Java o C# la herencia múltiple no es permitida, a diferencia de

lenguajes como C++ que si la permiten. "Herencia múltiple" significa que una clase

puede tener más de una clase padre, es decir, heredar directamente de más de una

clase; pero la herencia múltiple trae ciertas ambigüedades, como por ejemplo: si una

clase hereda de dos clases que poseen métodos con el mismo nombre, al invocar ese

método desde la clase hija ¿al método de qué clase se estará haciendo referencia, si

ambos tienen el mismo nombre?, este tipo de problemas, entre otros, hace de la

herencia múltiple una práctica no muy recomendable. Su contraparte, la herencia simple

(PHP, C#, Java) utiliza un tipo de elemento llamado "Interface" que satisface las mismas

necesidades que la herencia múltiple pero sin causar ambigüedades. Se hablará de las

interfaces en la siguiente clase.

Resumiendo: El mecanismo de herencia es la capacidad que tienen las clases de

implementar el comportamiento de otras clases y a su vez poder responder

ante la definición de todas sus superclases.



7.4.2. Características • Es definir una clase en términos de otra.

• Al crear una clase a partir de otra, luego puede especificar solamente aquellos

rasgos que se desean diferentes a la clase original para ser modificados.

• La clase original se la llama normalmente clase padre. Por defecto todas las

funciones (métodos) y datos (propiedades) definidos serán heredados por la clase

hijo a me nos que se especifique lo contrario.



7.5. Visibilidad

7.5.1. Encapsulamiento • La información que esta oculta dentro de un objeto es llamada encapsulamiento.

• Consiste en ocultar los detalles de la implementación de un objeto.

• También se define como la propiedad de los objetos de permitir acceso a su

estado solamente a través de su interfaz o de relaciones preestablecidas con otros

objetos

7.5.2. Miembros Públicos, Privados y Protegidos • PHP ofrece la posibilidad de definir datos privados, protegidos y públicos.

• La visibilidad de una propiedad o método puede ser definida al anteponerle a la

declaración con las palabras reservadas: public, protected o private.

• Los elementos declarados con Public pueden ser accedidos en todos lados.

• Los Protected limitan el acceso a las clases heredadas (y a la clase que define el

elemento).

• Los Private limitan la visibilidad solo a la clase que lo definió.

public El recurso puede ser accedido desde cualquier parte del programa

protected El recurso solo puede ser accedido desde adentro de la clase donde fue definida y sus descendencias

private El recurso solo puede ser accedido desde adentro de la clase donde fue definida

final El recurso puede ser accedido desde cualquier parte del programa pero no puede ser sobrescrito por sus descendientes

tabla de contenidos -...

Documents