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)) {

// hacer algo con d

}

Al evaluar la expresión if() usando un operador de cortocircuito (&&), la segunda expresión (d.dia>31) únicamente se evalúa si el resultado de la primera expresión (d!=null) es true; en otras palabras, si la primera expresión resulta false, no hay razón para evaluar la segunda, pues con el hecho de tener una expresión falsa, con AND toda la expresión sería falsa.

Operadores aritméticos

Los operadores aritméticos incorporados en el lenguaje Java son:

Propósito

Operador

Ejemplo

Suma

+

sum = num1 + num2

Resta

-

dif = num1 – num2

Multiplicación

*

prod = num1 * num2

División

/

div = num1 / num2

Módulo

%

mod = num1 % num2

Todos los cálculos aritméticos siguen las reglas de precedencia de operadores:

Operadores dentro de pares de paréntesis.

Operadores de multiplicación y división, evaluados de izquierda a derecha.

Operadores de suma y resta, evaluados de izquierda a derecha.

Si el mismo operador aparece sucesivamente en una expresión, los operadores son evaluados de izquierda a derecha.

El siguiente ejemplo demuestra la necesidad de la precedencia de operadores:

c = 25 – 5 * 4 / 2 – 10 + 4;

En este caso, no está claro lo que se pretende obtener, pues el valor de c es 9:

c = 25 – ((5 * 4) / 2)) – 10 + 4;

Es importante usar paréntesis para proveer la estructura deseada:

c = ((25 – 5) * 4) / (2 – 10)) + 4;

c = ((20 * 4) / (2 – 10)) + 4;

c = (80 / (2 – 10)) + 4;

c = (80 / -8) + 4;

c = -10 + 4;

c = -6

Es una buena práctica de programación agregar los paréntesis para enfatizar la intención, aún y cuando la precedencia no está en duda.

Operadores de incremento y decremento

Un requerimiento común de un programa es sumar o restar un valor de una variable. En el siguiente ejemplo, 9 es restado de la variable total.

total = total - 9;

...