distinguir entre variables de instancia y variables locales. describir cómo inicializar variables...

Distinguir entre variables de instancia y variables locales.

Describir cómo inicializar variables de instancia. Reconocer, describir y usar los operadores Java. Distinguir entre asignaciones legales e ilegales de tip

os primitivos.

Reconocer la compatibilidad de asignaciones y las conversiones requeridas  sobre los tipos fundamentales.

Usar  las construcciones if, switch, for, while y do y las formas  etiquetadas de break y continue como estructuras de control  en un programa.

Las variables locales son:₋ Variables que son definidas dentro de

métodos y son llamadas variables locales, automáticas, temporales y de stack.

₋ Las variables que son creadas cuando el método es ejecutado son destruidas cuando se sale del mismo.

₋ Las variables locales necesitan inicialización explícita.

₋ Las variables de clase y miembros son inicializadas automáticamente.

public class ScopeExample {

private int i=1; public void firstMethod() {

int i=4, j=5;

this.i = i + j;

secondMethod(7);

} public void secondMethod(int i) {

int j=8;

this.i = i + j;

}}public class TestScoping {

public static void main(String[] args) {

ScopeExample scope = new ScopeExample();

scope.firstMethod();

}}

Los operadores producen nuevos valores a partir de uno o más operandos

El resultado de la mayoría es numérico o booleano

No pueden ser sobrecargados como en C++

El igual (=) es utilizado para asignar un valor a una variable

Las variables son simplemente un conjunto de bits

Para los tipos primitivos se guarda el valor en esos bits

Para los tipos de referencia se guarda un valor igual a la dirección de memoria del objeto o null

Existen 12 operadores de asignación incluyendo el igual (=)

Los otros 11 son combinaciones del signo de igual con algún otro operador (compound assignment operators)

=

+=

>>>=

*=

-=

&=

/=

<<=

^=

%=

>>=

!=

Se puede asignar una variable usando un literal o el resutlado de una expresión

₋ int x = 7;₋ int y = x + 2;₋ int z = x * y;

Recordar que un entero literal (7) es implícitamente un int (32 bits)

No habría problema en asignar un int a un long. ¿Que pasaría en el caso de asignar un int a un byte, char o short ?

Lo siguiente es legal:₋ byte b = 27; // El compilador hace el casteo

// automáticamente Sabemos que los literales enteros son int, pero en

realidad el resultado de cualquier operación de enteros entre operandos de 32 bits o menos da como resultado un int

₋ byte b = 3;₋ byte c = 8;₋ byte d = b + c; // error de compilación,

// distinto de byte d = 3 + 8;

Recordar que implicitamente los literales en punto flotante son double

Si se intenta asignar un double a un float el compilador sabe que no hay suficiente espacio en 32 bits para almacenar la precisión de un double (64 bits)

₋ float f = 32.3; // no compila₋ float g = (float) 32.3; // ok₋ float h = 32.3f; // ok₋ float y = 32.3F; // ok

Lo siguiente da error de compilación:₋ byte b = 128; // 127 es el rango máximo del

byte₋ byte b = (byte) 128; // ok

El operador += permite sumar sin hacer casteo explícito

₋ byte b = 3;₋ b += 7; // equivalente a b = (byte) b + 7

Cuando se asigna una variable primitiva a otra, el valor de la variable de la derecha es copiado a la de la izquierda

₋ int a = 6;₋ int b = a;

No refieren al mismo lugar en memoria, simplemente tienen el mismo valor

Cuando se asigna una variable de referencia a otra, se copia el valor de la dirección de memoria de una a la otra, por lo que las dos “apuntan” al mismo lugar de memoriaMyDate m = new MyDate();MyDate n = m;n.setDay(30); // se cambia tanto el día del objeto

// referenciado por n como el referenciado por

// m, ya que son el mismo. Hay ciertas excepciones como el caso de String que

veremos más adelante

Los operadores de comparación simpre resultan en algún valor booleano (true o false)

Existen 4 operadores de comparación que pueden utilizarse para comparar cualquier combinación de de enteros, numeros en punto flotante o caracteres

₋ > mayor que₋ >= mayor o igual que₋ < menor que₋ <= menor o igual que

La igualdad puede ser testeada con 2 operadores₋ == igual que₋ != distinto de

Comparan 2 “cosas” y devuelven un valor booleano Cada comparación individual puede comprender

₋ numeros ₋ caracteres₋ Booleanos₋ objetos

No se pueden comparar tipos incompatibles

Los operadores aritméticos son:₋ + suma₋ - resta₋ * multiplicación₋ / división₋ % resto

Reglas básicas:₋ Dividir un entero por cero causa una ArithmeticException₋ Usar el operador % con cero como operador derecho

causa una ArithmeticException₋ Dividir un numero en punto flotante por cero es legal₋ Usar el operador % sobre un operando en punto flotante

con cero como operando derecho causa una ArithmeticException

El operador +:₋ Realiza la concatenación de String₋ Produce un String nuevo:

String salutation = "Dr."; String name = "Pete" + " " + "Seymour"; String title = salutation + " " + name;

Uno de los argumentos debe ser un objeto String₋ Los objetos que no son String son convertidos en

String automáticamente.

Java tiene dos operadores que incrementan o decrementan una variable en exactamente 1

₋ ++ incremento (prefijo y postfijo)₋ -- decremento (prefijo y postfijo)

Uso prefijo:₋ int x = 4;

int y = ++x;₋ La variable x se incrementa y luego se utiliza el valor alterado

en la evaluación de la expresión₋ Resultado: y = 5, x = 5

Uso postfijo:₋ int x = 4;

int y = x++;₋ La variable x se evalúa en la expresión y luego se incrementa.₋ Resultado: y = 4, x = 5

>> shift derecha<< shift izquierda>>> shift derecha (unsigned o zero-filled shift)

El desplazamiento a la derecha aritmético o con signo se utiliza 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 desplazamiento El desplazamiento a la derecha lógico o sin signo

(>>>) es:₋ El signo no es copiado durante el desplazamiento.₋ Trabajan con los bits como están y no con

significado aritmético

Ejemplos de desplazamiento a la izquierda (<<):₋ 128 << 1 retorna 128 * 21 = 256₋ 16 << 2 retorna 16 * 22 = 64

R (right) derecha L (left) izquierda L to R(derecha a

izquierda) R to L (izquierda a

derecha)

Los operadores booleanos son (bit a bit):₋ ! – NOT & – AND₋ | – OR ^ – XOR

Los operadores booleanos “short-circuit” son (son de comparación entre tipos y objetos):₋ && – AND || – OR

Puede usar estos operadores de la siguiente manera:MyDate d;if ((d != null) && (d.day > 31)) {

// do something with d}

Los operadores son:₋ ~ – Complement & – AND₋ ^ – XOR | – OR

Ejemplos:

Operador ternario utilizado para evaluar condiciones booleanas como un if

En vez de ejecutar un bloque de código, asigna un valor a una variable

₋ nombreVariable = (expresión booleana) ? Valor si verdadero: valor si falso

₋ Los paréntesis son opcionales₋ int a = 1;₋ int b = 2;₋ int x = (a > b) ? a : b;

Si existe información que se puede perder cuando se hace una asignación, el programador debe confirmar la asignación con un casteo.

La asignación entre un long y un int requiere un casteo explícito

Ejemplos:₋ long bigValue = 99L;₋ int squashed = bigValue;// Wrong, needs a cast₋ int squashed = (int) bigValue; // OK₋ int squashed = 99L; // Wrong, needs a cast₋ int squashed = (int) 99L; // OK, but...₋ int squashed = 99; // default integer literal

Las variables son automáticamente promovidas (casteadas) a un tipo mas grande ( p.e. de int a long).

Las expresiones son compatibles para ser asignadas, si el tipo de la variable es por lo menos tan grande como( el mismo número de bits) el tipo de la expresión.

Ejemplos:₋ long bigval = 6; // 6 is an int type, OK₋ int smallval = 99L; // 99L is a long, illegal₋ double z = 12.414F; // 12.414F is float, OK₋ float z1 = 12.414; // 12.414 is double, illegal

La sintaxis de la sentencia if, elseif ( boolean expression) {

statement or block;}if ( boolean expression) {

statement or block;} else {

statement or block;}

Ejecuta un bloque o sentencia de acuerdo a cierta condición booleana

Si es una única sentencia la que se pretende ejecutar no es necesario definir un bloque

int count;count = getCount(); // a method defined in the classif (count < 0) {

System.out.println("Error: count value is negative.");} else if (count > getMaxCount()) {

System.out.println("Error: count value is too big.");} else {

System.out.println("There will be " + count + " people for lunch today.");

}

La sintaxis del switchswitch ( expr1) {

case constant2:statements;break;

case constant3:statements;break;

default:statements;break;

} El tipo de la expr1 debe ser compatible con el tipo int (byte, short, int,

char) El argumento de los case debe ser un literal o una variable final Si expr1 matchea algun case, se comenzaran a ejecutar las sentencias

definidas en ese case hasta encontrar un break El default se utiliza para ejecutar en caso que no se matchee ningun valor

de case y puede ubicarse en cualquier lugar del switch Si no se coloca el break seguirá ejecutando el siguiente case

switch ( carModel ) {case DELUXE:

addAirConditioning();addRadio();addWheels();addEngine();break;

case STANDARD:addRadio();addWheels();addEngine();break;

default:addWheels();addEngine();

}

switch ( carModel ) {case THE_WORKS:

addGoldPackage();

add7WayAdjustableSeats();case DELUXE:

addFloorMats(); addAirConditioning();

case STANDARD: addRadio(); addDefroster();

default: addWheels(); addEngine();}

En este caso no tiene breaks Si carModel == DELUX Se ejecutará todo lo siguiente; lo

de STANDAR y lo de default

La sentencia for:

for (init_expr; boolean testexpr; alter_expr) {sentencia o bloque;

}₋ Ninguna parte del for es requerida₋ Las variables declaradas en el for serán solamente

accesibles desde el for₋ Puede inicializarse más de una variable en la init_expr

del for₋ Las inicializaciones están separadas por coma (,)

Ejemplo

for( int i = 0; i < 10 ; i++){System.out.println(“Todavía no terminó?”);

}System.out.println(“Terminó”);

La sentencia while:while( sentencia boolean ){

sentencia o bloque;}

Ejemploint i = 0;while ( i < 10){

System.out.println(“Todavía no terminó?”);i++;

}System.out.println(“Terminó”);

La sentencia do / whiledo{

sentencia o bloque;} while (boolean test);

Ejemploint i = 0;do{

System.out.println(“Todavía no terminó?”);i++;

}while ( i < 10);System.out.println(“Terminó”);

break [label];₋ Un break sin label, causa la interrupción de el loop que

lo contiene (el más interno) y se pasa a ejecutar la siguiente linea luego del loop.

continue [label];₋ Un continue sin label, causa la interrupción de la

iteración actual del loop que lo contiene, y la ejecución del chequeo de la condición del loop. Si la condición es true, se ejecuta el loop nuevamente

label: statement; ₋ Si el break o continue están etiquetados, tiene el

mismo efecto pero esta vez el loop sobre el que se realizan las acciones es el loop con esa misma etiqueta.

do {

statement;

if ( condition is true) {

break;

}

statement;

} while ( boolean expression);

do {

statement;

if ( boolean expression) {

continue;

}

statement2;

} while ( boolean expression);

outer: do {statement;do {

statement;if ( boolean expression) {

break outer;}statement;

} while ( boolean expression);statement;

} while ( boolean expression);

test: do {statement;do {

statement;if (condition is true) {

continue test;}statement;

} while ( condition is true);statement;

} while ( condition is true);

Variables de instancia y variables locales. Inicializacion de variables de clase y locales. Operadores Asignaciones Casteo y Promocion Estructuras de control:

₋ If₋ Switch₋ For₋ While₋ Do

Etiquetas: continue y break.

The Java TutorialControl Flow Statements₋ http://download.oracle.com/javase/tutorial/java/

nutsandbolts/flow.html