Tu portal de
formación online

Infórmate
Inicio » Catálogo » Curso de Programación en Java »  Estructuras básicas de programación

Curso de Programación en Java

 Estructuras básicas de programación

El estudio de esta sección del tema se recomienda a personas que no conocen las estructuras típicas de programación comunes a la mayoría de lenguajes, tales como los condicionales, los bucles for, los bucles while, las sentencias de ruptura break y continue, etc.

Primero se realiza una explicación de los operadores y expresiones que más frecuentemente se utilizan en cualquier lenguaje de programación y, a continuación, se explican las estructuras  mencionadas anteriormente.

Es una sección optativa.

 Expresiones

Una expresión es una instrucción o sentencia que devuelve un valor llamado valor de retorno y que asigna a una variable un:

  • Dato numérico
  • Valor lógico
  • Carácter
  • Cadena de caracteres o dato textual
 int x; // Expresión de definición de una variable. x = 3; // Expresión de inicialización de una variable. int x = 3; // Expresión que define e inicializa una variable.
 int edad; boolean mayorDeEdad; mayorDeEdad=18>edad; // Expresión que devuelve un valor lógico.

 Operadores

Un operador permite relacionar dos datos en una expresión y evaluar el resultado de una operación.

Hay varios tipos de operadores:

Aritméticos

Manipulan datos numéricos. Los siguientes operadores forman parte de los operadores aritméticos:

  • Suma +
  • Resta –
  • Producto *
  • División /
  • Resto de la división entera o módulo %
  • Incremento unitario ++
  • Decremento unitario –
  • Incremento de cien en cien +=100
  • Decremento de cien en cien -=100

Operadores básicos

 public class OperadoresAritmeticos{ 	public static void main(String args[]){ 		int x=3; 		int y=2; 		System.out.println(x+y); 		System.out.println(x-y); 		System.out.println(x*y); 		System.out.println(x/y); 		System.out.println(x%y); 	} }

Incrementar/Decrementar 1

 public class OperadoresAritmeticosIncreDecre1{ 	public static void main(String args[]){ 		int x=10; 		x++;  //++x; tendría el mismo efecto 		System.out.println("Valor de x: "+x); 	} }

Incrementar/Decrementar 2

  public class OperadoresAritmeticosIncreDecre2{  	public static void main(String args[]){ 		int x=10; 		 		//Primero se asigna el valor actual de  la variable "x" a la 		//variable "y" y después se incrementa el valor de "x" 		int y=x++; 		System.out.println("Valor de x: "+x); 		System.out.println("Valor de y: "+y); 	} }

 public class OperadoresAritmeticosIncreDecre2Bis{ 	public static void main(String args[]){ 		int x=10; 		 		//Primero se incrementa el valor actual de la variable "x" en una 		//unidad y después se asigna el valor incrementado a la variable "y" 		int y=++x; 		System.out.println("Valor de x: "+x); 		System.out.println("Valor de y: "+y); 	} }

De asignación
Transfieren datos de una variable a otra. 

Hay también varios operadores que forman parte de este tipo:

  • x+=y        x=x+y
  • x-=y         x=x-y
  • x*=y         x=x*y
  • x/=y         x=x/y
  • x%=y       x=x%y    Es el módulo o resto de una división

Asignación 1

 public class OperadoresAsignacion1{ 	public static void main(String args[]){ 		int x=3; 		int y=5; 		 		//z se inicializa con la suma de los valores de las variables x e y 		int z=x+=y; 		System.out.println("Valor de z: "+z); 		System.out.println("FIN DE PROGRAMA"); 	} }

Asignación 2

  public class OperadoresAsignacion2{  	public static void main(String args[]){ 		int a=6; 		int b=3; 		a+=b; //a=6+3=9 y b=3 		b*=a; // b=3*9=27 y a=9 		System.out.println("El valor de a es "+a+" y el de b es "+b); 		System.out.println("FIN DE PROGRAMA"); 	} }

De comparación

Comparan dos datos y devuelven un valor booleano. 

Son los siguientes:

  • ==                   igual (no confundir con el = de asignación)
  • !=                    distinto
  •                     mayor que
  • <                     menor que
  • >=                   mayor o igual que
  • <=                   menor o igual que

Operadores de comparación

 public class OperadoresComparacion{ 	public static void main(String args[]){ 		int x=5; 		int y=8; 		boolean z=x!=y; 		System.out.println("Valor de z: "+z); 		System.out.println("FIN DE PROGRAMA"); 	} }

Lógicos

Concatenan expresiones lógicas con objeto de evaluar si es cierto o falso el conjunto de las expresiones.

Son los siguientes:

  • && (Y lógico): si todas las expresiones lógicas que se evalúan son verdaderas se devuelve un valor booleano true; si alguna es falsa, devuelve false.
  • || (O lógico): si alguna de las expresiones lógicas que se evalúa es verdadera, se devuelve un valor booleano true; si todas son falsas, devuelve false.
  • ! (NOT): invierte el valor de una expresión booleana.

Operador lógico Y

 public class OperadoresLogicosY{ 	public static void main(String args[]){ 		int x=10; 		int y=20; 		 		//x>5 devuelve true 		//y<50 devuelve true 		//Ambas expresiones unidas por && hacen que z almacene un valor true 		//No son necesarios los paréntesis aunque conviene ponerlos para 		//interpretar mejor el código 		boolean z=(x>5) && (y<50); 		System.out.println("Valor de z: "+z); 		System.out.println("FIN DE PROGRAMA"); 	} }

Operador lógico O

 public class OperadoresLogicosO{ 	public static void main(String args[]){ 		int x=10; 		int y=20; 		 		//x>20 devuelve false 		//y<50 devuelve true 		//Ambas expresiones unidas por || hacen que z almacene true 		boolean z=(x>20) || (y<50); 		System.out.println("Valor de z: "+z); 		System.out.println("FIN DE PROGRAMA"); 	} }

Condicional if .. else

No todos los problemas pueden resolverse empleando estructuras secuenciales. Cuando hay que tomar una decisión aparecen las estructuras condicionales.

En nuestra vida diaria se nos presentan situaciones donde debemos decidir.

  • ¿Elijo la carrera A o la carrera B?
  • ¿Me pongo este pantalón?
  • Para ir al trabajo, ¿elijo el camino A o el camino B?
  • Al cursar una carrera, ¿elijo el turno mañana, tarde o noche?

Por supuesto que en la resolución de un problema se combinan estructuras secuenciales y condicionales.

La palabra clave if indica que estamos en presencia de una estructura condicional; seguidamente disponemos la condición entre paréntesis.
Por último encerrada entre llaves las instrucciones de la rama del verdadero.
Es necesario que las instrucciones a ejecutar en caso que la condición sea verdadera estén encerradas entre llaves { }, con ellas marcamos el comienzo y el fin del bloque del verdadero.
Si el bloque de código del if tiene una sola línea de código no es necesario utilizar llave, aunque si se escribe, no da error. Lo mismo ocurre con el bloque de código alternativo.
Si no se escribe el else opcional y no se cumple la condición del if, el programa continúa ejecutándose pasando a las siguientes líneas de código.

Las estructuras condicionales se dividen en dos tipos:

Estructura condicional simple
Cuando se presenta la elección tenemos la opción de realizar una actividad o no realizar ninguna.
Se puede observar en la imagen de abajo que el rombo representa la condición, hay dos opciones que se pueden tomar.
Si la condición da verdadera se sigue el camino del verdadero, o sea el de la derecha, si la condición da falsa se sigue el camino de la izquierda.

Ingresar el sueldo de una persona, si supera los 3000 euros mostrar un mensaje en pantalla indicando que debe abonar impuestos
Siempre se hace la carga del sueldo, pero si el sueldo que ingresamos supera 3000 euros se mostrará por pantalla el mensaje "Esta persona debe abonar impuestos", en caso que la persona cobre 3000 o menos no aparece nada por pantalla.

 

 import java.util.Scanner;  public class EstructuraCondicionalSimple1 {    public static void main(String[] ar) {      Scanner teclado=new Scanner(System.in);      float sueldo;      System.out.print("Ingrese el sueldo:");      sueldo=teclado.nextFloat();      if (sueldo>3000) {        System.out.println("Esta persona debe abonar impuestos");      }    }  } 

Estructura condicional compuesta
Cuando se presenta la elección tenemos la opción de realizar una actividad u otra. Es decir tenemos actividades por el verdadero y por el falso de la condición. Lo más importante que hay que tener en cuenta que se realizan las actividades de la rama del verdadero o las del falso, NUNCA se realizan las actividades de las dos ramas. En una estructura condicional compuesta tenemos entradas, salidas, operaciones, tanto por la rama del verdadero como por la rama del falso.
Realizar un programa que solicite ingresar dos números distintos y muestre por pantalla el mayor de ellos.
Se hace la entrada de num1 y num2 por teclado.
Para saber cual variable tiene un valor mayor preguntamos si el contenido de num1 es mayor (>) que el contenido de num2, si la respuesta es verdadera vamos por la rama de la derecha e imprimimos num1, en caso que la condición sea falsa vamos por la rama de la izquierda (Falsa) e imprimimos num2.
Como podemos observar nunca se imprimen num1 y num2 simultáneamente.
 import java.util.Scanner;  public class EstructuraCondicionalCompuesta1 {    public static void main(String[] ar) {      Scanner teclado=new Scanner(System.in);      int num1,num2;      System.out.print("Ingrese primer valor:");      num1=teclado.nextInt();      System.out.print("Ingrese segundo valor:");      num2=teclado.nextInt();      if (num1>num2) {        System.out.print(num1);      } else {        System.out.print(num2);      }    }  } 

​

La estructura condicional compuesta también permite la concatenación de varias sentenecias condicionales de modo que podemos tener un bloque como el siguiente:

 if (condición 1){   Bloque de código 1 }else if (condición 2){   Bloque de código 2 }else{   Bloque de código alternativo }
 public class EjemploCondicionalCompuesto{   public static void main(String args[]){     int edadPedro=25;     int edadLuis=22;     System.out.println("BIENVENIDO AL PROGRAMA");     if (edadPedro>=18 && edadLuis>=18){       System.out.println("Pedro y Luis son mayores de edad");       System.out.println("Pedro y Luis pueden votar");     } else if(edadPedro>=18 && edadLuis<18){       System.out.println("Pedro es mayor de edad,Luis no");       System.out.println("Pedro puede votar, Luis no");     } else if(edadPedro<18 && edadLuis>=18){       System.out.println("Luis es mayor de edad, Pedro no");       System.out.println("Luis puede votar, Pedro no");     } else{       System.out.println("Pedro y Luis no son mayores de edad");       System.out.println("Ni Pedro ni Luis pueden votar");     }     System.out.println("FIN DE PROGRAMA");   } } 

Se emplea cuando se quiere ejecutar un bloque de código siempre y cuando se cumplan las condiciones.

Estas condiciones devuelven un valor booleano, es decir, true o false.

Condicional switch

Es similar a la estructura if()...else if()...else if()...else, pero con ciertas limitaciones:

  • Sólo admite una condición. No son validos los operadores && y ||.
  • En esa condición se presupone que el operador de relación es la igualdad (==).
  • La variable asociada a la condición sólo puede ser de tipo byte, short, int o char, ninguna otra es válida.

Se ejecutan todas las instrucciones a partir del segundo case (es el que coincide con la variable operador). Si no hay ningún case coincidente, se ejecuta el código asociado a default.

Switch1

 public class EjemploSwitch1{   public static void main(String args[]){     char operador='+';     switch(operador){       case '-':                System.out.println("El operador es -");       case '+':                System.out.println("El operador es +");       case '*':                System.out.println("El operador es *");       case '/':                System.out.println("El operador es /");       default:                System.out.println("Operador desconocido");     }     System.out.println("FIN DE PROGRAMA");   } } 

No se puede repetir ningún case con el mismo valor. Se produce error de compilación

Si se quiere que el programa, cuando encuentre el primer case coincidente con el valor de la variable evaluada, salga del switch, debe agregarse a cada case la instrucción break del siguiente modo: 

Switch 2

 public class EjemploSwitch2{   public static void main(String args[]){     char operador='+';     switch(operador){       case '-':           System.out.println("El operador es -");           break;       case '+': System.out.println("El operador es +");           break;       case '*':          System.out.println("El operador es *");          break;       case '/':          System.out.println("El operador es /");          break;       default:          System.out.println("Operador desconocido");     }     System.out.println("FIN DE PROGRAMA");   } } 

Bucle For

El bucle For se utiliza para repetir una o más instrucciones un determinado número de veces. De entre todos los bucles, el FOR se suele utilizar cuando sabemos seguro el número de veces que queremos que se ejecute. 

El  número de veces que se repetirá depende del cumplimiento de una condición fijada por el programador.

Sintaxis

 for(variable de control; condición; actualización de la variable de control){      Bloque de código que se ejecutará en cada iteración hasta que se      incumpla la condición. }

Se quiere desarrollar un programa que muestre por consola los números del 0 al 4. Con los conceptos aprendidos hasta ahora solamente podríamos hacer lo siguiente: 

Sin bucle for

     public class Numeros{       public static void main(String args[]){          int x1=0;          int x2=1;          int x3=2;          int x4=3;          int x5=4;          System.out.println(x1);          System.out.println(x2);          System.out.println(x3);          System.out.println(x4);          System.out.println(x5);          System.out.println("FIN DE PROGRAMA");        }      } 

Ahora, con este nuevo bucle, podríamos hacer lo mismo de manera más sencilla:

Con bucle for

 public class BucleFor{     public static void main(String args[]){         for(int i=0;i<5;i++)             System.out.println(i);         System.out.println("FIN DE PROGRAMA");     } }

Bucle For Extendido

En las últimas versiones de Java se introdujo una nueva forma de uso del for, a la que se denomina for extendido o for each.

Esta forma de uso del for, que ya existía en otros lenguajes, facilita el recorrido de objetos existentes en una colección sin necesidad de definir el número de elementos a recorrer.

Sintaxis

 for (TipoARecorrer nombreVariableTemporal : nombreDeLaColección     Instrucciones }
Para saber si un for es un for extendido o un for normal hemos de fijarnos en la sintaxis que se emplea. 

En el siguiente ejemplo vamos a ver como podemos utilizar el bucle for extendido para realizar la tarea anterior.

Para ello crearemos una variable de tipo array que contendrá los números que queremos mostrar y que se llamará numeros, después recorreremos  la variable almacenando cada objeto (de tipo int) en la variable numero y por último mostraremos el valor de esa variable en pantalla.

 public class ForExtendido {     static int[] numeros =  {0,1,2,3,4};     public static void main (String args0[]){         for(int numero:numeros){             System.out.println(numero);         }     } }

El for extendido tiene algunas ventajas y algunos inconvenientes. No siempre es aconsejable utilizarlo.

El for extendido es una herramienta muy útil cuando tenemos que realizar recorridos completos de colecciones, por lo que lo usaremos en numerosas ocasiones antes que bucles for o while que nos obligan a estar pendientes de más cuestiones (por ejemplo en este caso con el for, de llevar un contador, llamar en cada iteración a un método, etc.).

Bucle while

La sentencia while es la más sencilla de las estructuras de iteración. La iteración continuará hasta que su condición sea falsa.

Sintaxis:

while ( condición ) sentencia ;

  • La condición tiene que tomar un valor booleano (verdadero o falso).
  • Si este valor es verdadero, se ejecutará la sentencia.
  • Concluida esta acción se vuelve a evaluar la condición.
  • Proseguirán los ciclos hasta que la condición no cambie a falso.

Esta es una estructura de iteración preprueba, es decir primero se evalúa la condición antes de realizar cualquier acción. Si de entrada la condición es falsa nunca ejecutará el conjunto de sentencias.

 public class BucleWhile{     public static void main(String args[]){         while(i<5){             System.out.println(i);                         i++;                 }         System.out.println("FIN DE PROGRAMA");     } }

Bucle do ... while

Es casi igual al anterior: la diferencia se basa en que un bucle do...while se ejecuta, al menos una vez, el bloque de código encerrado dentro del bucle, independientemente del valor booleano que devuelva la condición del while.

Sintaxis

 do{    bloque de código a ejecutar en cada iteracción }while(condición booleana)
 public class EjemploDoWhile{     public static void main(String args[]){         int i=0;         do{             System.out.println(i);             i++;         }         while(i<=5);         System.out.println("FIN DEL PROGRAMA");     } }

Sentencias break, return y continue

Break

Aplicable dentro de bucles y estructuras condicionales de tipo switch. Su ejecución provoca que se salga del bucle o etiqueta que se esté ejecutando sin finalizar el resto de las sentencias asociadas al mismo.

public class EjemploBreak{
public static void main(String args[]){
   for(int i=0;i<=10;i++){
     if(i==3) //Se sale del bucle en el momento en que i llega a 3 break;
       System.out.print(i+" ");
   }
   System.out.println("Fuera del bucle");
 }
}

Return

Se utiliza para truncar la ejecución de un método o para almacenar el dato que devuelven. Puede emplearse para truncar bucles cuando no haya más código después del bucle

public class EjemploReturn{
  public static void main(String args[]){
    EjemploReturn er=new EjemploReturn();
    er.unMetodo(10);
    System.out.println("FIN DE PROGRAMA");
  }
  public void unMetodo(int num){
    System.out.println("Primera linea de unMetodo");
    if(num==10){
      System.out.println("Has introducido 10"); //Implica que se sale del método return;
    }
    System.out.println("Fin de linea de unMetodo");
  }
}

Se sale del bucle en el momento en que i llega a 3. Si se sustituye break por return, se trunca la ejecución del método main
Continue
Aplicable sólo a bucles. Finaliza la iteración i que en ese momento se está ejecutando (significa que no ejecuta el resto de sentencias hasta el final del bucle) y vuelve a analizar la condición del bucle, pero con la siguiente iteración i+1.
 
public class EjemploContinue{ 
  public static void main(String args[]){ 
    for(int i=0;i<=10;i++){ 
      if(i==3) 
        continue; 
      System.out.print(i+" "); 
    } 
    System.out.println("\nFuera del bucle"); 
  } 
}

Bucles anidados

 Es uno o más bucles for dentro de otro. Se pueden poner los que se consideren necesarios.

 ublic class BuclesAnidados1{
    public static void main(String args[]){
        System.out.println("INICIO DEL PROGRAMA");
        for(int i=1;i<=4;i++){
            for(int j=1;j<=3;j++)
                System.out.print(i+"."+j+" ");
        }
        System.out.println("\nFIN DE PROGRAMA");
    }
}

 

Si desea obtener un acceso sin restricciones a los contenidos del curso de Programación en Java y disfrutar de todas las herramientas del aula virtual (Videos explicativos streaming, acceso a los foros, chat, ejercicios resueltos, la ayuda del tutor, audioconferencia, estudio de grabación, test y actividades de autoevaluación, etc...) puede inscribirse completamente gratis y comenzar a realizar de forma inmediata el curso.
Este sitio web utiliza cookies de terceros con la finalidad de analizar el uso que hace de nuestra web y personalizar el contenido de los anuncios. Si continúa navegando entendemos que acepta su uso. Más información × Cerrar