HTMLpointHTMLpoint HTMLpoint.com


 Instrucciones



Estamos preparados para ver los constructores principales del lenguaje Java. Ya vimos los comentarios, que no se pueden ocultar, es decir, que el siguiente comentario no es posible: /* +Éste es seguramente un comentario /* Éste también lo es */ */ Sin embargo, se pueden introducir comentarios de una línea en los comentarios de más de una línea porque son distintos. Por ejemplo, es posible escribir lo siguiente: /* Éste es seguramente un comentario // Éste también lo es */ aunque realmente resulte bastante inútil. Las primeras instrucciones de Java que vamos a ver son las instrucciones de declaración, que son las declaraciones de variables locales. Se utilizan para declarar variables y darles un posible valor inicial. Estas instrucciones ya las vimos y se parecen a las declaraciones de los atributos, excepto por la falta de los modificadores. Las variables locales, antes de ser utilizadas, se tienen que inicializar.
Las variables locales se pueden declarar en un punto cualquiera de un bloque y no necesariamente al inicio, además existen sólo en los bloques en los que se declaran. Un bloque es como una instrucción, lo único es que empieza por { y acaba por }, y en él puede tener muchas instrucciones, incluso posiblemente de otros bloques.

{
instrucción 1;
instrucción 2;
….
instrucción j-1;
{
subinstrucción1;
subinstrucción2;
…..
subinstrucción;
}; // es la instrucción j
instrucción j+1;
….
instrucción n;
}// Este bloque puede ser el cuerpo de un método o un bloque
Pensad en el método:
void tribilín()
{
ent j=0;
{
ent k=0;
k++; // instrucción A
};
j++; // instrucción B
k++; // instrucción C
}


La instrucción A no da problemas porque usa una variable local que está inicialidada, declarada en su mismo bloque.
Con la instrucción B ocurre lo mismo, mientras la instrucción C está equivocada porque la variable que utiliza se ha declarado en un bloque entero y no se puede ver externamente. Si en el bloque interno hubiera escrito j++; no tendría ningún problema porque la variable j se habría declarado en un bloque externo. (Dentro se ve lo que hay fuera, pero fuera no se puede ver lo que hay dentro, lo cual ocurre en todos los lenguajes de programación por bloques).
Acabamos de ver en el ejemplo que también j++ es tanto una instrucción como una expresión, como su otra forma e ++j, y es su imagen especular de disminución. Hay otras operaciones que se pueden tener en cuenta a la hora de analizar las instrucciones. Se trata tanto de la implementación de los métodos que pueden devolver o no un valor, como de las instrucciones de creación de objetos, las que llevan new. Por ejemplo, new Object(), es una instrucción correcta.
Otra instrucción muy parecida a una expresión es la instrucción de asignación, la del tipo:

NombreVariable = expresión;

Por lo tanto, hasta ahora hemos visto las seis instrucciones:

  • Declaración de una variable local;
  • Bloque;
  • Formas de incremento y disminución de las variables, prefijas y postfijas;
  • Creación de los objetos;
  • Solicitud de los métodos;
  • Asignación de las variables;

    Todas las instrucciones terminan por ;

    Las demás instrucciones se llaman constructos y son muy parecidas a las de los demás lenguajes de programación. Las vamos a ver detalladamente.

    Instrucción condicional
    if (EXPBOOL) IST
    Esta instrucción pone en marcha la instrucción llamada IST que puede ser una cualquier instrucción del lenguaje sólo si la expresión booleana EXPBOOL es verdadera, de lo contrario se salta. Una variedad es la en que pone en marcha otra instrucción si EXPBOOL es falsa, es:

    if (EXPBOOL) IST
        else
        IST2


    Fijaos que IST y IST2 son instrucciones generales, por lo tanto también los bloques o las demás instrucciones condicionales. En este último caso hablamos de if ocultos.

    Instrucción switch

    Switch (EXP)
    {
    case CST11: …. :case CST1n: IST1
    case CST21: …. : case CST2n: IST2
    ….
    case CSTm1: …. : case CSTmn: ISTm
    default ISTm+1;
    };


    Si EXP es una expresión, CSTij son unas constantes del mismo tipo que la expresión. EXP y ISTi son unas instrucciones.
    La instrucción evalúa EXP, y compara el resultado con las constantes de los case; si encuentra otro igual, pone en marcha la instrucción correspondiente. Si, en cambio, no encuentra ninguna constante igual, pone en marcha la instrucción después del default, lo que es una opción. En el caso de que esté ausente y ningún case tenga la constante igual al valor de EXP, se salta el switch.
    Analizamos, por ejemplo, el siguente mando:

    switch (5+1)
    {
    case 6 : System.out.println ("Muy bien");
    default : System.out.println ("Burrp, es seis");
    };


    Instrucción for for (exp de inicialización; exb booleana; exp de incremento) ISTR
    pone en marcha la instrucción ISTR que es un número de veces igual a los valores contenidos en un intervalo. Normalmente la instrucción de inicialización pone en marcha una variable en un valor; la variable se incrementa (o disminuye) a partir de la instrucción de incremento y en la expresión booleana se controla que la variable tenga los valores que queremos. En efecto, si la expresión booleana es falsa, enseguida se sale del ciclo for.
    Voy a poner un ejemplo: quiero inicializar los valores de un vector de 100 enteros todos a cero. En lugar de escribir 100 asignaciones, escribiré:

    ent v = new ent[100];
    for (ent e = 0 ; e<100; e++) v[e] = 0 ;


    Como acabamos de ver la variable también se puede declarar en la instrucción de inicialización. De esta forma, sólo se puede ver en el for.

    Instrucción while
    while (EXPBOOL) IST
    Pone en marcha IST simulando que EXPBOOL es verdadera, por ejemplo, la inicialización del ejemplo anterior se puede llevar a cabo con el while de la siguiente forma:

    ent v = nuevo ent[100];
    ent e=0;
    while (e<100) {
    v[e]=0;
    e+=1;
    };


    o de forma comprimida, aprovechando el incremento de forma comprimida:

    ent v = nuevo ent[100];
    ent e=0;
    while (e<100) v[e++]=0;


    Instrucción do-while do IST while (EXPBOOL);
    ES como el while, sólo que antes ejecuta la instrucción y luego controla el EXPBOOL, de nuevo la inicialización precedente se convierte en:

    ent v = nuevo ent[100];
    ent e=0;
    do {
    v[e]=0;
    e+=1;
    } while (e<100);

    o también de forma todavía más comprimida:

    ent v = nuevo ent[100];
    ent e=0;
    do v[e++] = 0 while (e<100);

    Etiquetas
    Es posible poner etiquetas a las instrucciones, como ocurre con el código assembler. Esto resulta muy útil en combinación con las instrucciones de break y de continue:

    etiqueta: instrucción;

    instrucción de break
    La instrucción de break se utiliza para salir de un bloque o de un switch; cuando se encuentra un break se sale del bloque más interno, mientras que si se pone una etiqueta, se sale hasta donde la etiqueta se ha declarado.

    Ejemplo:

    {
    while ( COND )
    {
    while (COND2)
    {
    if (ALGO) break;
    }
    }
    }
    En este caso se sale del while interior, mientras:
    {
    tribilín: while ( COND )
    {
    while (COND2)
    {
    if (ALGO) break tribilín;
    }
    }
    }


    se sale de los dos while.

    Instrucción de continue
    En un ciclo se salta todas las instrucciones que le siguen y evalúa directamente la expresión booleana, por ejemplo:

    while (Condición)
    {
    instrucciones;
    if (GolpeDeEfecto) continue;
    otras instrucciones;
    };


    Se entra en el ciclo, se ponen en marcha las instrucciones. Si GolpeDeEfecto es verdadero, salta otras instrucciones y llega a evaluar Condición. Si ésta también es verdadera, continúa el ciclo poniendo en marcha las instrucciones, etc..

    Instrucción de return
    Produce la conclusión de la ejecución del método en el que se encuentra y el retorno a la llamada. Si el método es void basta con escribir return, si no tiene que contener una expresión del mismo tipo del método, por ejemplo

    ent tribilín()
    {
    return 10;
    }


    con la instrucción return es posible también bloquear la puesta en marcha de un constructor o de un método static.

    Con esto acabamos nuestro examen de las instrucciones. Ahora estamos preparados para construir cualquier aplicación a consola.
    Pongamos un par de ejemplos: empecemos escribiendo un pequeño programa que imprima los primeros números, los menores de 500 de la famosa serie de Fibonacci. Para los que no la conozcan, la serie de Fibonacci es una secuencia infinita de números cuyos dos primeros elementos son: 1, 1, y los demás elementos se calculan como la suma del e-1 ésimo número y del e-2 ésimo, formalmente, reconociendo Fibo come una función:

    Fibo ( e ) = Fibo ( e - 1 ) + Fibo ( e - 2 );

    El programa que hay que escribir en Fibo.java es el siguiente:

    class Fibo
    {

    public static void main (Cadena[] args)

    {

    ent bajo=1, alto=1;

    // ent alto=1;

    System.out.println (bajo);

    while (alto<500)
    {

    System.out.println(alto);

    alto+=bajo;

    bajo = alto - bajo;

    };

    }

    }


    Para que os entrengáis, podéis intentar hacer un programa que calcula 10 ! , sabiendo que 1! = 1 y que establecido n entero, n! = n * ((n-1)!). La solución se encuentra en el archivo Fatt.java.
    Ahora, intentamos escribir nuetra criba de Eratóstenes hecho en casa, es decir, una forma para calcular todos los números primos hasta un número establecido, digamos 100;
    El algoritmo procede así,

    1 es un número primo.
    2 es un número primo, le quito sus múltiplos
    3 es un número primo, le quito sus múltiplos


    etcétera hasta encontrar mi máximo.

    clase Eratóstenes
    {
    static ent MÁX=1000;

    ent [] números = nuevo ent[MÁX];

    boolean [] primos = nuevo boolean[MÁX];

    public Eratóstenes()
    {

    ent e;

    for (e=0;i<MAX;e++)
    {
    números[e]=e+1;

    primos[e]=verdaderos;

    };

    }

    void elMul(ent a)
    {

    for (ent j=2;j*a<=MÁX;j++)
    primos[(j*a)-1]=falso;

    }

    ent siguiente(ent n)
    {
    ent tmp=n;

    while (!primos[tmp]) {
    tmp++;
    if (tmp>=MÁX) break;
    }

    return tmp+1;

    }

    void calculaPrimos()
    {
    ent núm=2;

    while (núm<=MÁX)
    {
    elMúl(núm);
    núm=siguiente(núm);
    };

    }

    void escribaPrimos()

    {

    System.out.println("Los números primos hasta "+MÁX+" son:");

    for (ent e=0; e < MÁX ; e++)
    if (primos[e]) System.out.print(números[e]+" ");

    }

    public static void main(Cadena[] args)
    {

    Eratóstenes e = nuevo Eratóstenes();

    e.calculaPrimos();

    e.escribaPrimos();

    }

    }



  •   Vuelva al inicio de la página