MODULARIDAD
DEFINICIÓN:
Módulo: Un módulo que se supone que representa una función lógica es una secuencia léxicamente continúa de instrucciones que se encuentra limitado por elementos de fronteras y además se caracteriza por disponer de un nombre o identificador
Módulo: Es aquél que está constituido por una o varias instrucciones físicamente contiguas y lógicamente encadenadas, las cuales se pueden referenciar mediante un nombre y pueden ser llamadas desde diferentes puntos de un programa.
Un módulo puede ser:
Un programa Una función Una subrutina (o procedimiento) La modularidad se basa en la descomposición de un problema en una serie de sub problemas; dividiéndolo en módulos que resultan de segmentar el problema en funciones lógicas que son perfectamente diferenciadas. Esta división exige la presencia de un módulo denominado módulo de base o principal a objeto de que controle y se relacione con los demás.
Es una técnica de programación que todavía se utiliza tanto para la construcción de algoritmos computacionales básicos así como apoyo al desarrollo de sistemas de gestión (en el diseño de diagramas modulares).
La salida del módulo debe ser función de la entrada, pero no de ningún estado interno. En la creación de los módulos deben cumplirse tres aspectos básicos: descripción, rendimiento y diseño.
En la descripción se definen las funciones y objetivos del programa. Para obtener el máximo rendimiento se ha de comprobar que el programa realice el proceso aprovechando al máximo todos los recursos de los que dispone. En cuanto al diseño, se debe comprobar la estructura que sigue el módulo, así como la estructura de los datos y la forma de comunicaciones entre los diversos y diferentes módulos.
Conforme se extiende el tamaño de los algoritmos, se hace más difícil su revisión, actualización y/o corrección.
Una política común para solventar este problema consiste en la modularización. Esto significa que el algoritmo se fragmenta en partes llamadas módulos. En realidad, es un método de diseño que tiende a dividir el problema, de forma lógica, en partes perfectamente diferenciadas que pueden ser analizadas, programadas y puestas a punto independiente.
Objetivos: Descomponer el sistema en módulos: - Los grupos deben maximizar el enlace y minimizar el acoplamiento.
Determinar las relaciones entre módulos: - Identificar y especificar las dependencias entre módulos.
- Determinar la forma de comunicación entre módulos (variables llamadas a funciones, memoria compartida, paso de mensajes)
Especificar las interfaces de los módulos: - Facilita la prueba independiente entre los módulos.
- Mejora la comunicación e integración del grupo
Características: Permite reducir la complejidad global del sistema descentralizado; ejm. Divide y vencerás. Mejora la escalabilidad y la productividad (los módulos pueden desarrollarse independientemente por varias personas) Principios para asegurar diseños modulares: Soporte de lenguaje para unidades modulares. Los módulos deben corresponder a unidades sintácticas del lenguaje utilizado.
Pocas interfaces: Cada módulo debe comunicarse con tan pocos como sea posible.
Interfaces pequeñas (Acoplamiento débil): Si dos módulos se comunican, deben intercambiar la menor información posible..
Interfaces explícitas: Cuando dos módulos se comunican, debe estar claro en el texto de uno o de ambos.
Ocultación de la información: Toda la información sobre un módulo debe ser privada al módulo, a menos que se haya declarado específicamente como pública.
Arreglo unidimensional tiene una sola dimensión. En C#, la dimensión se maneja por medio de un par de corchetes.
A los arreglos de una dimensión también se les llama listas.
Operaciones.
Para manejar un arreglo, las operaciones a efectuarse son:
· Declaración del arreglo,
· Creación del arreglo,
· Inicialización de de los elementos del arreglo, y
· Acceso a los elementos del arreglo.
A continuación describiremos cada una de estas operaciones, en C#.
Declaración.
La declaración de un arreglo unidimensional consiste en establecer las características del arreglo y sus elementos, por medio de la siguiente sintaxis:
Donde:
tipo indica el tipo correspondiente a los elementos del arreglo ,
identificador es el nombre del arreglo, y
el par de corchetes, [ ], representa la dimensión del arreglo y encierra un número entero que corresponde al número de elementos del arreglo.
Ejemplos:
int [ ] a ;
float [ ] distancia ;
Artículo [ ] art = new Artículo[ 3];
Observe que, en la declaración, el espacio entre los corchetes está vacío. Esto se debe a que, durante dicha operación, no se reserva espacio en la memoria.
Creación.
La creación de un arreglo unidimensional consiste en reservar espacio de memoria para todos sus elementos, utilizando la siguiente sintaxis:
< identificador > = new
Donde:
new es el operador para gestionar espacio de memoria, en tiempo de ejecución,
tamaño es un número entero que representa el número de elementos del arreglo.
Ejemplos:
a = new int [10] ; // Se crea el arreglo a , con 10 elementos de tipo entero.
distancia = new float[ 5] ; // Se crea el arreglo distancia , con 5 elementos de punto flotante y precisión sencilla .Artículo [] art = new Artículo[3];
Artículo [ ] art = new Artículo[ 3]; // Se crean 3 referencias a objetos de la clase Artículo
art[0]= new Artículo(); // Se crea el primer objeto del arreglo art
art[1]= new Artículo(); // Se crea el segundo objeto del arreglo art
art[2]= new Artículo(); // Se crea el tercer objeto del arreglo art
Las dos primeras operaciones de declaración y creación anteriores se pueden agrupar en una sola instrucción, como se muestra enseguida:
int [ ] a = new int [10] ;
float [ ] distancia = new float[5] ;
Inicialización.
Un arreglo es un objeto que,cuando es creado por el compilador, se le asignan automáticamente valores iniciales predeterminados a cada uno de sus elementos, de acuerdo a los siguientes criterios:
· Si el tipo del arreglo es numérico, a sus elementos se les asigna el valor cero.
· Si el tipo del arreglo es char, a sus elementos se les asigna el valor '\u0000'.
· Si el tipo del arreglo es bool, a sus elementos se les asigna el valor false.
· Si el tipo del arreglo es una clase, a sus elementos se les asigna el valor null.
Cuando se requiere asignar valores iniciales diferentes de los predeterminados, es posible agrupar las operaciones de declaración, creación e inicialización en una sola instrucción, por ejemplo:
int [ ] a = { 1, 0,4,-6, 2,9, 23,455, 90,35 };
float [ ] distancia = { 2.50F, 286.45F, 46.75F, 30.62F, 93.00F };
string [ ] pato = { "Hugo", "Paco", "Luís" }
Acceso.
Se puede acceder a los valores de los elementos de un arreglo a través del nombre del arreglo y un subíndice. El subíndice debe escribirse entre corchetes y representa la posición del elemento en el arreglo. Así, podemos referirnos a un elemento del arreglo escribiendo el nombre del arreglo y el subíndice del elemento entre corchetes. Los valores de los subíndices empiezan en cero para el primer elemento, hasta el tamaño del arreglo menos uno.
Ejemplo:
float [ ] distancia = new float[5] ; // Crea el arreglo distancia con 5 elementos.
float x = 25F, y = 10F ; // Crea dos variables de punto flotante y precisión sencilla.
distancia[0] = x + y ; // El valor asignado al primer elemento es 35.
distancia[1] = ++distancia[0] ; // Asigna 36 al segundo elemento.
distancia[2] = distancia[1] - distancia[0] + 4 ; // Asigna 5 al tercer elemento.
distancia[3] = distancia[2]-- ; // Asigna 5 al cuarto elemento
// y disminuye en 1 el valor del tercero.
distancia[4] = distancia[3] * distancia[2] ; // Asigna 20 al quinto elemento.
y = distancia[4] ; // Asigna a y el valor almacenado en el quinto elemento.
Aplicaciones.
Listas.
Resolvamos el problema de manejar dos listas: una con los nombres de un grupo de alumnos y otra con una calificación para cada uno de los alumnos.
Primero se deberán leer los nombres de los alumnos y la calificación que corresponde a cada uno de ellos y después habrá que desplegar dos columnas: una con los nombres de los alumnos y la otra con sus respectivas calificaciones.
La lectura debe lucir de manera similar a la siguiente:
Número de alumnos: 30
Nombre [0] :
Calificación[0] :
Nombre [1] :
Calificación[1] :
Nombre [2] :
Calificación[2] :
...
...
Nombre [29] :
Calificación[29] :
El despliegue en el monitor luciría así:
| No. | Nombre | Calif. |
| 1 | Hugo | 100 |
| 2 | Paco | 90 |
| 3 | Luís | 95 |
| ... |
| ... |
| 30 | Donald | 70 |
El siguiente código corresponde a un programa que resuelve el problema.
// Lista.cs : Lee una lista de nombres y calificaciones correspondientes a un grupo de
// alumnos de una materia.
using System;
using C = System.Console;
public class Lista
{
public static void Main()
{
int nAlumnos;
C.Write("Número de alumnos: ");
nAlumnos = Convert.ToInt32(C.ReadLine());
string [ ] alumnos = new string[nAlumnos]; //Crea el arreglo de
//alumnos.
int [ ] calif = new int [nAlumnos]; // Crea el arreglo de calificaciones.
// Lee los elementos de los dos arreglos.
for(int i = 0; i < nAlumnos ; i++)
{
C.Write("Nombre del alumno [" + i + "] : ");
alumnos[i] = C.ReadLine( );
C.Write("Calificación [" + i + "] : ");
calif[i] = Convert.ToInt32(C.ReadLine( ));
}
// Despliega los valores de los dos arreglos.
C.WriteLine("No. Nombre Calif.");
for(int i = 0 ; i < nAlumnos ; i++)
{
C.Write(" " + (i+1) + ".- " + alumnos[ i] );
C.WriteLine(" " + calif[i] );
}
}
}
Vectores.
Otra de las aplicaciones de los arreglos es el manejo de vectores. En Física, los vectores sirven para representar velocidades, aceleraciones, etc.
Podemos representar a un vector como un segmento de recta dirigida que tiene magnitud, orientación y sentido.
En un espacio tridimensional, un vector puede expresarse por medio de tres componentes sobre los ejes cartesianos. Cada componente puede, a su vez, expresarse en función de los vectores unitarios i, j, k ,que se ubican en los ejes x, y, z, respectivamente.
Por ejemplo , un vector v1 puede representarse en función de sus componentes como:
v1 = 20i + 15j + 35k
Si tenemos otro vector,
v2 = -5i + 40j + 25k
La suma de los dos vectores sería:
s = v1+v2 = (20-5)i +(15+40)j+(35+25)k
s = 15i + 55j + 60k
Un segmento del programa para este ejemplo sería:
double v1[ ] = new double[3];
double v2[ ] = new double[3];
double s[ ] = new double[3];
v1[0] = 20;
v1[1] = 15;
v1[2] = 35;
v2[0] = -5;
v2[1] = 40;
v2[2] = 25;
for(int i=0; i < 3 ; i++)
{
s[ i ] = v1[ i ] + v2[ i ] ;
}
Arreglo bidimensional tiene dos dimensiones y es un caso particular de los arreglos multidimensionales. En C#, las dimensiones se manejan por medio de un par de corchetes, dentro de los que se escriben, separados por comas, los valores de las dos dimensiones.
Operaciones.
Para manejar un arreglo, las operaciones a efectuarse son:
· Declaración del arreglo,
· Creación del arreglo,
· Inicialización de de los elementos del arreglo, y
· Acceso a los elementos del arreglo.
A continuación describiremos cada una de estas operaciones, en C#.
Declaración.
La declaración de un arreglo consiste en establecer las características del arreglo y sus elementos, por medio de la siguiente sintaxis:
Donde:
tipo indica el tipo correspondiente a los elementos del arreglo ,
identificador es el nombre del arreglo, y
el par de corchetes y la coma, [ , ], representan las dimensiones del arreglo y encierra dos números enteros, cuyo producto corresponde al número de elementos del arreglo.
Ejemplos:
double [ , ] matriz ;
int [ , ] ubicación ;
Rama [ , ] árbol; // Rama es una clase.
Observe que, en la declaración, el espacio entre los corchetes está vacío. Esto se debe a que, durante dicha operación, no se reserva espacio en la memoria.
Creación.
La creación de un arreglo bidimensional consiste en reservar espacio en la memoria para todos sus elementos, utilizando la siguiente sintaxis:
< identificador > = new
Donde:
new es el operador para gestionar espacio de memoria, en tiempo de ejecución,
dim1 y dim2 son valores enteros que representan las dimensiones del arreglo.
El tamaño del arreglo es el resultado de multiplicar los valores de las dimensiones y representa el número de elementos del arreglo.
Ejemplos:
matriz = new double [2, 3] ; // Se crea el arreglo matriz, con 6 elementos de tipo
//punto flotante y precición doble .
ubicación = new int[ 4,2] ; // Se crea el arreglo ubicación, con 8 elementos de
//tipo entero de 32 bits .
árbol = new Rama[5,2] ; // Se crea el arreglo arbol, con 10 objetos
//de la clase Rama.
Las operaciones de declaración y creación anteriores se pueden agrupar en una sola instrucción, como se muestra enseguida:
double [ , ] matriz = new double [2,3] ;
int [ , ] ubicación = new int[4, 2] ;
Rama [ , ] alumno = new Rama[5,2] ;
Inicialización.
Un arreglo es un objeto que,cuando es creado por el compilador, se le asignan automáticamente valores iniciales predeterminados a cada uno de sus elementos, de acuerdo a los siguientes criterios:
· Si el tipo del arreglo es numérico, a sus elementos se les asigna el valor cero.
· Si el tipo del arreglo es char, a sus elementos se les asigna el valor '\u0000'.
· Si el tipo del arreglo es bool, a sus elementos se les asigna el valor false.
· Si el tipo del arreglo es una clase, a sus elementos se les asigna el valor null.
Cuando se requiere asignar valores iniciales diferentes de los predeterminados, es posible agrupar las operaciones de declaración, creación e inicialización en una sola instrucción, por ejemplo:
double [ , ] matriz = { {1.5, 0, 4, -6.5, 2 } , {2.3, 9, 3.5, 4.8, 6.2} };
int [ , ] ubicación = { {2, 4} , {6, 8} , {9, 10}, {5 , 1}};
string [ , ] funcionario = { {"Hugo", "jefe"} ,
{ "Paco", "operador "},
{ "Luís","ayudante"} };
Acceso.
Se puede acceder a los valores de los elementos de un arreglo bidimensional a través del nombre del arreglo y dos subíndices. Los subíndices deben escribirse entre corchetes y representa la posición del elemento en el arreglo. Así, podemos referirnos a un elemento del arreglo escribiendo el nombre del arreglo y los subíndices del elemento entre corchetes. Los valores de los subíndices empiezan en cero para el primer elemento, hasta el tamaño del arreglo menos uno.
Ejemplo:
int [ , ] posición = new int[5, 10] ; // Crea el arreglo posición , con 50 elementos de tipo entero.
int x;
posición[ 3, 5] = 3 ;
x = posición[ 3, 5] ;
Aplicaciones.
Matrices.
Una matriz es un arreglo rectangular de dos dimensiones, donde el acomodo de los elementos está dispuesto en renglones y columnas.
Ejemplo 1:
Se debe controlar la ubicación de los asistentes a una sala de conferencias por medio de un gafete que tiene escrito el nombre del asistente, la fila y la columna donde se ubica su asiento.
El siguiente segmento de código muestra la solución con arreglos bidimensionales.
string [ , ] asistente = new string[10,12] ;
// Inicializa los valores de los nombres con cadenas vacías.
for(int i=0 ; i < 10 ; i++ ) // Controla la fila.
for(int j=0 ; j < 12 ; j++ ) // Controla la columna.
asistente[ i , j ] = " " ;
// Captura los nombres de todos los asistentes y les asigna sus asientos,
// en el orden en que van llegando.
for(int i=0 ; i < 10 ; i++ ) // Controla la fila.
for(int j=0 ; j < 12 ; j++ ) // Controla la columna.
asistente[ i , j ] = System.Console.ReadLine( );
// Despliega los nombres de todos los asistentes.
for(int i=0 ; i < 10 ; i++ ) // Controla la fila.
for(int j=0 ; j < 12 ; j++ ) // Controla la columna.
System.Console.WriteLine( asistente[ i , j ] );
Ejemplo 2 :
Dada la matriz A :
| 8 | 9 | 5 |
| 6 | 3 | 2 |
y la matriz B :
| 7 | 1 | 4 |
| 5 | 0 | 3 |
Elaborar un programa en C# para obtener la suma de ambas matrices: S = A + B
// SumMatrices.cs : Suma dos matrices de 2 renglones y 3 columnas.
using System;
using C = System.Console;
namespace Sumatrices
{
class Matriz
{
public static void Main()
{
const int r = 2, c = 3;
int i, j;
double[,] A = new double[r, c];
double[,] B = new double[r, c];
double[,] S = new double[r, c];
C.Clear();
// Lectura de valores para los elementos de A.
C.WriteLine("Suma de las matrices A y B de 2x3\n");
C.WriteLine("\nTeclee los valores de la Matriz A\n");
for (i = 0; i < r; i++)
for (j = 0; j < c; j++)
{
C.Write(" A[{0},{1}] = ",i,j);
A[i, j] = Double.Parse(Console.ReadLine());
}
// Lectura de valores para los elementos de B.
C.WriteLine("\nTeclee los valores de la Matriz B\n");
for (i = 0; i < r; i++)
for (j = 0; j < c; j++)
{
C.Write(" B[{0},{1}] = ", i,j);
B[i, j] = Double.Parse(Console.ReadLine());
}
// Suma y despliegue de la matriz resultado.
C.WriteLine("\nMatriz S = A+B\n");
for (i = 0; i < r; i++)
{
for (j = 0; j < c; j++)
{
S[i, j] = A[i, j] + B[i, j];
C.Write(" " + S[i, j]);
}
C.WriteLine();
}
}
}
}
Arreglos multidimensionales tienen más de una dimensión. En C#, las dimensiones se manejan por medio de un par de corchetes, dentro de los que se escriben los valores de cada dimensión, separados por comas.
Operaciones.
Para manejar un arreglo, las operaciones a efectuarse son:
· Declaración del arreglo,
· Creación del arreglo,
· Inicialización de de los elementos del arreglo, y
· Acceso a los elementos del arreglo.
A continuación describiremos cada una de estas operaciones, en C#.
Declaración.
La sintaxis para declarar un arreglo multidimensional es la siguiente:
Donde:
tipo indica el tipo correspondiente a los elementos del arreglo ,
identificador es el nombre del arreglo, y
el par de corchetes, la coma y las diéresis, [ , ...], representan las dimensiones del arreglo. Los corchetes encierran todas las comas necesarias para separar las dimensiones del arreglo.
Ejemplos:
double [ , ] bidim; // Dos dimensiones.
int [ , , ] tridim ; // Tres dimensiones.
char [ , , , ] enciclopedia; // Cuatro dimensiones.
Observe que, en la declaración, el espacio entre los corchetes está vacío. Esto se debe a que, durante dicha operación, no se reserva espacio en la memoria.
Creación.
La creación de un arreglo multidimensional consiste en reservar espacio en la memoria para todos sus elementos, utilizando la siguiente sintaxis:
< identificador > = new
Donde:
new es el operador para gestionar espacio de memoria, en tiempo de ejecución,
dim1 , dim2 , dimN son valores enteros que representan las dimensiones del arreglo.
El tamaño del arreglo es el resultado de multiplicar los valores de las dimensiones y representa el número de elementos del arreglo.
Ejemplos:
bidim = new double [2, 3] ;
tridim = new int[ 2, 3, 4] ;
enciclopedia = new char[30, 80, 500, 10] ;
Las operaciones de declaración y creación anteriores se pueden agrupar en una sola instrucción, como se muestra enseguida:
double [ , ] bidim = new double [2,3] ;
int [ , , ] tridim = new int[2, 3, 4] ;
char [ , , , ] enciclopedia = new char[ 30, 80, 500, 10 ] ;
Inicialización.
Un arreglo es un objeto que,cuando es creado por el compilador, se le asignan automáticamente valores iniciales predeterminados a cada uno de sus elementos, de acuerdo a los siguientes criterios:
· Si el tipo del arreglo es numérico, a sus elementos se les asigna el valor cero.
· Si el tipo del arreglo es char, a sus elementos se les asigna el valor '\u0000'.
· Si el tipo del arreglo es bool, a sus elementos se les asigna el valor false.
· Si el tipo del arreglo es una clase, a sus elementos se les asigna el valor null.
Cuando se requiere asignar valores iniciales diferentes de los predeterminados, es posible agrupar las operaciones de declaración, creación e inicialización en una sola instrucción, por ejemplo:
int [ , , ] tridim={{{12, 59, 70, 45} , {20, 16, 29, 48} , {93, 75, 43, 10}},
{{44, 72, 30, 24} , {60, 89, 39, 61} , {99, 52, 34, 47}}};
Acceso.
Se puede acceder a los valores de los elementos de un arreglo bidimensional a través del nombre del arreglo y dos subíndices. Los subíndices deben escribirse entre corchetes y representa la posición del elemento en el arreglo. Así, podemos referirnos a un elemento del arreglo escribiendo el nombre del arreglo y los subíndices del elemento entre corchetes. Los valores de los subíndices empiezan en cero para el primer elemento, hasta el tamaño del arreglo menos uno.
Aplicaciones.
Se necesita manejar, en un arreglo, la posición todos los caracteres escritos en una enciclopedia. El arreglo deberá tener las siguientes dimensiones:
- Una para manejar el renglón en la página,
- otra para la columna en la página,
- otra para la hoja en el volumen y
- otra para el volumen en la enciclopedia.
Cada página tiene 30 renglones y 80 columnas.
Cada volumen tiene 500 páginas.
La enciclopedia tiene 18 volúmenes.
El siguiente fragmento de programa implementa la solución a este problema.
char car;
// Declara y crea el arreglo.
char[ , , , ] enciclopedia = new char [18,500,30,80] ;
// Lee, desde el teclado, cada carácter para la enciclopedia.
for(int v = 0 ; v < 18 ; v++) // Volumen
for(int p = 0 ; p < 500 ; p++) // Página
for(int r = 0 ; r < 30 ; r++) // Renglón
for(int c = 0 ; c < 80 ; c++) // Columna
{
car = (char)Console.Read( ) ;
enciclopedia[v,p,r,c] = car ;
}
Conceptos básicos.
Un arreglo de arreglos es un arreglo cuyos elementos son arreglos. Los elementos de un arreglo de arreglos pueden ser de diferentes dimensiones y tamaños, de ahí que en C# los arreglos de arreglos también se conocen como "arreglos dentados" ( jagged arrays ).
Declaración y creación.
En el manejo de un arreglo dentado debe usarse un par de corchetes para cada dimensión, como se muestra en la sintaxis para la declaración de sus elementos:
Ejemplo:
int [ ] [ ] lista = new int [ 3 ] [ ] ;
Hay que observar que aquí se ha creado un arreglo unidimensional y se han declarado sus 3 elementos que son arreglos unidimensionales de números enteros.
Antes de poder utilizar el arreglo lista, deben crearse sus elementos, por ejemplo:
lista[0] = new int[4] ;
lista[1] = new int[2] ;
lista[2] = new int[3] ;
De haber necesitado un arreglo de tres arreglos de dimensión 5, podríamos haber escrito:
int [ ] [ ] lista = new int[3] [5] ;
Esto es diferente al arreglo bidimensional:
int [ , ] lista = new int [3,5] ;
Inicialización.
Pueden inicializarse los elementos de un arreglo al mismo tiempo de su creación, como en el siguiente ejemplo.
lista[0] = new int[ ] { 10, 32, 15, 22 } ;
lista[1] = new int[ ] { 16, 50 } ;
lista[2] = new int[ ] { 35, 18, 47 } ;
O inicializarlos desde la creación del arreglo dentado, por ejemplo:
int [ ] [ ] lista = new int [ ] [ ]
{
new int[ ] { 10, 32, 15, 22 } ,
new int[ ] { 16, 50 } ,
new int[ ] { 35, 18, 47 }
} ;
Abreviando:
int [ ] [ ] lista = {
new int[ ] { 10, 32, 15, 22 } ,
new int[ ] { 16, 50 } ,
new int[ ] { 35, 18, 47 }
} ;
Acceso.
Se puede acceder a elementos individuales de un arreglo dentado utilizando un subíndice dentro de cada par de corchetes.
Ejemplos:
x = lista[ 0 ] [ 3 ] ; // Asigna 22 a la variable x.
lista[ 1 ] [ 0 ] = 25 ; // Sustituye el 16 por 25.
Mezcla de arreglos.
Es posible mezclar arreglos dentados y multidimensionales, como se muestra en el siguiente ejemplo de un arreglo dentado unidimensional que contiene tres arreglos bidimensionales, cada uno con diferentes dimensiones.
int [ ] [ , ] mezcla = new int [ 3 ] [ , ]
{
new int[ , ] { { 10 , 3 } , { 4 , 9 } } ,
new int[ , ] { { 21 , 7 } , { 8 , 5 } , { 12 , 56 } } ,
new int[ , ] { { 32 , 6 } , { 29, 0 } , { 28 , 34 } , { 20 , 11 } }
} ;
Para coordinarse en la solución de un problema, los objetos se comunican a través de mensajes.
Los métodos representan los comportamientos de los objetos pertenecientes a una clase y constituyen el medio para el envío de mensajes entre ellos.
No hay comentarios:
Publicar un comentario