Curso de Java – FastTrack

Curso de Java – FastTrack

Preparado con base en los Cursos
SL-110 y SL-275 de Sun® Microsystems

Módulo 4

“Expresiones y Control de Flujo, Uso de Operadores y

Construcciones del Lenguaje de Programación Java
Control de Flujo (decisión) y Ciclos, Arreglos
 Curso de Java – FastTrack

Identificando Uso de Variables y Sintáxis

Usted usa variables para almacenar y recuperar datos en su programa.
El siguiente código de ejemplo muestra como la clase Shirt declara
algunos tributos variables:
1. public class Shirt
2.
3. public int shirtId = 0; // el Id por defecto para una Shirt Camisa
4. public String description = “- descripción requerida”; // por defecto
5.
6. // los códigos de color son R=Red B=Blue U=Unset
7. public char colorCode = ‘U’;
8.
9. public double price = 0.0; // precio por defecto para todas las Shirt
10.
11. public int quantityInStock = 0; //
12.
13. // este método muestra por pantalla los valores de los items
14. public void dispayShirtInformation() {
15.
16. System.out.println(“Shirt Id: “ + shirtId) ;
17. System.out.println(“Shirt Description: “ + description) ;
18. System.out.println(“Color Code: “ + colorCode) ;
19. System.out.println(“Shirt price: “ + price) ;
20. System.out.println(“Quantity in stock: “ + quantityInStock) ;
21. } // fin del metodo Display
22. } // fin de la clase
 Curso de Java – FastTrack

Identificando Uso de Variables y Sintáxis

Atributos variables (las variables declaradas fuera de un método y sin la
palabra clave static ) son también llamadas variables miembro o
variables de instancia (como price, shirtID y colorCode en la clase
Shirt), cuando un objeto es instanciado desde una clase, esas variables
contienen datos especificos para esa particular instancia de la clase,
cuando un objeto es instanciado desde la clase esas variables son
llamadas variables de instancia porque ellas pueden contener datos
específicos para esa particular instancia de la clase. Por ejemplo una
instancia de la clase Shirt podría tener 7 asignado en el atributo
variable quantityStock y otra variable de instancia podria tener 100 en
en el atributo variable quantityStock.
 Curso de Java – FastTrack

Identificando Uso de Variables y Sintáxis

Su programa prodria tener variables definidas dentro de un método, esas
variables son llamadas, variables locales porque ellas solo están
disponibles en el método en el cual fueron declaradas. En la clase Shirt
no hay variables locales pero si hubiesen deberían estar declaradas
dentro del método displayShirtInformation.

• public void dispayShirtInformation() {

• int shirtQSTmp = quantityInStock; //Por ejemplo
• System.out.println(“Shirt ID: “ + shirtID) ;
• System.out.println(“Shirt Description: “ + description) ;
• System.out.println(“Color Code: “ + colorCode) ;
• System.out.println(“Shirt price: “ + price) ;
• System.out.println(“Quantity in stock: “ + quantityInStock) ;
• } // fin del metodo Display
 Curso de Java – FastTrack

Identificando Uso de Variables y Sintáxis

Uso de las Variables
Las variables son usadas extensivamente en el lenguaje de
programación
Java para realizar las siguientes tareas:
• Manejar atributos de datos unicos para una instancia de un objeto
(como por ejemplo las variables price e ID).
• Asignación de valores de una variable a otra.
• Representación de valores en expresiones matemáticas.
• Impresión de valores por pantalla. Por ejemplo, la clase Shirt usa las
variables precio e ID para imprimir los valores precio e ID de la
clase Shirt.
System.out.println(“Shirt ID: “ + shirtID) ;
System.out.println(“Shirt price: “ + price) ;
• Manejar referencias a otros objetos
 Curso de Java – FastTrack

Identificando Uso de Variables y Sintáxis

Variables declaración e inicialización
Atributos variables declaración e inicialización sintáxis:
[modificador] tipo identificador = valor;
Las variables locales pueden ser declaradas en inicializadas en líneas
separadas o en una misma línea.
Líneas separadas:
tipo identificador;
identificador = valor;
Misma línea:
tipo identificador = valor;

Nota : No use modificadores con las variables locales ( variables

declaradas dentro de los metodos)
 Curso de Java – FastTrack

Identificando Uso de Variables y Sintáxis

Las Siguientes son las declaraciónes de los atributos variables en la
clase Shirt

public int shirtId = 0;

public String description = “- descripción requerida”;
public char colorCode = ‘U’;
public double price = 0.0;
public int quantityInStock = 0;
Curso de Java – FastTrack

Auto Chequeo – Seleccione las asignaciones y

declaraciones de atributos variables que se
adhieren a la sintáxis vista anteriormente.

c. X
___ public int myInteger = 10;
d. X
___ long myLong;
e. ___ long = 10;
f. ___ private int = 100
g. X
___ private int myInteger = 10;

.
Curso de Java – FastTrack

Auto Chequeo – Defina el término “atributos variables”

o “variables de instancia”
Variables declaradas en la clase
fuera de los métodos y que no
son estáticas también llamadas
variables miembros o variables
Respuesta __________________________________
de instancia contienen los datos
particulares de una instancia de
una clase
Curso de Java – FastTrack

Auto Chequeo – Defina el término “variable local”

Variables declaradas dentro de

un método no puede tener un
Respuesta __________________________________
modificador
Curso de Java – FastTrack

Auto Chequeo – Cuantos y cuales tipos primitivos de

variables existen en el lenguaje de
programación en Java.

Son 8 tipos de variables

categorizadas como sigue
Lógicos – boolean
Texto – char
Integrales – byte, short, int y
Respuesta __________________________________
long
Punto Flotante – double y float
Curso de Java – FastTrack

Auto Chequeo – Enlace los tipos con su correspondiente

tamaño en bits.

Tipo de Datos Tamaño en bits

double 8
char 16
int 32
byte 64
 Curso de Java – FastTrack

Palabras Claves de Tecnología Java

__________________________________________________________________________________________________________________

abstract do implement protected

throws
boolean double import public
transient
break else instanceof
return true
byte extends int short
try
case false interface
static void
catch final long strictfp
volatile
char finally native super
 Curso de Java – FastTrack

Identificando Uso de Variables y Sintáxis

Las Siguientes son las declaraciónes de los atributos variables en la
clase Shirt

public int shirtId = 0;

public String description = “- descripción requerida”;
public char colorCode = ‘U’;
public double price = 0.0;
public int quantityInStock = 0;
 Curso de Java – FastTrack

Declaración de Variables y Asignación de Variables

Usted puede asignar una valor a una variable en el momento que la
variable es declarada o usted puede asignar la variable después.
El operador igual (=) asigna el valor del lado derecho a el item de el
lado izquierdo, el operador (=) debería ser leído como
“es asignado a” .

Nota – Los atributos variables son automaticamente inicializados:

los tipos integrales a 0, los punto flotante a 0.0, los char a \u0000 y
los boolean a false, sin embargo usted debería inicializar
explícitamente sus atributos variables de forma tal que otras
personas puedan leer y comprender su código. Las variables
locales (declaradas dentro de un método) tienen que ser inicializadas
explicitamente antes de ser usadas.
 Curso de Java – FastTrack

Declaración de Variables y Asignación de Variables

Declarando mas de una variable en una línea de codigo
tipo identificador = valor [, identificador = valor];
Ejemplo:
double price = 0.0, wholesalePrice = 0.0;
Asingnando valores a variables desde otra variable
int ID = 0;
int saleID = ID;
Asignación de expresiones a variables
float numberOrdered = 908.5F;
float casePrice = 19.99F;
float price = (casePrice * numberOrdered);
int hour = 12;
boolean isOpen = (hour >8);
 Curso de Java – FastTrack

Declaración de Variables y Asignación de Variables

Constantes
Hasta ahora usted ha aprendido a usar variables a las cuales le puede
cambiar el valor. En esta sección usted aprenderá como usar constantes
para representar valores que no pueden ser cambiados.
Asuma que ested quiere escribir una parte del programa cloting catalog
y el impuesto de las ventas debe ponerse una vez y debe permanecer
constante durante la aplicación. por consiguiente el valor debería
guardarse de forma tal que no se pueda cambiar.
double salesTax = 6.25
Por lo tanto haga la variable constante usando la palabra clave final que
Informa al compilador que esta variable no puede ser cambiada una vez
Inicializada, los nombres de las constantes debe ser en mayúsculas
separando las palabras en caso de ser más de una con underline (_)
final double SALES_TAX = 6.25;
 Curso de Java – FastTrack

Declaración de Variables y Asignación de Variables

Cuando usted usa valores literales o crea una variable o constante y asigna a este un
valor , el valor es almacenado en la memoria del computador

Variables declaradas Objetos con sus

dentro de un método atributos variables

Stack Memory Heap Memory

pila

Los objetos, sus atributos y métodos son usualmente almacenados en la memoria heap,
la memoria heap es dinámicamente reservada con pedazos de distintos tamaños de
información que permiten manejar los objetos de forma dinámica (incluyendo los
atributos variables y métodos) mientras estos son necesitados por su programa, otras
variables son usualmente almacenadas en la memoria stack, la memoria stack almacena
items tal que solo tal que solo sean usadas un periodo corto de tiempo (mas corto que la
vida de un objeto) como son las variables declaradas dentro de un método.
 Curso de Java – FastTrack

Alcance de Variables Ejemplo

public class ScopeExample { Pila de Ejecución
private int i=1;
public void firstMethod() {
int i=4, j=5;
this.i = i + j;
secondMethod(7);
} j 8
Memoria Heap
public void secondMethod(int i) {secondMethod i 7
int j=8; this
this.i = i + j; ScopeExample
j 5
} i 1
firstMethod
} i 4

this
public class TestScoping { main scope
public static void main ( String[] args) {
ScopeExample scope = new ScopeExample();
scope.firstMethod();
}
}
 Curso de Java – FastTrack

Operadores Lógicos
• Los operadores booleanos son:
! – NOT & - AND
| - OR ^-XOR
• Los operadores booleanos de corto circuito son:
&& - AND || - OR
• Usted puede usar estos operadores como sigue:
MyDate d;
If ( ( d != null ) && ( d.day > 31) )
// hacer algo con d
}
 Curso de Java – FastTrack

Operadores Lógicos Bitwise

• Los operadores enteros bitwise son:
~ – Complement & - AND
^- XOR | - OR
• Ejemplos tamaño byte:
0 0 1 0 1 1 0 1
~ 0 1 0 0 1 1 1 1 & 0 1 0 0 1 1 1 1
1 0 1 1 0 0 0 0 0 0 0 0 1 1 0 1

0 0 1 0 1 1 0 1 0 0 1 0 1 1 0 1
^ 0 1 0 0 1 1 1 1 | 0 1 0 0 1 1 1 1
0 1 1 0 0 0 1 0 0 1 1 0 1 1 1 1
 Curso de Java – FastTrack

Operador Mover a la Derecha “Right-Shift” >> y >>>

• El operador aritmético o mover a la derecha
“right-shift” (>>) es usado de la siguiente forma:
128 >> 1 retorna 128 / 21 = 64
256 >> 4 retorna 256 / 24 = 16
- 256 >> 4 retorna -256 / 24 = -16
▼ El bit del signo es copiado durante el movimiento

• El operador lógico o mover a la derecha sin sign

“unsigned right-shift” (>>>) es :
▼ Usado para patrones de bit

▼ El bit del signo no es copiado durante la operación

de movimiento
 Curso de Java – FastTrack

Operador Mover a la Izquierda “Left-Shift” <<

• El operador mover a la izquierda “left-shift” (<
trabaja de la siguiente forma:
128 << 1 retorna 128 * 21 = 256
256 << 2 retorna 16 * 22 = 64
 Curso de Java – FastTrack

Operador de Movimiento “Shift Operator” Ejemplos

1357 = 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 1 0 1 0 0 1 1 0 1

-1357 = 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 1 0 1 0 1 1 0 0 1 1

1357 >> 5 = 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 1 0 1 0

-1357 >> 5 = 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 1 0 1 0 1

1357 >>> 5 = 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 1 0 1 0

-1357 >>> 5 = 0 0 0 0 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 1 0 1 0 1

1357 << 5 = 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 1 0 1 0 0 1 1 0 1 0 0 0 0 0

-1357 << 5 = 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 1 0 1 0 1 1 0 0 1 1 0 0 0 0 0
 Curso de Java – FastTrack

Concatenación de Cadenas “String” con +

• El operador +
▼ Permite la concatenación de String

▼ Produce una nueva String

String salutation = “Dr.”;
String name = “Pete” + “ “ + “Seymour”;
String title = salutation + “ “ + name;

• Un argumento debe ser un objeto String

• Los No-String son convertidos a objetos String
automáticamente.
 Curso de Java – FastTrack

Casting
• Si en una asignación puede perderse información,
el programador puede confirmar la asignación
con un cast.
• La asignación entre un long y un int requiere un cast
explícito
long bigValue = 99L;
int squashed = bigValue; // mál, necesita un cast
int squashed = (int) bigValue; // ok

int squashed = 99L; // mál, necesita un cast

int squashed = (int) 99L; // ok, pero ...
int squashed = 99; // literal entero por defecto
 Curso de Java – FastTrack

Promoción y Casting de Expresiones

• Las variables son automáticamente promovidas a un
tamaño más grande (como int a long)
• Las expresiones son compatibles a asignaciones si los
tipos de variables son por lo menos tan grande (el mismo
número de bits) como el tipo de la expresión.
long bigval = 6; // es un tipo entero, ok
int smallval = 99L; // 99L es un long, ilegal

double z = 12.414F; // 12.414 es float, ok

float z1 = 12.414; // 12.414 es doble , ilegal
 Curso de Java – FastTrack

Instrucciones de Bifurcación
• Sintaxis de la instrucción if, else.
if ( expresión booleana ) {
instrucción o bloque;
}

if ( expresión booleana ) {
instrucción o bloque;
} else {
instrucción o bloque;
}
 Curso de Java – FastTrack

Instrucciones de Bifurcación
• switch ...
 Curso de Java – FastTrack

Instrucciones de Ciclo
El ciclo for :
for ( expr_inicialización ; boolean expr_testeo ;
expr_alteración ) {
instrucción o bloque;
}

Ejemplo:
for ( int i = 0 ; i < 10 ; i++ ) {
System.out.println(“¿Ud. Todavía no finalizó?”);
}
System.out.println(“¡Finalmente!”);
 Curso de Java – FastTrack

Instrucciones de Ciclo
El ciclo while :
while (boolean) {
instrucción o bloque;
}

Ejemplo:

i = 0;

while (i < 10) {

System.out.println(“¿Ud. Todavía no finalizó?”);
i++
}
System.out.println(“Hecho”);
 Curso de Java – FastTrack

Instrucciones de Ciclo
El ciclo do/while :
do {
instrucción o bloque;
} while (boolean test);

Ejemplo:

i = 0;

do {
System.out.println(“¿Ud. Todavía no finalizó?”);
i++
} while (i < 10);
System.out.println(“Hecho”);
 Curso de Java – FastTrack

Controles Especiales de Flujo de Ciclo

• break [label] ;
• continue [label] ;
• label: instrucción; // donde la
instrucción debe ser
un ciclo
 Curso de Java – FastTrack

Declaración de Arreglos
• Agrupa Objetos de Datos en mismo tipo.
• Declara los arreglos de tipo primitivo o clases
• Las variables locales requieren de una inicialización
explícita
• Crea spacio para una referencia
• Un Arreglo es un objeto; este es creado con new.
 Curso de Java – FastTrack

Creando Arreglos
Usa la palabra clave new para crear un arreglo de objetos :

Por ejemplo, un arreglo del primitivos (char) :

public char[] createArray() {
Pila de Ejecución
char[ ] s;
s = new char[26]; Memoria Heap
for (int i=0; i<6; i++) {
s[i] = (char) (‘A’ + i);
} char[]
A
B
return s;
C
}
D
s
createArray
this Z

main
 Curso de Java – FastTrack

Creando Arreglos
Otro ejemplo, un arreglo de objetos :
public Point[ ] createArray() {
Point p[ ];

p = new Point[10]; Pila de Ejecución

for ( int i=0; i<10; i++ ) {
Memoria Heap
p[i] = new Point(i, i+1);
}
Point
Point[] x 0
return p; y 1
Point
} x 1
y 2
p
firstMethod Point
this x 2
main y 3
 Curso de Java – FastTrack

Inicializando Arreglos
• Inicializando elementos del arreglo
• Creando un arreglo con valores iniciales

String names[]; String names[] = {

names = new String[3]; “Georgiana”,
names[0] = “Georgiana”; “Jen”,
names[1] = “Jen”; “Simon”
names[2] = “Simon”; };

MyDate dates[]; MyDate dates[] = {

dates = new MyDate[3]; new MyDate(22, 7, 1964),
dates[0] = new MyDate(22, 7, 1964); new MyDate(1, 1, 2000),
dates[1] = new MyDate(1, 1, 2000); new MyDate(22, 12, 1964)
};
dates[2] = new MyDate(22, 12, 1964);
 Curso de Java – FastTrack

Arreglos Multidimencionales
• Arreglos de arreglos
int twoDim [ ] [ ] = new int [ 4 ] [ ] ;
twoDim[ 0 ] = new int [ 5 ];
twoDim[ 1 ] = new int [ 5 ];

int twoDim [ ] [ ] = new int [ ] [ 4 ]; ilegal

 Curso de Java – FastTrack

Arreglos Multidimencionales
• Arreglos de arreglos no rectangulares

twoDim[ 0 ] = new int [ 2 ];

twoDim[ 1 ] = new int [ 4 ];
twoDim[ 2 ] = new int [ 6 ];
twoDim[ 3 ] = new int [ 8 ];

• Arreglo de cuatro arreglos de cinco enteros cada uno

int twoDim[ ] [ ] = new int [ 4 ] [ 5 ] ;

 Curso de Java – FastTrack

Límites de los Arreglos

• Todos los sub-índices de los arreglos comienzan en 0:

int list[ ] = new int [ 10 ] ;

for ( int i = 0 ; i < list.length ; i++ ) {
System.out.println( list [ i ] );
}
 Curso de Java – FastTrack

Redimensionando Arreglos
• No se puede redimensionar un arreglo
• Puede usar la misma variable de referencia para referen-
ciar a un nuevo arreglo completamente

int myArray[ ] = new int [ 6 ];

myArray = new int [ 10 ];
 Curso de Java – FastTrack

Copiando Arreglos
• El método System.arraycopy() :

// arreglo ariginal
int elements [ ] = { 1, 2, 3, 4, 5, 6 };

// nuevo arreglo grande

int hold [ ] = { 10, 9, 8, 7, 6, 5, 4, 3, 2, 1 };

// copia todos los elementos del arrego elements al arreglo hold ,

// comenzando con el índice 0.
System.arraycopy ( elements, 0, hold, 0, elements.length );
 Curso de Java – FastTrack

Arreglos
Declaración:

La sintaxis para declarar un arreglo es:

<tipo>[] <nombre del arreglo>
<tipo> <nombre del arreglo>[]
<tipo> []<nombre del arreglo>
<tipo> puede ser un primitivo o referencia
Nota: El tamaño del arreglo no se indica.
Si un arreglo es miembro y solo se declara, sea de instancia o estático
este será inicializado por defecto a null (por tratarse de una referencia)
Esto no se aplica a variables locales.
Nota: En declaraciones múltiples del tipo:
<tipo>[] Var1, Var2, Var3
Donde Var1 y Var2 y Var3 son arreglos.
<tipo> Var1[], Var2, Var3
Donde Var1 es arreglo, Var2 y Var3 son variables normales.
 Curso de Java – FastTrack

Arreglos
Construcción:

La sintaxis para construir un arreglo es:

<nombre del arreglo> = new <tipo> [numero de elementos]
el numero mínimo de elementos es: 0
Se puede combinar la declaración y construcción:
<tipo1> <nombre del arreglo> = new <tipo2> [numero de elementos]
<tipo2> debe ser "asignable" a <tipo1>. Ver 6.5
Cuando el arreglo es construido, todos los elementos son inicializados
al valor por defecto de <tipo2>. Esto es valido para variables de tipo
miembro y locales.
Se asigna a la variable de instancia length (del arreglo) el valor de
número de elementos usado en la construcción.
 Curso de Java – FastTrack

Arreglos
Inicialización:

-Java permite la declaración, construcción e inicialización por defecto en una sola

instrucción de lenguaje.
<tipo>[] <nombreArreglo> = {<código Inicialización>};
<tipo>[] <nombreArreglo> = new <tipo>[] {<código Inicialización>};
Esta forma de inicialización se aplica a variables locales y miembros.
 Curso de Java – FastTrack

Arreglos
Uso:
El arreglo es referenciado utilizando su nombre.
Cada elemento individual es accedido utilizando el operador [<índice>]
Cada elemento es tratado como una variable simple de un tipo determinado.
<índice> es un literal o una expresión de tipo entero. Debe estar dentro del
rango mayor o igual a cero y menor al largo del arreglo.
En tiempo de ejecución se chequea automáticamente el valor del <índice>,
que cumpla la condición antes señalada. Se comprueba la excepción
ArrayIndexOutBoundsException
 Curso de Java – FastTrack

Arreglos
Arreglos Multidimensionales:
La definición de arreglos multidimensionales en Java pueden
ser de dos maneras:
<tipo>[][]…[] <nombre Arreglo>;
<tipo> <nombre Arreglo>[][]…[];
La secuencia del operador [] indica el numero de dimensiones
y puede ser distribuido en el <tipo> y/o el <nombre Arreglo>.
<tipo>[] nombreArreglo[]. Esto declara un arreglo de dos dimensiones.
Se puede combinar la declaración y construcción de la siguiente manera:
int[][] multiArreglo = new int[4][5];
Crea un arreglo de cuatro elementos i, donde cada elemento tiene cinco
elementos j.
La dimensión máxima de i es igual multiArreglo.length
La dimensión máxima de j es igual a multiArreglo[i].length
 Curso de Java – FastTrack

Arreglos
Arreglos Multidimensionales (cont):
Los arreglos multidimensionales también pueden ser construidos
e inicializados explícitamente al igual que los arreglos simples.
double[][] matrizIdentidad = {
{1.0, 0.0, 0.0, 0.0, 0.0}
{0.0, 1.0, 0.0, 0.0, 0.0}
{0.0, 0.0, 1.0, 0.0, 0.0}
{0.0, 0.0, 0.0, 1.0, 0.0}
{0.0, 0.0, 0.0, 0.0, 1.0}
}
Los arreglos "internos" no necesariamente deben tener la misma
dimensión.
Cuando construimos arreglos multidimensionales con el operador
new, podemos omitir la dimensión de arreglo anidado. En este caso
estos arreglos quedaran sin construir.
double[][] nultiArreglo = new double[5][];
 Curso de Java – FastTrack

Arreglos
Arreglos Anónimos:
Java admite la creación de arreglos sin nombre de la
siguiente forma:
new <tipo>[] {<código de iniciación>};
Ejemplo: new int[] {2,4,6,8};
Se pueden utilizar en el paso de parámetros:
objeto.metodo(new int[] {2,4,6,8});
Nota: Una arreglo de primitivos puede ser "moldeado"
solo a Object, el siguiente ejemplo se encuentra libre
de errores:
int sizes[] = {4, 6, 8, 10}; //(1)
Object obj = sizes; //(2)
int x = ((int[])obj)[2]; //(3)
Sun Servicios Educativos

Curso de Java – FastTrack

Módulo 4

Fin