jueves, 19 de junio de 2014

MODULO 4

Inicialización de variables
Variables Locales: Son temporales y solo viven dentro de un método una vez que el método termina de ejecutarse no existen más en el Stack. Se eliminan.


Los datos que son primitivos se inicializan con 0, 0.0F, 0.0, etc.
Los datos NO primitivos de java se incializan con null.

String a;  //se inicializa con null
Integer b; // se inicializa con null

int b = 14
Integer a;
System.out.println("a + b = " + (a+b) );  //sale error a diferecia de ser un String no marca error porque

String k;
int c = 5;
System.out.println("c + k = " + (c+k) );
imprimirá: null5


Operadores

Binario


Operador ternario
Requieren trres operadores, asigna el valor si se cumple o no una condición


Aritméticos
necesitan dos operandos


int a=5;
int b = 7;
a++ ->





Precedencia de operadores
s = b++ * ++a + b

s= ++b * ++a
s= b++ * a++

s= ++a * ++b


EL operador de igualdad (==)
Compara referencias


CONDICIONALES
&&  operador de corto circuito (AND)
& NO operador de corto circuito  (AND)
||   operador de corto circuito  (OR)
|  NO operador de corto circuito (OR)
!

 operador de corto circuito
Puede tomar una decisión con una sola condición (excepciones)

 operador de corto circuito
Evalua a fuerza las dos condiciones



package OjOCC;

/**
 *
 * @author Samuel
 */
public class OCC {
    public static void main(String[] args) {
     
        if( (m(6)  && (m(7)))){  //False
           System.out.println("true");
       }
     
        if( (m(6)  & (m(7)))){  //False
           System.out.println("true");
       }
     
        if( (m(6)  || (m(7)))){     ///False
           System.out.println("true");
       }
     
        if( (m(6)  | (m(7)))){ //false
           System.out.println("true");
       }
           
    }
 
    public static boolean m(int x){
        if(x < 5){
            System.out.println("i<5");
            return true;
        }else{
            System.out.println("z >= 5");
            return false;
        }
    }
 
}

La diferencia esta en que unos evaluan las dos partes y otros sólo uno



Operadores de Bits

Existen dos tipos: los que desplazan (mueven) bits, y operadores lógicos de bit.

Operadores de asignación

+=
-=
*=
/=
%=
&=
|=
^=

PROBARLOS Y VER COMO FUNCIONAN



Operador Ternario
Los operadores sirven como una especie de if en el cual tiene dos opciones y de ser verdad asigna o regresa el valor del que fue verdadero.

Su estructura es la siguiente> Expresión ? opción1 : opción2 de culmplirse la expresión regresaría opción uno en otro caso sería opción2.

Ejemplos:
Ejemplo 1:
       int i = 40; //i = 49;
       String res = (i<40)?"life":(i>40)?(i<39)?"e":"t": "Everything" ;

Cuando compara si i<40 es verdadero por lo tanto asigna life a la variable res, si probamos con i = 49, entonces no se cumple si se va al lado derecho de los : y ahí se hace otra evaluación verifica que i>40, como esto es verdadero, entonces asigna  Everything

Ejemplo2
        if( ((edad>18)?1:2) == 2  ){
            System.out.println("Esto es un ejempo");
        }


public class LosTernarios {
    public static void main(String[] args) {
       int edad = 25;
     
       String op1 = "Mayor de edad";
       String op2 = "Menor de edad";
     
       String res =  edad >= 18?op1:op2;  //operador ternario, parecidos a un if
       //? sintaxiste el operador ternario tiene una operacion y significa una asignacion a op1 o op2 si se cumple lo de atrás
        System.out.println(res);
        System.out.println(op1);
        System.out.println(op2);
    }
 

}


Estructuras de control

if(){
}else{

}

switch


For
Uso del break, break etiqueta, continue etiqueta

//uso de un break en un ciclo for.
        for (int i = 0; i < 2; i++) {
            for (int j = 0; j < 5; j++) {
                if(j==1) break;
                System.out.println("j = "+j);
            }
            System.out.println("i= "+i);
        }

output -------------------------------
j = 0
i= 0
j = 0
i= 1

En este caso lo que hace break es salirse del for, es decir ya termina el ciclo como tal y se va al de más arriba.

     
        //uso de un break con etiqueta.
        System.out.println("uso de un break con etiqueta.");
        for (int i = 0; i < 2; i++) {
            z:
          //Aquí no debe haber absolutamente nada de código
            for (int j = 0; j < 2; j++) {
                for (int k = 0; k < 10; k++) {
                    if(k==2) break z;
                    System.out.println("k= "+k);
                }
                System.out.println("j= "+j);
            }
            System.out.println("i= "+i);
        }

output -------------------------------
uso de un break con etiqueta.
k= 0
k= 1
i= 0
k= 0
k= 1
i= 1

La etiqueta indica hasta donde nos vamos a ir cuando se cumpla la condición pero lo interesante del break con la etiqueta es que una vez cumplida la condición rompe todos los ciclos que están por debajo de la etiqueta inicial, en terminos generales hace lo mismo que el break silito, sólo que la etiqueta nos dece hasta donde.

*Algo importante mencionar es que no debe haber nada entre la etiqueta y el ciclo, es decir una la línea siguiente de la etiqueta inicial debe ser un for.  
     
        //uso de un break y continue
        System.out.println("uso de un continue");
        for (int i = 0; i < 2; i++) {
            z:
            for (int j = 0; j < 2; j++){
                System.out.println("Aj= "+j);
                for (int k = 0; k < 5; k++) {
                    if(k==2) continue z;
                    System.out.println("k= "+k);
                }
                System.out.println("j= "+j);
            }
            System.out.println("i= "+i);
        }

output -------------------------------
uso de un continue
Aj= 0
k= 0
k= 1
Aj= 1
k= 0
k= 1
i= 0
Aj= 0
k= 0
k= 1
Aj= 1
k= 0
k= 1

i= 1


El uso del continue con la etiqueta funciona de manera similar al break, sólo que en este rompe el ciclo donde esta el continue y los demás entre este ciclo y un ciclo antes de la etiqueta. Es decir el que continua con el valor sumando es el que esta bajo la etiqueta, como se ve en el siguiente código:
//uso de un continue con más niveles.
        System.out.println("uso de un continue con más niveles");
        for (int i = 0; i < 2; i++) {
            z:
            for (int kj = 0; kj < 3; kj++) {
                System.out.println("kj= "+kj);
            
            for (int j = 0; j < 2; j++){
                System.out.println("Aj= "+j);
                for (int k = 0; k < 5; k++) {
                    if(k==2) continue z;
                    System.out.println("k= "+k);
                }
                System.out.println("j= "+j);
            }
            System.out.println("i= "+i);
        }
        }

output -------------------------------
uso de un continue con más niveles
kj= 0
Aj= 0
k= 0
k= 1
kj= 1
Aj= 0
k= 0
k= 1
kj= 2
Aj= 0
k= 0
k= 1
kj= 0
Aj= 0
k= 0
k= 1
kj= 1
Aj= 0
k= 0
k= 1
kj= 2
Aj= 0
k= 0
k= 1