¡Descarga Apuntes sobre el Lenguaje de Programacion Java Parte2 y más Apuntes en PDF de Informática solo en Docsity!
Cada espacio del arreglo guarda un elemento individual y se pueden colocar los elementos o cambiar el contenido de esos espacios según se necesite.
Los arreglos pueden tener cualquier tipo de valor de elemento (tipos primitivos u objetos), pero no se pueden almacenar diferentes tipos en un solo arreglo.
Es factible tener un arreglo de enteros o de cadenas o de arreglos, pero no se pueden tener arreglos de cadenas y enteros al mismo tiempo, por ejemplo.
CREACIÓN DE ARREGLOS EN JAVA
- Declarar una variable para guardar el arreglo.
- Crear un nuevo objeto de arreglo y asignarle a la variable de arreglo.
- Guardar lo que se desee en el arreglo. DECLARACION DE VARIABLES DE ARREGLO Se declaran indicando el tipo de objeto que el arreglo contendrá y el nombre del arreglo, seguido por corchetes vacíos.
. Ejemplos: String palabrasDifíciles[ ]; Point hits[ ]; int temps[ ]; Un método alterno es colocar los corchetes después del tipo, en lugar de enseguida de la variable. Este método es más legible.
. Ejemplos: String[ ] palabrasDifíciles; Point[ ] hits; int[ ] temps; CREACION DE OBJETOS DE ARREGLO - El segundo paso es crear un objeto de arreglo y asignarlo a esa variable. - Existen dos formas de hacerlo: Usar new Inicializar de manera directa el contenido de ese arreglo. - El primero implica el uso del operador new para crear una nueva instancia de un arreglo: String[ ] nombres = new String[10]; - Esta línea crea un nuevo arreglo de Strings con diez slots (casillas) conteniendo los elementos. - Cuando se crea un nuevo objeto de arreglo con new se deben indicar cuántas casillas tendrá ese
arreglo. Los objetos de arreglo pueden contener tipos primitivos o booleanos, de la misma forma que contienen objetos:
int[ ] temps = new int[99]; Cuando se crea un objeto de arreglo mediante el uso de new, todas sus casillas se inicializan con algún valor: 0 para arreglos numéricos, false para booleanos, `\0' para arreglos de caracteres y null para objetos.
- También se puede crear e inicializar un arreglo al mismo tiempo.
- En lugar de utilizar new, se encierran los elementos del arreglo dentro de llaves, separados por comas: String[ ] chiles = {jalapeno, anaheim, serrano, habanero, thai}; Cada elemento dentro del arreglo dentro de las llaves debe ser del mismo tipo y debe coincidir con el tipo de la variable que contiene ese arreglo.
Un arreglo del tamaño de elementos que se incluyeron se creará en forma automática; por ejemplo, en el caso anterior se crea un objeto String llamado chiles que contiene cinco elementos.
ACCESO A LOS ELEMENTOS DEL ARREGLO
- Para obtener un valor de un arreglo, se utiliza la expresión de arreglo subíndice: arreglo[subíndice];
- subíndice especifica la casilla a consultar dentro del arreglo. Los subíndices (subscripts) de arreglos inician con 0, por lo que un arreglo con 10 elementos, tendrá diez casillas a las cuales se puede tener acceso al utilizar los subíndices del 0 al 9.
Cuando se usan arreglos, se revisan todos los subíndices del arreglo para asegurarse de que estén dentro de su frontera: igual o mayor a cero y menor o igual a n−1, donde n es la longitud del arreglo, ya sean cuando se compila el programa o cuando se ejecuta.
En Java no se puede tener acceso a asignar un valor a una casilla del arreglo fuera de las fronteras de éste. Ejemplo:
String[ ] arr = new String[10]; arr[10] = enunciado; Este último enunciado produce un error de compilación puesto que el arreglo arr sólo tiene 10 casillas, numeradas de 0 a 9. El elemento arr[10] no existe.
Si el subíndice del arreglo se calcula al momento de la ejecución (por ejemplo, como parte de un ciclo) y está fuera de las fronteras del arreglo, el intérprete Java también produce un error, es decir, lanza una excepción.
Para evitar cometer estos errores en forma accidental, se puede examinar la longitud del arreglo utilizando la variable de instancia length, que está disponible para todos los objetos de arreglo sin importar el tipo:
int len = arr.length // retorna el valor 10 ASIGNACION DE VALORES A ELEMENTOS DE UN ARREGLO
- Para asignar un valor de elemento a una casilla de un arreglo, se usa un enunciado de asignación:
else enunciado Ejemplos : if (x < y) System.out.println(x es menor que y); if (x < y) System.out.println(x es menor que y); else System.out.println(y es menor que x); if (engineState == true) System.out.println(El motor ya está encendido.); else { System.out.println(Encendiendo el motor.); if (gasLevel >= 1) engineState = true; else System.out.println(Sin gasolina! No se enciende el motor.); } Este ejemplo utiliza la prueba (engineState == true). Para pruebas booleanas de este tipo, una forma común es incluir la primera parte de la expresión en lugar de hacerlo en forma explícita y probar su valor contra verdadero o falso:
if (engineState) System.out.println(El motor está encendido.); else { System.out.println(El motor está apagado.); EL OPERADOR CONDICIONAL Una alternativa para utilizar las palabras clave if y else en un enunciado condicional es usar el operador condicional, también conocido como el operador ternario.
- El operador condicional es un operador ternario porque tiene tres términos. Este operador es una expresión, es decir regresa un valor (a diferencia del if más genérico que sólo puede resultar en un enunciado o bloque que se ejecute).
- El operador condicional es más útil para condicionales muy cortos o sencillos, y tiene este formato: prueba? resultadoverdadero : resultadofalso La prueba es una expresión que regresa true o false. Si la prueba es verdadera, el operador condicional regresará el valor de resultadoverdadero y si es falsa, regresará el valor de resultadofalso.
Ejemplo: int smaller = x < y? x : y; En este ejemplo, se prueban los valores de x e y, regresando el más pequeño de los dos y asignándolo a la variable smaller.
CONDICIONALES SWITCH
Se los utiliza para evitar hacer if's anidados cuando se quiere comparar una variable contra algún valor.
- Formato: switch (prueba) { case valorUno: sentenciaUno; break; case valorDos: sentenciaDos; break; case valorTres: sentenciaTres; break; .... default: sentenciaDefault; } Con esta estructura de programación, la prueba (que puede ser byte, char, short o int) se compara con cada uno de los valores en turno.
- Si es igual, se ejecuta la sentencia o sentencias después de la prueba; si no es igual, se ejecutará la
case 6: case 8: System.out.println("x es un número par."); break; default: System.out.println("x es un número impar."); CICLOS for El ciclo for repite una declaración o bloque de enunciados un número de veces hasta que una condición se cumple.
Estos ciclos con frecuencia se usan para una iteración sencilla en donde se repite un bloque de enunciados un cierto número de veces y después se detiene, aunque también se los puede usar para cualquier clase de ciclo.
- Formato: for (inicialización; test; incremento) { sentencias; }
- El inicio del ciclo for tiene tres partes: inicialización es una expresión que inicializa el principio del ciclo. Si se tiene un índice, esta expresión puede ser declarada e inicializada, int i = 0. Las variables que se declaran en esta parte del ciclo son locales al ciclo: dejan de existir después de acabar la ejecución del mismo.
test es la prueba que ocurre después de cada vuelta del ciclo. La prueba debe ser una expresión booleana o una función que regresa un valor booleano, por ejemplo, i < 10. Si la prueba es verdadera, el ciclo se ejecuta; cuando es falsa, el ciclo detiene su ejecución.
incremento es una expresión o llamada de función. Por lo común, el incremento se utiliza para cambiar el valor del índice del ciclo a fin de acercar el estado del ciclo a false y que se complete.
Dentro del ciclo for existen sentencias que se ejecutan cada vez que se itera el ciclo. Al igual que con if, se puede incluir un solo enunciado o un bloque; en este último caso, como se sabe, se lo empieza y termina con llaves ({ }).
- Ejemplo. ciclo for para inicializar todos los valores de un arreglo String para cadenas vacías: String strArray [ ] = new String[10]; int i; // índice del lazo for (i = 0; i < strArray.length; i++) strArray[i] = ""; Cualquier parte del ciclo for puede se un enunciado vacío, esto es, puede incluir sólo un punto y coma sin ninguna expresión o declaración, y esa parte del ciclo se ignorará.
También puede tenerse un enunciado vacío para el cuerpo del ciclo for, si todo lo que se desea hacer se encuentra en la primera línea. Por ejemplo, aquí está una que encuentra el primer número primo mayor que 4000:
for (i = 40001; notPrime(i); i +=2) ; CICLOS while y do Estos ciclos permiten también a un bloque de código ejecutarse de manera repetida hasta encontrar una condición específica. Utilizar uno de estos tres ciclos es, por lo general, una cuestión de estilo de programación.
Los ciclos while y do son exactamente los mismos que en C y C++, a excepción de que su condición de prueba debe ser un booleano.
CICLOS while
- Se utilizan para repetir un enunciado o bloque de enunciados, mientras una condición sea verdadera.
- Formato: while (condición) { cuerpoDelLazo; } La condición es una expresión booleana. Si regresa true, el ciclo while ejecuta los enunciados en cuerpoDelLazo y después prueba la condición hasta que ésta sea falsa. También se puede emplear un enunciado sencillo en lugar del bloque.
- Ejemplo. Inicialización y escritura de un vector: int [ ] A = new int[10]; for (int j = 0; j < A.length; j++) A[ j ] = j + 2; int i = 0; while (i < A.length) System.out.println("A[ " + i + " ] = " + A[i]);
- Si la condición la primera vez que se prueba es falsa, el cuerpo del ciclo while nunca se ejecutará. Para este caso, cuando se desee que una iteración se ejecute por lo menos una vez, se utiliza el ciclo do ... while, como se explica a continuación.
CICLOS do ... while El ciclo do es como el ciclo while, excepto que ejecuta un enunciado o bloque dado hasta que la condición es false.
La principal diferencia es que los ciclos while prueban la condición antes de realizar el ciclo, lo cual hace posible que el cuerpo del ciclo nunca se ejecute si la condición es falsa la primera vez que se prueba.
- Los ciclos do ejecutan el cuerpo del ciclo por lo menos una vez antes de probar la condición.
- Para los ciclos for, la expresión de incremento se evalúa y después el bloque se ejecuta.
- continue es útil cuando se desea tener elementos especiales de condición dentro de un ciclo. Usando el ejemplo anterior, se puede probar si el elemento actual es 0 y reiniciar el ciclo si lo encuentra, para que el arreglo resultante nunca contenga cero. Obsérvese que puesto que en el primer arreglo se saltan los elementos, ahora se tiene que seguir a dos diferentes contadores de arreglos:
int count1 = 0; int count2 = 0; while (count1 < array1.length) { if (array1[count1] ==0) { count1++; continue; } array2[count2++] = (float) array1[count1++]; } CICLOS ETIQUETADOS
- Tanto break como continue pueden tener una etiqueta opcional que le indique a Java dónde detenerse. Sin una etiqueta, break saltará hacia el ciclo más cercano (a uno envolvente o al siguiente enunciado fuera del ciclo) y continue reinicia el ciclo envolvente.
Utilizar estas instrucciones etiquetadas, permite salirse de ciclos anidados o continuar un ciclo fuera del actual.
Para utilizar un ciclo etiquetado, se agrega la etiqueta antes de la parte inicial del mismo, con dos puntos entre ellos.
Después, cuando se utilice break o continue, se agrega el nombre de la etiqueta, después de la palabra clave:
out: for (int i = 0; i < 10; i++) { while (x < 50) { if (i * x == 400) break out;
... } ...
En este recorte de código, la etiqueta out marca el ciclo externo. Entonces, dentro de los ciclos for y while, cuando una condición particular se cumple, un break ocasiona que la ejecución se salga de ambos ciclos.
El siguiente programa contiene un ciclo anidado for. Dentro del ciclo más profundo, si los valores sumados de los dos contadores es mayor que cuatro, ambos ciclos se abandonan al mismo tiempo:
foo: for (int i = 1, i <= 5; i++) for (int j = 1; j <= 3; j++) { System.out.println(" i es " + i + ", j es " + j); if (i + j) > 4) break foo; } System.out.println("fin de lazos"); Salida del programa: i es 1, j es 1 i es 1, j es 2 i es 1, j es 3 i es 2, j es 1 i es 2, j es 2 i es 2, j es 3 fin de lazos Como se puede ver, el ciclo se iteró hasta que la suma de i y j fue mayor que 4 y después ambos regresaron al bloque externo y el mensaje final se imprimió.
CAPITULO 6: CREACION DE CLASES Y APLICACIONES EN JAVA
Objetivos:
- Definir clases
- Declarar y usar variables de instancia
- Definir y usar métodos Crear aplicaciones Java, incluido el método main() y cómo pasar argumentos a un programa Java desde una línea de comandos
currentGearFront y currentGearRear: las velocidades actuales de la bicicleta están tanto en el frente como en la parte trasera.
CONSTANTES
Las constantes son útiles para definir valores comunes para todos los métodos de un objeto (dar nombres significativos a valores de objetos generales que nunca cambiarán).
En Java se pueden crear constantes sólo para variables de instancia o de clase, no para variables locales.
- Una variable constante o constantes es un valor que nunca cambia. Para declara una constante, se utiliza la palabra clave final antes de la declaración de la variable y se incluye un valor inicial para esa variable:
final float pi = 3.141592; final boolean debug = false; final int maxsize = 40000; VARIABLES DE CLASE
- Son globales para todas sus instancias de clase. Son usadas para la comunicación entre diferentes objetos con la misma clase, o para rastrear los estados globales de entre una serie de objetos.
- Se usa la palabra reservada static. static int sum; static final int maxObjects = 10; CREACION DE METODOS
- Los métodos son usados para definir el comportamiento de un objeto. Definición de métodos
- Constan de cuatro partes básicas:
- El nombre del método
- El tipo de objeto o tipo primitivo que el método regresa.
- Una lista de parámetros
- El cuerpo del método En Java se puede tener más de un método con el mismo nombre, pero con un tipo de retorno o lista de argumentos diferente.
Formato: tipoderetorno nombre (tipo1 arg1, tipo2 arg2, tipo3 arg3, ...) { .... }
El tipoderetorno es el tipo primitivo o clase del valor que este método regresa. Puede ser uno de los tipos primitivos, un nombre de clase o void si no regresa un valor.
Si el método regresa un objeto de arreglo, las llaves del arreglo van después del tipo de retorno o después de la lista de parámetros: se usará la primera forma porque es más fácil de leer:
int [ ] hacerRango (int lower, int upper) { ... } La lista de parámetros del método es un conjunto de declaraciones de variables separadas por comas dentro de los paréntesis.
Estos parámetros se vuelven variables locales en el cuerpo del método, cuyos valores son los objetos o los valores primitivos transmitidos cuando se llama al método.
Dentro del cuerpo de un método se pueden tener enunciados, expresiones, llamadas de métodos a otros objetos, condicionales, ciclos y demás.
Si el método tiene un tipo de retorno, en algún lugar dentro del cuerpo del método se necesitará regresar un valor. Se debe usar la palabra clave return para hacer esto.
Ejemplo: método que toma dos enteros (un límite inferior y uno superior) y crea un arreglo que contiene todos los enteros entres los dos límites, incluidos los límites:
class RangeClass { int [ ] makeRange (int lower, int upper) { int arr [ ] = new int [ (upper. lower) + 1 ]; for (int i = 0; i < arr.length; i++) { arr [i ] = lower++; } return arr; } public static void main (String args[ ] ) { int theArray[ ]; RangeClass theRange = new RangeClass(); theArray = theRange.makeRange(1,10); System.out.print(El arreglo: [ ); for (int i = 0; i < theArray.length; i++) { System.out.print(theArray [i ] + ) } System.out.println(]);
int test = 10; void printTest(){ int test = 20; System.out.println(test = + test); } } PASO DE ARGUMENTOS A LOS METODOS En el paso de objetos como argumentos, las variables se pasan como referencias, lo que implica que lo que se les haga a esos objetos dentro del método afectará los objetos originales también.
- Esto incluye a los arreglos y a todos los objetos que los arreglos contienen.
- Cuando se pasa un arreglo a un método y modifica su contenido, el arreglo original se ve afectado.
- Los tipos de datos primitivos, en cambio, se pasan por valor.
- Ejemplo: class PassByReference { int OnetoZero (int arg[ ]) { int count = 0; for (int i = 0; i < arg.lenth; i++) { if (arg [ i] == 1) { count++; arg [ i] = 0; } } return count; } }
- El método onetoZero realiza dos acciones:
- Cuenta el número de unos en el arreglo y regresa ese valor.
- Si encuentra un uno, lo sustituye por un cero en el arreglo. El siguiente programa muestra el método main() para la clase PassByReference, el cual prueba el método onetoZero:
public static void main(String args [ ]) {
int arr[ ] = { 1,3,4,5,1,1,7 }; PassByReference test = new PassByReference(); int numOnes; System.out.print(Valores del arreglo: [ ); for (int i = 0; i < arr.length; i++) { System.out.print(arr}; } Sytem.out.println( ] ); numOnes = test.OnetoZero(arr); System.out.println(Número de Unos = + numOnes); System.out.print(Nuevos valores del arreglo: [ ); for (int i = 0; i < arr.length; i++) { System.out.print(arr[ i] + ); } System.out.println( ] ); } Salida del programa: Valores del arreglo: [ 1 3 4 5 1 1 7 ] Número de unos = 3 Nuevos valores del arreglo: [ 0 3 4 5 0 0 7 ] METODOS DE CLASE Los métodos de clase están disponibles para cualquier instancia de la clase misma así como en otras clases. En consecuencia, algunos métodos de clase se usan en cualquier lugar, sin importar si una instancia de la clase existe o no.
Para definir los métodos de clase, se emplea la palabra clave static al frente de la definición del método.
static int max (int arg1, int arg2) COMO CREAR APLICACIONES JAVA
