Leer números por teclado

Para poder pedir datos desde consola se necesita crear un objeto de la clase Scanner sobre el
elemento de consola que es el System.in. 

Scanner entrada=new Scanner(System.in);

La línea anterior crea un objeto de la clase Scanner, el cual podemos utilizar todos los
métodos disponibles en dicha clase, como parámetro indica un valor de entrada del sistema.

Para poder utilizar esta clase, antes que nada se debe importar ya que ésta se encuentra externa
a otro paquete del nuestro, se utiliza la siguiente línea de código:

import java.util.Scanner;

 A partir de ese momento cada vez que queramos que el usuario nos dé una entrada por
teclado, se debe declarar una variable de tipo int se de llamar al método .nextInt()

Entero variable;
variable=Objeto.método;

Ejemplo:

int numero;
num=entrada.nexInt ();

 entrada.nextLine(); indica un método del objeto entrada que permite capturar cadenas de
texto, pero como mencione antes, todavía no es importante entender todo el código.

 Para verificar que se captura el número ingresado, la mandamos a imprimir:

System.out.println(num);

Ejercicio:

Realizar un proyecto q permita ingresar dos datos numéricos.

int numero1=0;
int numero2=0;
int resultado=0;
Scanner entrada= new Scanner(System.in);
System.out.println("Ingrese el primer número:");
numero1=entrada.nextInt();
System.out.println("Ingrese el segundo número:");
numero2=entrada.nextInt();
resultado=numero1+numero2;
System.out.println("El resultado es: "+resultado);
Ejercicio:

Realizar un proyecto q permita ingresar tres números por teclado, calcular la suma y visualizar
por pantalla.

Ejercicio:

Realizar un proyecto q permita ingresar dos números por teclado, calcular la suma, resta
multiplicación, división, potenciación y visualizar por pantalla.

Leer una variable de tipo String desde el teclado en Java

En este programa, el dato que se introduce por teclado es el nombre de una persona, es decir,
una cadena de caracteres. Por tanto, para almacenar dicho dato, se puede declarar una variable
de tipo String.

String nombre;

String en un tipo de objeto definido por Java. Por tanto, en la variable nombre se almacenará
una referencia (dirección de memoria) a un objeto (instancia) de la clase String. Por otra parte,
para leer el dato introducido por teclado se puede utilizar la clase Scanner de Java. Para ello,
se puede escribir:

Scanner teclado = new Scanner(System.in);

Con esta sentencia, se crea un nuevo (new) objeto, llamado teclado, de la clase Scanner. En
cuanto a System.in, hace referencia a la entrada (input) estándar, es decir, al teclado.

Posteriormente, se puede llamar (invocar) al método nextLine del la clase Scanner para leer la
cadena de caracteres (dato) que introduzca el usuario y, mediante el operador de asignación
(=), asignarle a la variable nombre la dirección de memoria donde está almacenado dicho dato.
Esto se puede hacer con la sentencia:

nombre = teclado.nextLine();

Ejercicio:

Realizar un proyecto q permita ingresar 10 datos de estudiante por pantalla.

public static void main(String[] args) {

//-----------------------------------------------------//
//------------- DECLARAMOS LAS VARIABLES --------------//
//-----------------------------------------------------//

Scanner entrada = new Scanner(System.in);

 String nombre;
String direccion;
int edad;
double sueldo;

//-----------------------------------------------------//
//--------------- CARGAMOS LOS VALORES ----------------//
//-----------------------------------------------------//

System.out.println(".:: BIENVENIDOS ::.");

System.out.print("Ingrese su nombre y apellido: ");

nombre = entrada.nextLine();

System.out.print("Ingrese su direccion: ");

direccion = entrada.nextLine();

System.out.print("Ingrese la edad: ");

edad = entrada.nextInt();

System.out.print("Ingrese el sueldo: ");

sueldo = entrada.nextDouble();

//-----------------------------------------------------//
//------------- IMPRIMIMOS LOS RESULTADOS -------------//
//-----------------------------------------------------//

System.out.print("\n\n LOS RESULTADOS INGRESADOS SON:\n\n");

System.out.println("NOMBRE: \t" + nombre);

System.out.println("DIRECCION: \t" + direccion);
System.out.println("EDAD: \t\t" + edad);
System.out.println("SUELDO: \t" + "$ " + sueldo);
}

Ejercicio:

Realizar un proyecto q permita ingresar el nombre y visualizar por pantalla

import java.util.Scanner;

public class VariableNombre

{
public static void main(String[] args)
{
String nombre;

Scanner teclado = new Scanner(System.in);

System.out.print("Introduzca su nombre: ");
nombre = teclado.nextLine();
System.out.println("¡Hola " + nombre + "!");
}
}

mhttps://tutospoo.jimdo.com/tutoriales-java/mis-primeros-programas/pedir-datos-a-usuario/

http://java-inicial.blogspot.com/p/ingresar-datos-por-teclado-en-la-consola.html

Estructuras de repetición

Objetivo:

Implementar programas utilizando estructuras de repetición en un lenguaje orientado a

objetos.

Introducción

Los lenguajes de programación tienen elementos básicos que se utilizan como bloques
constructivos, así como reglas para que esos elementos se combinen. Estas reglas se
denominan sintaxis del lenguaje. Solamente las instrucciones sintácticamente correctas
pueden ser interpretadas por la computadora y los programas que contengan errores de
sintaxis son rechazados por la máquina.

La sintaxis de un lenguaje de programación se define como el conjunto de reglas que deben

seguirse al escribir el código fuente de los programas para considerarse como correctos
para ese lenguaje de programación.

Las estructuras de control permiten modificar el flujo de ejecución de las instrucciones de

un programa. Todas las estructuras de control tienen un único punto de entrada. Las
estructuras de control se pueden clasificar en: secuenciales, transferencia de control e
iterativas. Básicamente lo que varía entre las estructuras de control de los diferentes
 lenguajes es su sintaxis, cada lenguaje tiene una sintaxis propia para expresar la estructura.

Estructuras de control

Las estructuras de programación o estructuras de control permiten tomar decisiones o

realizar un proceso repetidas veces. En la mayoría de los lenguajes de programación, este
tipo de estructuras son comunes en cuanto a concepto, aunque su sintaxis varía de un
lenguaje a otro. La sintaxis de Java coincide prácticamente con la utilizada en C/C++, lo
que hace que para un programador de C/C++ no represente ninguna dificultad adicional.

Estructuras de repetición

Las estructuras de repetición, lazos, ciclos o bucles se utilizan para realizar un proceso
repetidas veces. El código incluido entre las llaves { } (opcionales si el proceso repetitivo
consta de una sola línea), se ejecutará mientras se cumplan determinadas condiciones.

Hay que prestar especial atención a los ciclos infinitos, hecho que ocurre cuando la
condición de finalizar el ciclo no se llega a cumplir nunca. Se trata de un fallo muy típico,
habitual sobre todo entre programadores poco experimentados.

Estructuras de ciclos o repetición (bucles)

Los bucles son estructuras de repetición. Bloques de instrucciones que se repiten un número de veces
mientras se cumpla una condición o hasta que se cumpla una condición.

Existen tres estructuras de repetición:

 Bucle for.
 Bucle do-while.
 Bucle while.
 Como regla general puede decirse que se utilizará el bucle for cuando se conozca de
antemano el número exacto de veces que ha de repetirse un determinado bloque de
instrucciones. Se utilizará el bucle do-while cuando no se conoce exactamente el
número de veces que se ejecutará el bucle pero se sabe que por lo menos se ha de
ejecutar una. Se utilizará el bucle while cuando es posible que no deba ejecutarse
ninguna vez.

 Estas reglas son generales y algunos programadores se sienten más cómodos utilizando
principalmente una de ellas. Con mayor o menor esfuerzo, puede utilizarse cualquiera
de ellas indistintamente.
Cuando hablamos de ciclos o repeticiones, comunmente es necesario emplear ciertas variables que
nos permitan llevar el control de cuantas repeticiones que se estan realizando o bien conservar
 valores. Estos tipos de variables reciben el nombre de contadores y acumuladores.

Contador 
Un contador es una variable cuyo valor se incrementa  o decrementa en una cantidad constante cada
vez que se produce un determinado suceso o acción.

Los contadores se utilizan con la finalidad de contar sucesos o acciones internas de un bucle; deben
realizar una operación de inicialización y posteriormente las sucesivas de incremento o decremento del
mismo.

La inicialización consiste en asignarle al contador un valor. Se situará antes y fuera del bucle.

Representación:
     contador  =  contador + valor_constante
Si en vez de incremento es decremento se coloca un menos en lugar del más.
Ejemplo: i = i + 1

Acumulador o totalizador
Es una variable que suma sobre sí misma un conjunto de valores para de esta manera tener la suma
de todos ellos en una sola variable. La diferencia entre un contador y un acumulador es que mientras
el primero va aumentando de uno en uno, el acumulador va aumentando en una cantidad variable.

Representación:
     Acumulador = acumulador + valor_variable

Ejemplos de valores de inicialización y acumulaciones:

     sumaCalificacion = 0;
    sumaCalificacion = sumaCalificacion +  calificacion;

Tupos de estructuras
Estructuras de Control repetitivas en Java: for, while, do while

Una estructura de repetición o bucle nos permite ejecutar un numero de veces determinado
una serie de instrucciones. La mayor utilidad es evitar la repetición de lineas de código
iguales. Para salir del bucle, se indica una condición, si esa condición no se cumple se sale del
bucle.

Las estructuras de repetición son:

  while: indicamos una condición que se ejecutara hasta que la condición sea falsa, es
importante que la variable que este en la condición, varíe para que no se produzca un
bucle infinito. Su sintaxis es:

El ciclo while permite ejecutar n veces un conjunto de

instrucciones siempre y cuando la condición se cumpla o sea
verdadera.
Nota importante: Este ciclo se utiliza cuando no sabemos el
número de veces exacto que se ejecutará el ciclo.
Si la condición siempre es verdadera o siempre se cumple este
ciclo puede crear un bucle que nunca termine, por eso hay que
tener en cuenta que en algún momento del ciclo la condición
no debe cumplirse (debe volverse falsa) para que el ciclo
termine, caso contrario el ciclo se vuelve infinito.
Vamos a ver un ejemplo

1. Ingresar un número por teclado e imprimir por la consola

su decena superior: Ejemplo sin ingreso el número 5, su
decena superior es 10, si ingreso el 25, su decena
superior es 30. 
Análisis del problema para saber que ciclo utilizar

El ejemplo anterior lo podemos resolver también con un ciclo

for, pero como no sabemos cuantas iteraciones o cuantas veces
se repite el ciclo ya que la decena superior cambiará de
acuerdo al número ingresado, es recomendable utilizar el ciclo
while.
A continuación el código.
while (condicion){
   instrucciones
}

Ejercicio:
package com.ecodeup.ciclos;
 
import java.util.Scanner;
 
public class TestCiclos {
public static void main(String[] args) {
int numero;
Scanner entrada = new Scanner(System.in);
System.out.println("Ingrese un número:");
 
try {
numero = entrada.nextInt();
while ((numero % 10) != 0) {
numero++;
}
System.out.println("La decena superior es: " + numero);
} catch (Exception e) {
System.out.println("Número no válido");
}
}
}

Ejercicio:
public class PruebaApp {
 
    public static void main(String[] args) {
 
        int num=1;
 
        while (num<=5){
            System.out.println(num);
            num++;
        }
    }
}

 for: este tipo de bucle, es como el anterior pero ademas de la condición, incluye una
inicialización de una variable y un incremento o decremento de esa variable, en
principio, no es necesario que incluya las 3 partes, se pueden inicializar o incrementar
varias varias separadas por comas. Cada parte se separa con un ; .

El ciclo for permite ejecutar un conjunto de sentencias un

número fijo de veces y antes de saber cómo funciona esta
sentencia, primero que nada vamos a ver la sintaxis.

 NOTA: cuando salimos del bucle, la variable inicializada no existe. Su sintaxis:

1for(inicializacion;condicion;incremento){
2   instrucciones
3}

Ahora un ejemplo
Desarrollar un programa que liste los N primeros y reporte su suma.
 1. Imprimir por consola los números enteros desde el 2
hasta 20
package com.ecodeup.ciclos;

public class TestCiclos {

public static void main(String[] args) {
for (int i = 2; i < 21; i += 2) {
System.out.println("Número: " + i);
}
}
}
Proceso

1. La variable i es declarada en inicializada en 2 (también se

la puede declarar en inicializar fuera y omitir esa parte).
2. Seguido de esto el compilador verifica si la variable i es
menor a 21, si es correcto continúa el ciclo, ejecuta la (s)
instrucciones y luego.
3. La variable i se incrementa en 2.

Ejemplo:

public class PruebaApp {

 
    public static void main(String[] args) {
 
        for (int num=1; num<=5; num++){
            System.out.println(num);
        }
    }
}

Ejercicio:

System.out.println("Tabla de multiplicar del 5");

for (int i =0 ; i <= 10; i++) {
System.out.println(5 + " * " + i + " = " + 5 * i);
}
Programa que suma los números pares comprendidos entre n1 y n2.

 do-while: esta estructura repetitiva, tiene algo especial y es que como mínimo las

instrucciones dentro de la estructura repetitiva al menos una vez, mientras que el while
sus instrucciones pueden ejecutarse 0 o N veces. Se sale del bucle cuando
la condición del while no se cumple, si esto pasa empieza desde el do. Se utiliza para
la validación de datos

a estructura de control DO WHILE

El ciclo do while también permite ejecutar n número de

veces un conjunto de instrucciones, es muy parecida a las
otras 2 estructuras de control que hemos visto anteriormente,
salvo que este ciclo siempre se ejecuta por lo menos una vez,
recordemos que en el ciclo for debemos conocer el número de
veces que se va ejecutar las instrucciones, el ciclo while hay
una condición que se debe cumplir para que se ejecuten las
instrucciones, en cambio en el ciclo do while primero se
ejecutan las instrucciones y luego verifica la condición y si
esta es verdadera el ciclo se repite hasta verificar de nuevo la
condición, para salir del ciclo la condición se debe volver
falsa.
La sintaxis del ciclo do while es la siguiente:
amos a ver un ejemplo

1. Obtener los dígitos de un número ingresado por teclado,

ejemplo 100, tiene 3 dígitos.
Una forma para obtener los dígitos que tiene un número,
realizamos divisiones sucesivas entre 10 hasta que el número
se vuelve cero (del resultado de la división sólo se debe tomar
la parte entera), para obtener el número de dígitos contamos
las veces que se ha dividido. Por ejemplo tenemos el número
345:
El resultado debe ser almacenado en una variable de tipo
entero.
345/10=34
34/10=3
3/10=0
En este caso se ha realizado 3 divisiones por lo que el número
de dígitos es 3.
package www.ecodeup.com;
 
public class TestCiclos {
 
public static void main(String[] args) {
int numero = 345;
int contador = 0;
do {
numero /= 10;
System.out.println(numero);
contador++;
} while (numero != 0);
System.out.println("El número tiene " + contador + " dígitos");
}
}

ambién hubiésemos podido utilizar el ciclo while que funciona

con todos los números, menos con el número 0 (cero), no
entra en el ciclo porque número es igual que cero y por ende
la respuesta va ser:
"El número tiene 0 dígitos"

1 "El número tiene 0 dígitos"

Esto se soluciona con el ciclo do while que me garantiza que

por lo menos el ciclo se va ejecutar una vez, con esto, si se
ingresa el número cero va ingresar al ciclo ya que la condición
se verifica al final.
Nota importante: Este ciclo se utiliza cuando sabemos que se
ejecutará el ciclo al menos una vez .
  Su sintaxis es:

1do{
2   intrucciones
3}while(condicion);

import javax.swing.JOptionPane;
public class PruebaApp {
 
    public static void main(String[] args) {
        int num;
        do{
            String texto=JOptionPane.showInputDialog("Introduce un numero
entre 0 y 10");
            num=Integer.parseInt(texto);
        }while(num>=10 || num<0);
        System.out.println("El numero introducido es "+num);
    }
}

Ejercicios de práctica para ciclos

Realizar los siguientes ejercicios para practicar en el laboratorio el uso de las sentencias while y do-
while.
  Elaborar un programa en Java haciendo uso de la sentencia while para que lea 10 números
cualquiera y que calcule el promedio de los mismos.
 Elaborar un programa en Java haciendo usao de la sentencia do-while para que leea una
lista de calificaciones enteras entre 0 y 10. Dicho programa dejará de repetir el ciclo hasta que
el usuario escriba una calificación de 0. Si el usuario escribe una calificación diferente a 0
entonces deberá sumarlos y calcular el promedio.

vbcvb

http://java-es.blogspot.com/2012/12/ejercicios-de-practica-para-ciclos.html

Ejercicio:

Programa que calcula el área de una figura geométrica dependiendo la opción seleccionada
por el usuario en un menú que se repite hasta seleccionar la opción “Salir”.
cccc

Ejemplo del uso de switch - case

Estructura switch - case
La instrucción switch es una forma de expresión de un anidamiento múltiple de instrucciones
if ... else. Su uso no puede considerarse, por tanto, estrictamente necesario, puesto que
siempre podrá ser sustituida por el uso de if. No obstante, a veces nos resultará útil al
introducir mayor claridad en el código.

La instrucción if-else puede ser engorrosa si es preciso enfrentarse a múltiples selecciones

con muchas alternativas.

Por ejemplo, suponga que se requiere un programa que presente un menú con diferentes
opciones:

1. Área de un Cuadrado
2. Área de un Triángulo
3. Área de un Circulo
4. Finalizar

Y en función de la opción que seleccione el usuario realice la operación.

Sintaxis:
switch (expresion) {
   case valor1:
      sentencia1;
      break;
   case valor2:
      sentencia2;
      break;
   ...
   [default:
      sentenciaN;]
}

Cada sentencia case se corresponde con un único valor de expresion. No se puede

establecer rangos o condiciones sino que se debe comparar con valores concretos.

Los valores no comprendidos en ninguna sentencia case se pueden manejar en la clausula

opcional default.

La instrucción break tiene la función de que una vez concluidas la ejecución de las sentencias
de cada caso, la secuencia del programa finalice hasta la siguiente instrucción que se encuentra
despues de las llave de cierre }.
Ejemplo
switch (opcion) {
   case 1:
      ...;
      break;
   case 2:
      ...;
      break;
   default:
      System.out.println ("Opción incorrecta…");
}

Nota 
- Los valores para cada uno de los casos deberán ser números enteros, caracteres o valores
enumerados. 
- No funcionan con valores flotantes o cadena de caracteres.
 

Problema: Lochería 'La Sabrocita'

Se requiere un programa para una lonchería, el cual deberá mostrar un menú de alimentos y
bebidas con sus respectivos precios. El usuario deberá indicar cual es el alimento en base a una
opción y a continuación el programa debe preguntar la cantidad del alimentos consumido. De
igual manera, el programa debe preguntar cual es la bebida consumida mediante otra opción y
preguntar por la cantidad.

Para finalizar el programa deberá calcular el total de alimentos, el total de bebidas y el total a
pagar.

Para mayor claridad ver el siguiente ejemplo. Los números en fondo amarillo indican los
valores que el usuario deberá capturar y los números en fondo verde los valores que el
programa deberá calcular a partir de los datos capturados.

Loncheria 'La sabrosita'

------------------------
1. Alimentos
   1. Tortas......$20.00
   2. Salbutes....$9.00
   3. Panuchos....$9.00
   4. Caldos......$20.00

2. Bebidas
   1. Horchata....$12.00
   2. Jamaica.....$12.00
   3. Embotellado.$15.00
   4. Machacados..$20.00

Elija un alimento: 1
   Cantidad: 3

Elija una bebida:4

   Cantidad: 1

Total alimentos: $60.00

Total bebidas: $20.00
Total a pagar: $80.00

Bbb

/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package javaapplication1;

/**
 *
 * @author Vannesa Chi Chan
 */
import java.util.*;

public class Main {

    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        // TODO code application logic here
        Scanner entrada = new Scanner(System.in);
        int opcion;
        System.out.println("Menus de opciones");
        System.out.println("------------------------");
        System.out.println("1.Calcular el área de un cuadrado");
        System.out.println("2. Calcular el area de un Triangulo");
        System.out.println("3. Calcular el area de un Circulo");
        System.out.println("4. finalizar");

        System.out.print("Elija la opcion:");

        opcion = entrada.nextInt();

        switch (opcion) {

            case 1:
                System.out.println("Ha seleccionado calcular el area
de un cuadrado...");
                int base;
                int altura;
                double areaCuadrado;
                System.out.println("Cual es la base del cuadrado");
                base = entrada.nextInt();
                System.out.println("Cual es la altura del cuadrado");
                altura = entrada.nextInt();

                areaCuadrado = base * altura;

                System.out.printf("El area del cuadrado es %f\n",
areaCuadrado);
                break;
            case 2:
                System.out.println("Ha seleccionado calcular el area
de un triangulo...");
                int lado1;
                int lado2;
                int lado3;
                double areaTriangulo;

                System.out.print("Dame el lado1");

                lado1 = entrada.nextInt();
                System.out.print("Dame el lado2");
                lado2 = entrada.nextInt();

                System.out.print("Dame el lado3");

                lado3 = entrada.nextInt();

                areaTriangulo = (lado1 * lado2) / 2;

                System.out.printf("El area del triangulo es %f\n",

areaTriangulo);
                break;
            case 3:
                System.out.println("Ha seleccionado calcular el area
de un circulo...");

                int radioCirculo;

                double areaCirculo;

                System.out.print("Cual es el radio del circulo?");

                radioCirculo = entrada.nextInt();

                areaCirculo = 3.1416 * (radioCirculo * radioCirculo);

                System.out.printf("El area del circulo es %f\n",
areaCirculo);
                break;
            default:
                System.out.println("Ha seleccionado terminar");
        }
    }
}

Nnnnn

Programa: Loncheria La Sabrosita

/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package antojitoslasabrosita;

/**
 *
 * @author Celso J. Cruz Caamal
 */

import java.util.*;

public class AntojitosLaSabrosita {

/**
     * @param args the command line arguments
     */
public static void main(String[] args) {
// TODO code application logic here
// Declaración de variables de entrada
Scanner entrada = new Scanner (System.in);

int opcionAlimento,
opcionBebida;

int cantidadAlimento,
cantidadBebida;

int totalAlimentos=0,
totalBebidas=0,
totalPagar=0;

System.out.println("Loncheria 'La sabrosita'");

System.out.println("------------------------");
System.out.println("--|Menu de alimentos|--");
System.out.println(" 1) Tortas......$20.00");
System.out.println(" 2) Salbutes....$9.00");
System.out.println(" 3) Panuchos....$9.00");
System.out.println(" 4) Caldos......$20.00");
System.out.println("");
System.out.println("--|Menu de bebidas|--");
System.out.println(" 1) Horchata....$12.00");
System.out.println(" 2) Jamaica.....$12.00");
System.out.println(" 3) Embotellado.$15.00");
System.out.println(" 3) Machacados..$20.00");

System.out.print ("Elija un alimento: ");

opcionAlimento = entrada.nextInt();

System.out.print (" ¿Cual es la cantidad? ");

cantidadAlimento = entrada.nextInt();

System.out.print ("Elija una bebida: ");

opcionBebida = entrada.nextInt();

System.out.print (" ¿Cual es la cantidad? ");

cantidadBebida = entrada.nextInt();

// analizar el tipo de alimento comprado

switch (opcionAlimento) {
case 1:
case 4:
totalAlimentos = cantidadAlimento * 20;
break;

case 2:
case 3:
totalAlimentos = cantidadAlimento * 9;
break;

default:
totalAlimentos = 0;
}

// analizar el tipo de bebida comprada

switch (opcionBebida) {
case 1:
case 2:
totalBebidas = cantidadBebida * 12;
break;

case 3:
totalBebidas = cantidadBebida * 15;
break;
 case 4:
totalBebidas = cantidadAlimento * 20;
break;

default:
totalBebidas = 0;
}

// cálculo del total a pagar

totalPagar = totalAlimentos + totalBebidas;

System.out.printf ("Total alimentos: $%d \n", totalAlimentos);

System.out.printf ("Total bebidas : $%d\n", totalBebidas);
System.out.printf ("Total a pagar : $%d\n", totalPagar);
}
}

Estructuras condicionales en Java:

La toma de decisiones en la programación es similar a la toma de decisiones en la vida
real. En la programación también enfrentamos algunas situaciones en las que queremos
que se ejecute cierto bloque de código cuando se cumple alguna condición.

Un lenguaje de programación utiliza instrucciones de control para controlar el flujo de

ejecución del programa en función de ciertas condiciones. Estos se utilizan para hacer
que el flujo de ejecución avance y se ramifique en función de los cambios en el estado
de un programa.

Declaraciones de selección de Java:

 if
 if-else
 nested-if
 if-else-if
 switch-case
 jump – break, continue, return

Estas declaraciones le permiten controlar el flujo de la ejecución de su programa en

función de condiciones conocidas solo durante el tiempo de ejecución.

 if
 La sentencia if, actúa como cabría esperar. Si la condición es verdadera, la sentencia se
ejecuta, de otro modo, se salta dicha sentencia, continuando la ejecución del programa con
otras sentencias a continuación de ésta. La forma general de la sentencia if es:

La estructura condicional más simple en Java es el if, se evalúa una condición y en caso
de que se cumpla se ejecuta el contenido entre las llaves {} o en caso de que se omitan se
ejecuta el código hasta el primer «;» por lo tanto si no se usan los {} la condición aplica solo a
la siguiente instrucción al if.

if (condición)
{
//Código a ejecutar si condición es true
}

 if-else

La instrucción if tiene la siguiente estructura:

if (condición)
{
//Código a ejecutar si condición es true
}
else
{
//Código a ejecutar si condición es false
}

Condicionales en Java, uso de if/else ejemplos de uso

Explicación en la vida diaria:

Normalmente durante el trascurso de nuestras vidas debemos tomar decisiones

utilizando el condicional “SI”, como cuando decimos:

SI gano la materia mis padres me compraran la bicicleta que les pedí, SI NO la gano me
castigaran y no me dejaran salir.

Esa es una estructura condicional en la cual el flujo de la acción puede tomar dos
caminos distintos (pero solo un camino), bien en java es igual solo que debemos tener
en cuenta la sintaxis del lenguaje, anotaciones correspondientes y operadores de
relación los cuales nos permitirán establecer las condiciones que deseemos.
Veamos también una gráfica del comportamiento del flujo del programa:
Operadores

En una condición deben disponerse únicamente variables, valores constantes y

operadores relacionales, algo a recalcar también es que los operadores deben usarse sin
espacios, de lo contrario tendremos un error en el código.

Operadores Relacionales:

> (Mayor)
< (Menor) >= (mayor o igual)
< = (menor o igual)
== (igual) Nota: no se debe confundir con “=”, ya que este otro es
para asignación de valor.
!= (distinto)

Operadores Matemáticos

+ (Más)
- (menos)
* (Producto)
/ (División)
% (resto de una división)

Los operadores aritméticos

operador: OperadorAp.java

e detalla con ejemplos todos los tipos de operadores que existen en Java. Como por
ejemplo: Operadores relacionales, aritméticos, lógicos, de asignación, entre otros.

Java proporciona muchos tipos de operadores que se pueden usar según la necesidad. Se
clasifican según la funcionalidad que brindan. Algunos de los tipos son los siguientes:

 Operadores aritméticos
 Operadores unarios
 Operador de asignación
 Operadores relacionales
  Operadores lógicos
 Operador ternario
 Operadores bit a bit
 Operadores shift
 Operador de instancia
 Precedencia y Asociatividad de Operadores

1. Operadores aritméticos

Java tiene cinco operadores aritméticos cuyo significado se muestra en la tabla adjunta

Operador Nombre Ejemplo

+ Suma 3+4

- Diferencia 3-4

* Producto 3*4

/ Cociente 20/7

% Módulo 20%7

Operadores de INCREMENTO Y DECREMENTO

OPERADOR OPERACIÓN

Incrementa en 1. El valor del incremento se observa en la siguiente

a++
línea de código.

Decrementa en 1.El valor del incremento se observa en la siguiente

a- –
línea de código.

Incrementa en 1. El valor del incremento se observa en la misma línea

++a
de código.

Decrementa en 1.El valor del incremento se observa en la siguiente línea de

– -a
código.

package com.ecodeup.operadores;
public class EjecutorOperadores {
public static void main(String[] args) {
//operadores de incremento y decremento
int a=0;
int b=0;
//postfijo a++ a--
//prefijo ++a --a
System.out.println("Incremetno A con postfijo: "+a++);
System.out.println("Variable A actualizada: "+a);
System.out.println("Incremetno B con prefijo: "+ ++b);
}
}
Operadores de ASIGNACIÓN
OPERADOR OPERACIÓN

a*=a Asigna en a el producto de lo que tiene actualmente a multiplicado por a

a+=a Asigna en a la suma de lo que tiene actualmente a mas a

a-=a Asigna en a la resta de lo que tiene actualmente a menos a

a/=a Asigna en a la división de lo que tiene actualmente a dividido entre a

package com.ecodeup.operadores;

public class EjecutorOperadores {

public static void main(String[] args) {
//operadores de asignación
//*=, /=,+=, -=, =
int a=5;
a*=a; // a* a
System.out.println("El valor de a: "+a);
}
}

Ejercicio:

// Programa Java para ilustrar

// operadores unarios
public class operators
{
public static void main(String[] args)
{
int a = 20, b = 10, c = 0, d = 20, e = 40, f = 30;
boolean condition = true;

// operador de pre-incremento
// a = a+1 y entonces c = a;
c = ++a;
System.out.println("Valor de c (++a) = " + c);

// operador de post-incremento
// c=b entonces b=b+1 (b pasa a ser 11)
c = b++;
System.out.println("Valor de c (b++) = " + c);

// operador de pre-decremento
// d=d-1 entonces c=d
c = --d;
System.out.println("Valor de c (--d) = " + c);

// operador de post-decremento
// c=e entonces e=e-1 (e pasa a ser 39)
 c = e--;
System.out.println("Valor de c (e--) = " + c);

// Operador lógico not

System.out.println("Valor de !condition = " + !condition);

}
}

Salida:

Valor de c (++a) = 21
Valor de c (b++) = 10
Valor de c (--d) = 19
Valor de c (e--) = 40
Valor de !condition = false
3. Operador de asignación (=)

El operador de asignación se usa para asignar un valor a cualquier variable. Tiene una
asociación de derecha a izquierda, es decir, el valor dado en el lado derecho del
operador se asigna a la variable de la izquierda y, por lo tanto, el valor del lado derecho
debe declararse antes de usarlo o debe ser una constante.

El formato general del operador de asignación es, variable = valor;

n muchos casos, el operador de asignación se puede combinar con otros operadores para
construir una versión más corta de la declaración llamada Declaración
Compuesta (Compound Statement). Por ejemplo, en lugar de a = a + 5, podemos
escribir a + = 5.

int a = 5;
a += 5; // a = a + 5;

 + = , para sumar el operando izquierdo con el operando derecho y luego

asignarlo a la variable de la izquierda.
 – = , para restar el operando izquierdo con el operando derecho y luego asignarlo
a la variable de la izquierda.
 * = , para multiplicar el operando izquierdo con el operando derecho y luego
asignándolo a la variable de la izquierda.
 / = , para dividir el operando izquierdo con el operando derecho y luego
asignarlo a la variable de la izquierda.
 ^ = , para aumentar la potencia del operando izquierdo al operando derecho y
asignarlo a la variable de la izquierda.
 % = , para asignar el módulo del operando izquierdo con el operando derecho y
luego asignarlo a la variable de la izquierda.

Ejemplo:

// Programa Java para ilustrar

// Operadores de Asignación
public class operators
{
public static void main(String[] args)
{
int a = 20, b = 10, c, d, e = 10, f = 4, g = 9;
 // operador de asignación simple
c = b;
System.out.println("Valor de c = " + c);

// Esta siguiente declaración arrojaría una exception

// porque el valor del operando derecho debe ser inicializado
// antes de la asignación, entonces el programa no
// compila.
// c = d;

// operadores de asignación simples

a = a + 1;
b = b - 1;
e = e * 2;
f = f / 2;
System.out.println("a,b,e,f = " + a + ","
+ b + "," + e + "," + f);
a = a - 1;
b = b + 1;
e = e / 2;
f = f * 2;

// operados de asignación compuestos/cortos

a += 1;
b -= 1;
e *= 2;
f /= 2;
System.out.println("a,b,e,f (usando operadores cortos)= " +
a + "," + b + "," + e + "," + f);
}
}

Salida:

Valor de c = 10
a,b,e,f = 21,9,20,2
a,b,e,f (usando operadores cortos)= 21,9,20,2

Nos habremos dado cuenta que el operador más importante y más frecuentemente usado
es el operador asignación =, que hemos empleado para la inicialización de las variables.
Así,

int numero;
numero=20;

la primera sentencia declara una variable entera de tipo int y le da un nombre (numero).
La segunda sentencia usa el operador asignación para inicializar la variable con el
número 20.

Consideremos ahora, la siguiente sentencia.

a=b;
que asigna a a el valor de b. A la izquierda siempre tendremos una variable tal como a,
que recibe valores, a la derecha otra variable b, o expresión que tiene un valor. Por
tanto, tienen sentido las expresiones

a=1234;
double area=calculaArea(radio);
superficie=ancho*alto;

Sin embargo, no tienen sentido las expresiones

1234=a;
calculaArea(radio)=area;

Las asignaciones múltiples son también posibles. Por ejemplo, es válida la sentencia

c=a=b; //equivalente a c=(a=b);

la cual puede ser empleada para inicializar en la misma línea varias variables

c=a=b=321; //asigna 321 a a, b y c

El operador asignación se puede combinar con los operadores aritméticos

Expresión Significado

x+=y x=x+y

x-=y x=x-y

x*=y x=x*y

x/=y x=x/y

concatenación de strings

En Java se usa el operador + para concatenar cadenas de carcateres o strings. Veremos

en el siguiente apartado una sentencia como la siguiente:

System.out.println("la temperatura centígrada es "+tC);

Espinoza pas
Jessi Uribe

4. Operadores relacionales

Estos operadores se utilizan para verificar relaciones como igualdad, mayor que, menor
que. Devuelven el resultado booleano después de la comparación y se usan ampliamente
en las instrucciones de bucle, así como en las sentencias condicionales if/else. El
formato general es, variable operador_relacion valor

Algunos de los operadores relacionales son:

  ==, Igual a: devuelve verdadero si el valor del lado izquierdo es igual al lado derecho.
 ! =, No igual a: devuelve verdadero si el valor del lado izquierdo no es igual al lado
derecho.
 <, menos que: el resultado verdadero si el valor del lado izquierdo es inferior al del
lado derecho.
 <=, menor o igual que: devuelve verdadero si el valor del lado izquierdo es menor o
igual que el lado derecho.
 >, Mayor que: devuelve verdadero si el valor del lado izquierdo es mayor que el lado
derecho.
 > =, Mayor que o igual a: regresa verdadero si el valor del lado izquierdo es mayor o
igual que el lado derecho.

Ejemplo:

// Programa Java para ilustrar

// operadores relacionales
public class operators
{
public static void main(String[] args)
{
int a = 20, b = 10;
String x = "Thank", y = "Thank";
int ar[] = { 1, 2, 3 };
int br[] = { 1, 2, 3 };
boolean condicion = true;

//varios operadores condicionales

System.out.println("a == b :" + (a == b));
System.out.println("a < b :" + (a < b));
System.out.println("a <= b :" + (a <= b));
System.out.println("a > b :" + (a > b));
System.out.println("a >= b :" + (a >= b));
System.out.println("a != b :" + (a != b));

// Los Arrays no se pueden comparar con

// operadores relacionales porque los objetos
// almacenan referencias, mas no el valor
System.out.println("x == y : " + (ar == br));

System.out.println("condicion==true :" + (condicion == true));

}
}

Salida:

a == b :false
a < b :false
a <= b :false
a > b :true
a >= b :true
a != b :true
x == y : false
condicion==true :true
5. Operadores lógicos

Estos operadores se utilizan para realizar operaciones “lógicas AND” y “lógicas OR”,
es decir, la función similar a la puerta AND y la puerta OR en electrónica digital. Una
cosa a tener en cuenta es que la segunda condición no se evalúa si la primera es falsa, es
decir, tiene un efecto de cortocircuito. Se usa ampliamente para probar varias
condiciones para tomar una decisión.

Los operadores condicionales son:

 &&, AND lógico: devuelve verdadero cuando ambas condiciones son

verdaderas.
 || , O lógico: devuelve verdadero si al menos una condición es verdadera.
 ! b NOT: Es la negación del valor de b, si b es true, utilizando este operador se
vuelve falso

b NOT: Es la negación del valor de b, si b es true, utilizando este operador se vuelve

! falso

Ejemplo:

// Programa Java para ilustrar

// operadores logicos
import java.util.Scanner;

public class operators

{
public static void main(String[] args)
{
String x = "java";
String y = "desdecero";

Scanner s = new Scanner(System.in);

System.out.print("Ingrese usuario:");
String uuid = s.next();
System.out.print("Ingrese contraseña:");
String upwd = s.next();

// Verifique si el nombre de usuario y la contraseña coinciden o no.

if ((uuid.equals(x) && upwd.equals(y)) ||
(uuid.equals(y) && upwd.equals(x))) {
System.out.println("Bienvenido usuario.");
} else {
System.out.println("ID o Contraseña equivocada");
}

}
}

Salida:

Ingrese usuario:java
Ingrese contraseña:desdecero
Bienvenido usuario.

6. Operador ternario

Ternario es una versión abreviada de la declaración if-else. Tiene tres operandos y de

ahí el nombre ternario. El formato general es: condicion ? if true : if false

La declaración anterior significa que si la condición se evalúa como verdadera, entonces

ejecuta las instrucciones después del ‘?‘ de lo contrario, ejecuta las instrucciones
después de ‘:‘.

Ejemplo:

// Programa Java para ilustrar

// el máximo de tres números utilizando
// operador ternario.
public class operators
{
public static void main(String[] args)
{
int a = 20, b = 10, c = 30, result;

//el resultado obtiene el máximo de tres

//numeros
result = ((a > b) ? (a > c) ? a :
c : (b > c) ? b : c);
System.out.println("Máximo de tres números = "+result);
}
}

Salida:

Máximo de tres números = 30

Extra: Secuencias de Escape en Java

Los valores numéricos y de texto en los programas de Java se conocen como “literales”;
no representan nada, pero son, literalmente, lo que ves.
Los literales normalmente se desprenden de las palabras clave del lenguaje Java, pero
cuando se requieren comillas dobles o comillas simples dentro de un valor de String, es
necesario indicar que el carácter de cita debe tratarse LITERALMENTE para evitar
terminar prematuramente el String. Esto se logra fácilmente mediante el prefijo
inmediato de cada carácter de comillas anidado con el operador de escape \.

Me explico mejor con el siguiente ejemplo:

String cita = " \"Java debe ser un territorio neutral, la Suiza de la

tecnología informática.\"dijo James Gosling";

Además, el operador de escape \ ofrece una variedad de secuencias de escape muy útiles
como son los siguientes:

Tabla de Secuencias de Escape en Java.

Escape Descripción

\n Nueva Linea.

\t Tabulador.

\b Backspace

\r Retorno del carro.

\f Form feed.

\\ Barra invertida (\)

\’ Comilla simple

\” Comilla doble

× Nota: Tanto \r como \f son caracteres de control de terminal o impresora y no tienen ningún
significado en Java.

Ejemplo de Escape:

class Escape {

public static void main( String[] args ) {

String cabecera = "\n\tPRONOSTICO DE CLIMA:\n" ;

cabecera += "\n\tDia\t\tMañana\tNoche\tCondiciones\n" ;
cabecera += "\t---\t\t-------\t----\t-----------\n" ;

String pronostico = "\tDomingo\t25C\t\t23C\t\tSoleado\n";

pronostico += "\tLunes\t24C\t\t19C\t\tSoleado\n";
pronostico += "\tMartes\t26C\t\t15C\t\tNublado\n";

System.out.print(cabecera+pronostico) ;
}
}
Salida:
 https://javadesdecero.es/basico/operador
es-en-java-ejemplos/