Algoritmos

Algoritmos

Cualquier problema puede ser resuelto si se siguen una serie de acciones o pasos en un orden específico. A esta serie de acciones se le conoce como algoritmo o procedimiento. El procedimiento se define en términos de:

Las acciones que deben ejecutarse.

El orden en que deben ejecutarse.

En programación, una vez comprendido un problema, se procede a la solución usando pseudocódigo, que es un lenguaje informal para indicar la estructura de un programa y la lógica que deberá seguir, para posteriormente ser escrito en el lenguaje de programación, donde se declaran las variables, las estructuras de control y en general todos los procedimientos que forman parte del algoritmo. Este es un ejemplo de pseudocódigo:

Solicitar al usuario su nombre.

Solicitar al usuario su edad.

Si la edad es mayor que 18, entonces:

Dar acceso y la bienvenida.

En caso contrario:

No permitir el acceso.

Terminar.

4.1 Variables y su alcance

En Java, las variables pueden ser de tipos primitivos o de tipo de referencia y declararse dentro de un método o fuera del método pero dentro de una definición de clase.

Las variables locales (o automáticas, temporales o de pila) son aquellas declaradas dentro de un método y deben inicializarse de forma explícita antes de usarlas por primera vez. Los parámetros de los métodos son también variables locales. En caso de intentar usar una variable sin haber sido inicializada, el compilador indicará:

"variable x might not have been initialized"

Las variables de instancia son las que se declaran fuera de un método, pero siempre dentro de una definición de clase y pertenecen a un objeto una vez que es construido con new. También las variables estáticas (o de clase) se declaran fuera de los métodos, anteponiendo el modificador static, pero no pertenecen a un objeto en particular, sino a toda la clase. Tanto las variables de instancia como las estáticas se inicializan automáticamente durante su creación, a diferencia de las locales, con valores 0 (para las de tipo primitivo) o null (para las variables de tipo de referencia).

Las variables locales (las declaradas dentro de un método y las recibidas como argumento del método) se crean dentro del método y sólo duran hasta que se termina de ejecutar el método (por eso se llaman temporales o automáticas). A esto se le conoce como el ámbito o alcance de la variable. Por ejemplo:

public class Alcance {

private int i=1;

public void metodoUno() {

int x = 2, y = 5;

this.i = x + y;

metodoDos(10);

}

public void metodoDos(int x) {

int a = 8;

this.i = x + a;

}

}

class PruebaAlcance {

public static void main(String[] args) {

Alcance alcance = new Alcance();

alcance.metodoUno();

}

}

4.2 Operadores

Los operadores en Java son parecidos, en estilo y función, a los de C y C++. A continuación se presentan los operadores de Java por orden de precedencia (D-I indica que son asociativos de derecha a izquierda, I-D que lo son de izquierda a derecha).

Precedencia

Operadores

D-I

++ -- + - ~ ¡ (<tipo_dato>)

I-D

* / %

I-D

+ -

I-D

<< >> >>>

I-D

< > <= >= instanceof

I-D

== !=

I-D

&

I-D

^

I-D

|

I-D

&&

I-D

||

D-I

<expr_booleana> ? <expr1> : <expr2>

D-I

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

Operadores lógicos

Los operadores lógicos y relacionales devuelven un resultado booleano (boolean), nunca un valor numérico. Los operadores admitidos son: !, &, ^ y | para las operaciones algebraicas NOT, AND, XOR y OR respectivamente, y siempre devuelven un resultado boolean.

Operación

Operador

Ejemplo

es igual a

==

if(i==1)

es diferente de

!=

if(i!=1)

es menor que

<

if(i<1)

es menor o igual a

<=

if(i<=1)

es mayor que

>

if(i>1)

es mayor o igual a

>=

if(i>=1)

Adicionalmente, será necesario tomar decisiones basadas en más de una comparación, usando operadores booleanos.

Operación

Operador

Ejemplo

AND

&

if((i<1)&(j>5))

OR

|

if((i<1)|(j>5))

NOT

!

if(!(i<1))

XOR

^

if((i<1)^(j>6))

Los operadores && (AND) y || (OR) equivalen a & y |, pero evalúan en cortocircuito:

MiFecha d = viaje.getFechaSalida();

if ((d != null) && (d.dia > 31)) {

...