Buenas tardes, aquí os traigo la última parte del Capitulo 4, en el cual cubriremos los Arrays, las Enumeraciones, los tipos de dato en las variables, formas de nomenclatura de variables y unos usos prácticos de todo lo que hemos visto. Dicho esto podemos ponernos manos a la obra.
Arrays
Un array es una serie de variables del mismo tipo que pueden ser accedidas por un índice.
Los arrays son muy útiles cuando tienes un conjnto de datos que se van a usar de la misma manera. Los arrays pueden ser hechos con tipos de dato primitive o con objetos. Aunque un array sea de tipos de dato primitive, el operador new debe ser usado. Lo siguiente es un eemplo de un array de enteros o array de int:
int[] testScore = new int[3];
Ene ste ejemplo, declaramos una variable llamada testScore para que sea un array de enteros. Esto se hace añadiendo corchetes después del tipo de dato: int[].
Los [] después del tipo de dato hace que sea un array. Deberían seguir siempre al tipo de dato, pero es válido que vaya siguiendo al nombre de la variable. El standard de Java sugiere que se debería usar tras el tipo de dato.
Recordemos que aunque sea un array de tipo primitive, deben ser inicializados con el new. En el ejemplo, el array tiene 3 items, cada item es del tipo int, y cada elemento del array puede ser accedido, manipulado e incluso ser guardado en otra variable de tipo int. Los índices del array empiezan en el indice 0, es decir, el primer elemento está en el índice 0:
int[] testScore = new int[3]; testScore[0] = 98; testScore[1] = 100; testScore[2] = 72]; int shannonsTestScore = testScore[1];
Los arrays son muy útiles en los bucles. Es muy común tener acceso a un array en un bucle con una variable como índice (lo comunmente llamado contador). Esta variable será incrementada cada vez que el bucle acceda a un item.
El desarrollador debe tener cuidado de no usar un índice fuera del limite del array, o esto causará un error en tiempo de ejecución. Una vez que el tamaño del array es definido, no puede ser cambiado. Esto hace que los arrays sean menos útiles donde los datos puedan crecer.
Enumerations (Enumeraciones)
Las enumeraciones son un tipo de dato especial en Java que permite a una variable establecer constantes predeficinas cona nterioridad. La variable de ber igual a uno de los valores que han sido predefinidos para ella. Una enumeración es muy útil cuando hay un límite de opciones que se pueden estblecer en ella y estas estánr estringidas a estos valores que ya conocemos. Por ejemplo, una mano de juego de cartas tiene 4 palos: diamantes, corazones, espadas y picas.
Si un desarrollador quiere representar una carta, una enumeración podria ser usada para representar el palo:
enum Suit{CLUBS, DIAMONDS, HEARTS, SPADES}
Este código es un ejemplo de enumeración que podría ser usada para guardar la información sobre una carta en juego. Es definido con la palabra clave enum. Se usa de la misma manera que la palabra class. Puede ser definida en el mismo archivo Java o en el interior de una clase.
Suit cardSuit;
cardSuit=Suit.CLUBS;
if(cardSuit==Suit.CLUBS){
System.out.println("The suit of this card is clubs");
}
El ejemplo anterior demuestra el uso de una enumeración. La variable carta es declarada como Suit. Suit fué definida anteiorrmente como enumeración.
La variable cardSuit puede ahora ser usada para guardar uno de los 4 valores predefinidos.
Beneficio del uso de Enumerations
Un objeto puede ser creado para trabajar de la misma manera que una enumeración. Aunque las enumeraciones no existían en el lenguaje Java hasta la versión 5.0. Sin embargo, las enumeraciones pueden hacer el código mucho mas legible y provee menos opciones de errores para el programador.
Java is Strongly Typed
Java requiere que un desarrollador declare el tipo de dato de cada variable que usa. una vez que la variable ha sido declarada con algún tipo, toda la información que se guarde en ella debe ser compatible con ese tipo. Por ejemplo si declaramos una variable de tipo int, solo información de tipo int puede ser almacenada en ella.
Entendiendo las variables Strongly Typed
Las variables Strongly Typed ayudan a crear un código mas seguro. En la mayoría de los casos, el compilador de Java no permitirá al desarrollador pasar iandvertido a la hora de almacenar tipos de datos con tipos de dato diferentes.
Solo variables con el mismo tipo de dato son compatibles entre ellas. Por ejemplo un float no puede ser almacenado en una variable que no sea del tipo float. Lo mismo es válido para el resto de variables de tipo primitive u objetos.
La máquina virtual de Java (JVM hará conversiones automáticas para el desarrollador.
Un ejemplo deuna conversión sería el paso de un int a un float. La JVM permitirá a un int almacenarse en un float porque se puede convertir de int a float sin perder precisión. Sin embargo un float no puede ser convertido a un int sin perder precisión.
Convirtiendo variables a un tipo diferente
Java permite a una variable ser convertida a otro tipo de dato. Para esto, hay que poner el tipo de dato entre paréntesis delante del dato o la variable. Solo puede hacerse entre tipos de dato compatibles.
Si el dato se ha convertido de manera ilegal, el programa lanzará una excepción en tiempo de ejecución:
float floatNum=1.5f; int wasFloat = (int)floatNum;
La variable wasFloat será ahora igual a 1 ya que el .5 será truncado para que el dato sea compatible.
Nomenclatura de variables
Un uso correcto de las nomenclaturas mientras se crean aplicaciones en Java es un paso crítico para que el código sea de facil lectura y tenga un mantenimiento menos complicado. Java no tiene restricciones en como se deben llamar las clases y los objetos. Sin embargo, los desarrolladores de Java con mucha experiencia usan una nomenclatura sugerida por Sun MicroSystems.
Cuando se crea una clase, el nombre de la clase debe ser un nombre. La primera letra debe estar capitalizada, y si el nombre de la clase son varios nombres, la primera letra de cada nombre tambien debe de ir capitalizada. Los nombres de las clases deberían de ser cortos pero descriptivos.
Lo que vemos a continuación son algunos ejemplos de buenos nombres para las clases:
class SportCar{}
class BaseballPlayer{}
class CHannel{}
Las variables deben tener un nombre corto pero con sentido Sin embargo usar una letra para las variables de corta duración está permitido. En el caso de que sean nombres, estos deberán ofrecer una información a primera vista de lo que hará esa variable. El nombre de la variable debería empezar en minuscula pero cada secuencia de nombres en su interior debe contener la primera letra capitalizada.
A continuación se muestran unas variables nombradas con estas instruccion:
int milesPerGalon; float price; int i; Car raceCar;
Usos prácticos de tipos Primitive, Enumerations y Objects
El objetivo de esta sección es el desarrollo de código que use primitives, enumeration y referencias a objetos y reconocer los literales de estos tipos.
Esta sección se construye con los conceptos fundamentales que discutimos en apartados anteriores.
Literales
Un literal es el término usado para el uso de un valor dentro del código.
El siguiente ejemplo muestra el uso de literales:
int daysInMay = 31; int daysInJune; daysInJune = 30; char y = 'Y';
Aquí hemos usado 3 literales, 31, 30 y ‘Y’. Un literale s un valor que no es una variable.
Ejemplos de Primitive, Enumerations y Objects
En esta sección seremos proveidos de algunos ejemplos de todas las entradas que hemos cubierto. Cada ejemplo estará acompañado de una explicación.
public class EraCalculator {
public static void main(String[] args){
int earnedRuns = 3;
int inningsPitched = 6;
int inningsInAGame = 9;
float leagueAverageEra = 4.25f;
float era=((float)earnedRuns / (float) inningsPitched) * inningsInAGame;
boolean betterThanAverage;
if (era<leagueAverageEra){
betterThanAverage=true;
} else{
betterThanAverage=false;
}
char yesNo;
if(betterThanAverage){
yesNo= 'Y';
}else{
yesNo= 'N';
}
System.out.println("Earned Runstt" + earnedRuns);
System.out.println("Innings Pitchedtt" + inningsPitched);
System.out.println("ERAttt" + era);
System.out.println("Leage Average ERAt" + leagueAverageEra);
System.out.println("Is player better than league average " + yesNo);
}
}
Miremos la linea donde la variable “era” ha sido calculada, las 2 variables de tipo int “earnedRuns” y “inningsPitched”, son convertidas a float. La conversión a float es necesaria para que la división sea realizada en variables de tipo float en vez de su tipo de dato original int.
Las variables “earnedRuns”, “inningsPitched”, “inningsInAGame” y “leagueAverageEra” son definidas con literales. Este código de ejemplo era un ejemplo para trabajar con las variables de tipo primitive.
Primitive vs Wrapper Class
El segmento de código que sigue a continuación muestra como 4 variables están siendo declaradas. De los 4, 2 son primitives y otros 2 son objetos. Los objetos son instancias de una wrapper class.
Integer numberOfCats; Float averageWeightOfCats; int numberOfDogs; float averageWeightOfDogs;
En este código de ejemplo, int y float son tipos de dato primitive, mientras que Integer y Float son objetos.
Enumerations
El siguiente código muestra una clase pequeña. Esta clase tiene una enumeración definida que contiene tres tipos de zapatillas. El método createRunningShoes() es usado para establecer una variable con un tipo de enumeración:
public class EnumExample{
enum TypeOfShoe{RUNNING, BASKETBALL, CROSS_TRAINING}
TypeOfShoe shoe;
void createRunningShoes(){
shoe = TypeOfShoe.RUNNING;
}
}
Objects
Es importante conocer y entender el contenido de una clase y reconocerlo en el código. Es importante saber como usar métodos que contiene el objeto. En el siguiente ejemplo, se define una clase. Esta clase se llama heater. Como su nombre sugioere, se usa para representar un calentador. es una clase muy básica proque solo tiene 2 métodos y una variable. Una clase mas útil tendrá muchas mas variables y muchos mas métodos.
class Heater{
int temperatureTrigger;
int getTemperatureTrigger(){
return temperatureTrigger;
}
void setTemperatureTrigger(int temperatureTrigger){
this.temperatureTrigger = temperatureTrigger;
}
}
La clase Heater almacena una temperatura que disparará el sistema y lo activará con la llamada a la variable temperatureTrigger.
Los 2 métodos usados son para establecer un valor y retornar el valor.
Los siguientes segmentos de código usan la clase Heater para crear un objeto:
Heater houseHeater = new Heater(); houseHeater.settemperatureTrigger(68); System.out.println(houseHeater.getTemperatureTrigger());
Este código declara una nueva variable como un objeto Heater. El objeto es inicializado con el new. La siguiente línea usa el método setTemperatureTrigger para establecer una emperatura y modificar el estado del objeto. La línea final usa el gettemperatureTrigger para leer la temperatura y mostrarsela al usuario.
Hasta aquí este capítulo, en el que hemos dado un repaso a las clases básicas de Java y variables, un poco ver como funcionan entre sí, si se pueden convertir, y en este caso como hacerlo mejor y de forma mas segura.
En el siguiente capitulo veremos el ámbito de las variables (Variable Scope) y los métodos constructores.
Como siempre digo, cualquier aporte o corrección es bienvenida.
Saludos!!