 Una matriz es un objeto en el que se

puede almacenar un conjunto de datos

de un mismo tipo.
 Las matrices son conocidas también
como arreglos o “arrays”.
 Una matriz puede definirse con base en
la cantidad de dimensiones.
 Una matriz de una dimensión también se
llama matriz unidimensional y la puedes
representar gráficamente de la siguiente
manera:
 Un arreglo es una colección de objetos
numerados del mismo tipo, en donde
cada variable o celda en el arreglo
tiene un índice. Las celdas están
numeradas del 0 al N-1, donde N es el
número de celdas del arreglo es decir su
capacidad.
 Java implementa los arreglos como
objetos que pueden ser tratados como
cualquier otro objeto.
Para utilizar un arreglo en Java:
 Declare una variable para que
contenga el arreglo.
 Cree un nuevo arreglo de objeto y
asígnelo a la variable de arreglo.
 Almacene información en ese arreglo.
 Realice operaciones de
almacenamiento y recuperación con los
elementos del arreglo.
Declaración:

 Se agrega un par de corchetes vacíos

[ ]

al objeto o tipo de datos, o al nombre

de variable.
Ejemplos:
 String palabrasDificiles [ ];
Point hits [ ];
int donaciones [ ];

O bien:

String [ ] palabrasDificiles;
Point [ ] hits;
int [ ] donaciones;
 Creación de objetos de arreglos:

 Después de haber declarado la variable

arreglo, el siguiente paso es crear un
arreglo de objetos y asignarlo a esa
variable. Las formas de hacerlo son:
› a través del operador new
› inicializando directamente el contenido del
arreglo
Ejemplos:
String [ ] nombreJugadores = new String [10];
int [ ] temps = new int [99];

 Todas las posiciones se inicializan

automáticamente (0 para arreglos numéricos,
false para booleanos, “vacio” para arreglos de
carácter y null para objetos y Strings).

 También se puede crear e inicializar un
arreglo al mismo tiempo. Encierre los
elementos del arreglo entre llaves,
separándolos con comas:
String [ ] chiles = { “jalapeno”, “de árbol”,
“serrano”, “habanero”};

 Al crear elementos con valores iniciales, el

arreglo es del mismo tamaño que la
cantidad de elementos que ha incluido en
las llaves.
class ArregloNombres
{
String[ ] nombres = { “Daniel", “Alma", "Blanca", "Jaime"};
String[ ] apellidos = new String[nombres.length];
void imprime()
{
int i = 0;
System.out.println(nombres[i] + " " + apellidos[i]);
i++;
System.out.println(nombres[i] + " " + apellidos[i]);
i++;
System.out.println(nombres[i] + " " + apellidos[i]);
i++;
System.out.println(nombres[i] + " " + apellidos[i]);
}
 public static void main (String arguments[])
{
ArregloNombres a = new
ArregloNombres();
a.imprime();
System.out.println("-----");
a.apellidos[0] = “Guzman";
a.apellidos[1] = “Rodríguez";
a.apellidos[2] = “Duran";
a.apellidos[3] = “Cárdenas";
a.imprime();
}
}
 El tamaño de un arreglo se almacena
en la variable “length”, que puede ser
accesada a través del operador “.” y el
nombre del arreglo:

nombreArreglo.length
 Cuando se inicia un programa Java
desde una ventana de terminal, es
posible suministrarle uno, ninguno o
varios argumentos de la línea de
comandos. Estos argumentos permiten
al usuario especificar la información de
configuración de la aplicación.
 Los argumentos de la línea de
comandos son cadenas (String). Al
ejecutar el programa, después del
nombre de la clase, pueden incluirse los
argumentos y se almacenan en un array
de objetos String pasados al método
estático main, por ejemplo, el siguiente
programa muestra todos los argumentos
de la línea de comandos que se pasan
al programa:
public class Argumentos
{
public static void main(String[] args)
{
for (int i = 0; i < args.length; i++)
{
System.out.println("args[" + i + "] es: " +
args[i]));
}
}
}
 Un ejemplo de ejecución del programa sería:
java Argumentos uno Dos 3 cuatro 5.0 six

Y la salida:

args[0] es: uno

args[1] es: Dos
args[2] es: 3
args[3] es: cuatro
args[4] es: 5.0
args[5] es: six
 Las clases internas (también llamadas
clases anidadas) son clases declaradas
dentro de otra declaración de clases, y
se utilizan para crear objetos que
tengan acceso a las variables de
instancia de los objetos que los
contienen.
public class ClasesInternas
{
private class MiClaseInterna
{
private String etiqueta;

public MiClaseInterna(String etiqueta)

{
this.etiqueta=etiqueta;
}
public MiClaseInterna()
{
this.etiqueta="Soy un constructor sin parametros ";

}
 public void imprimeEtiqueta( )
{
System.out.println(this.etiqueta);
}
}

public ClasesInternas( )
{
MiClaseInterna uno=new MiClaseInterna("Soy un
constructor con parametros");
MiClaseInterna dos=new MiClaseInterna( );
uno.imprimeEtiqueta( );
dos.imprimeEtiqueta( );
}
}
public class PruebaClasesInternas
{
public static void main(String[] args)
{
ClasesInternas prueba = new
ClasesInternas();
}
}
 El lenguaje Java no considera los tipos
de datos primitivos como objetos, para
poder mantener la eficiencia en la
ejecución. Para poder manejar los
primitivos como objetos, Java
proporciona las llamadas clases
envolventes (wrapper).
 Los elementos primitivos quedan
envueltos por un objeto que se crea en
torno a ellos. Para cada tipo primitivo
existe una clase envolvente en el
paquete java.lang.