1. Definir los conceptos básicos de arreglos, según una discusión en clase.

2. Identificar los tipos de problemas que se pueden resolver mediante el

uso de arreglos, usando programación orientada a objetos.
3. Resolver problemas haciendo uso de arreglos unidimensionales para
desarrollar programas orientados a objetos.

1. Definición de arreglos.
2. Declaración y creación de arreglos.
3. Tipos de arreglos según sus dimensiones.
4. Aplicación de arreglos en la programación orientada a objetos.
 Un arreglo unidimensional es un tipo de datos estructurado que está
formado de una colección finita y ordenada de datos del mismo tipo. Es
la estructura natural para modelar listas de elementos iguales.

Para implementar arreglos unidimensionales se debe reservar espacio

en memoria, y se debe proporcionar la dirección base del arreglo, la cota
superior y la inferior.

Un arreglo es un conjunto finito y ordenado de elementos homogéneos.

La propiedad ordenado significa que el primer elemento, el segundo, el
tercero,..., el enésimo puede ser identificado. La homogeneidad implica
que todos los elementos del arreglo son datos del mismo tipo.
Arreglos Primitivos

Arreglos Referencia
Conocidos también como Listas o Vectores

Nombre del arreglo

C [0] 10
C [1] 4
C [2] 7
C[3] 18
C[4] 9
C[5] 3
C[6] 25
Número de posición
del elemento dentro
del arreglo C
 Arreglos de dos dimensiones, llamados tablas o matrices

0 1 2 3 4 5 Columnas
0
1 (matriz 2 3)
2
3
4
5 (matriz 4 0)
.
Filas

Declaración y Creación
tipo nombre_arreglo[ ][ ] = new
tipo[nº][nº];
Guardar colección de Información.
Permite almacenar Datos para luego acceder a ellos.
Simplifica la escritura de códigos en la programación.
Limpieza de Programación.
Facilitar actividades de la vida diaria.
Presentar posibles soluciones que se adapte a situaciones
problemáticas reales.
En java un arreglo es considerado como una colección de objetos del
mismo tipo enumerados en una celda en donde cada uno de ellos
posee un índice que indica su posición en el arreglo.

Almacena los elementos del arreglo en posiciones de memoria

continua.

Tiene un único nombre de variable que representa a todos los

elementos, y éstos a su vez se diferencian por un índice o subíndice.

Acceso directo o aleatorio a los elementos individuales del arreglo.

Son entidades estáticas ya que conservan el mismo tamaño durante

toda la ejecución del programa.
 Suponga que tenemos la siguiente simple clase para representar
cursos.
class Curso
{
private String sigla;
private int creditos;
public Curso(String sig, int cred)
{
sigla = sig;
creditos = cred;
}
public int Creditos()
{
return creditos;
}
public String Sigla()
{
return sigla;
}
}
J
 Supongamos queremos tener una clase Alumno a la que podamos
asignarle varios objetos de tipo Curso.
La clase Alumno debería contener un arreglo de objetos Cursos.
Tal como definamos arreglos para tipos simples en JAVA podemos
hacer arreglos de objetos.

Por ejemplo:
1. Para crear un arreglo llamado cursos de 5 (referencias a) cursos debemos
hacer:
Curso[] cursos = new Curso[5];

2. Ahora podríamos a cada curso[i] asignarle un objeto de tipo curso, ya sea

uno previamente creado, o uno nuevo

Curso c1 = new Curso("ing1310", 10);

cursos[0] = c1;
cursos[2] = c1;
cursos[1] = new Curso("ing1320", 15);
3. Después de que creamos un arreglo de objetos y asignamos ciertos
objetos a cada componente, podemos usar losm etodos/atributos de
cada objeto tal como un objeto cualquiera.

4. Dado que por ejemplo cursos[1] es un objeto de la clase Curso

podemos hacer

cursos[1].Creditos();

Para obtener los créditos del curso con Índice 1.

5. Siguiendo el ejemplo anterior, que imprime este trozo de código?:

System.out.println(cursos[2].Creditos());
System.out.println(cursos[1].Creditos());
System.out.println(cursos[0].Creditos());
 6. Ahora podríamos tener una clase Alumno como la siguiente:

class Alumno
{
String nombre;
private Curso[] cursos;
private int cantidadCursos;
private int maximaCantidadCursos;
public Alumno(String nom)
{
nombre = nom;
cantidadCursos = 0;
maximaCantidadCursos = 6;
cursos = new Curso[maximaCantidadCursos];
}
....
}

Donde:
- maximaCantidadCursos: indica la máxima cantidad permitida de cursos
que puede tener asignado un alumno.
- cantidadCursos: representa la cantidad de cursos que actualmente tiene
asignado el alumno.
- int[ ] A; // A es un arreglo de enteros
- int A[ ]; // A es un arreglo de enteros
- int A[10]; // error, el tamaño no va aquí
- int A,B[ ]; // A es un entero, B un arreglo
- int[ ] A,B; // A y B son arreglos

- String Palabra[ ]; // “Palabra” es un arreglo de String

- Palabra [1]=" " // error, el arreglo “Palabra” no ha sido creado

- double A[ ]; // Declaración del arreglo A

- double[ ] A; // A es un arreglo de datos doubles
- int A[ ]= new int[10]; // Arreglo A de dimensión 10 enteros
- int[ ] A= new int[10]; //Creación del arreglo A de 10 enteros
- A= new int[10]; //Asignación de memoria al arreglo A

- String Nombre[ ]= new String[10]; // Arreglo “Nombre” de dimensión 10

- String[] Nombre= new String[10]; //Creación del arreglo “Nombre” con
dimensión 10
- Nombre= new String[10]; //Asignación de memoria al arreglo “Nombre”

- double B[ ]= new double[10]; // Arreglo B de dimensión 10 elementos

- double[ ] B= new double[10]; //Creación del arreglo B de 10 elementos
- B= new double[10]; //Asignación de memoria al arreglo B
 Para tener un arreglo unidimensional preparado es necesario
ejecutar dos pasos.

Tipo nombre_arreglo [ ];

Cuando se declara una variable vector, esta no tiene ningún valor. Antes de
asignar cualquier valor, se debe reservar un espacio en memoria, utilizando
el operador new y asignarlo a la variable.

Tipo nombre_arreglo [ ] = new Tipo [nº];

New: operador especial que reserva espacio en memoria.

Al reservar espacio para los elementos de un vector, mediante new, se

inicializa automáticamente en cero su contenido.
 El siguiente programa permite crear y llenar un arreglo tipo lista
(vector) y mostrarlo al usuario a partir de las entradas ingresadas por
pantalla:
 El siguiente programa suma dos matrices A y B llenadas por el
usuario ingresando su dimensión n*n y presenta en pantalla la matriz
llena A, la matriz llena B y la matriz suma (A+B)