distinguir entre variables de instancia y variables locales. describir cómo inicializar variables...
TRANSCRIPT
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