Entender un programa

1. Introducción

Durante la ejecución de una aplicación, permiten almacenar en memoria diferentes valores útiles para su correcto funcionamiento.

Antes de usar una variable en un programa, es importante saber dónde declararla, qué nombre y qué tipo asignarles. Estos aspectos se detallan en las siguientes secciones.

2. Las ubicaciones

En Java, las variables se pueden declarar en diferentes lugares del código, siempre que estén dentro de las llaves de una clase, interfaz o enumeración. No es posible declarar una variable fuera de estas estructuras.

Una regla esencial: una variable siempre se debe declarar antes de usarla.

Dependiendo de dónde se declare, una variable se clasifica en una de las siguientes categorías:

La siguiente estructura permite visualizar la ubicación de estas diferentes categorías:

public class UbicacionDeLasVariables {  
 
    // variable de instancia  
    int instanciaVariable;  
 
    // variable de clase 
    static int classVariable;  
 
    void unMetodo(int parametro) {   
       // variable locale   
       int locale = 0;   
    } 
} 

3. El nombre

El nombre de una variable en Java debe cumplir con ciertas reglas, incluso si el lenguaje deja una libertad relativa al desarrollador:

1. Funcionamiento

Es posible pasar argumentos a un programa Java para que se adapte su comportamiento, de acuerdo con los valores proporcionados.

Se puede acceder a estos argumentos a través del array de cadenas denominadas args, que se pasa como argumento del método main.

Para pasar argumentos durante la ejecución del programa, es suficiente con utilizar la herramienta java y agregar los argumentos directamente después del nombre del programa en la misma línea de comando. El separador que se utiliza es el espacio. Por ejemplo:

Java MyJavaProgram arg1 arg2 arg3 

En este caso, el array args contiene tres elementos: arg1, arg2 y arg3.

Si un argumento contiene un espacio, hay que delimitar el valor con comillas. Por ejemplo:

Java MyJavaProgram arg1 arg2 "arg 3" 

En este caso array args contendrá tres elementos: arg1, arg2 y arg3.

Si un argumento contiene un espacio, hay que delimitar el valor con el carácter \:

Java MyJavaProgram arg1 arg2 "arg \" 3 \ "" 

En este caso, args contiene las cadenas: arg1, arg2 y arg "3".

2. Utilización en un IDE

Estos son los pasos que hay que seguir para definir argumentos en un programa Java usando un IDE:

1. Los operadores unarios

Estos son los principales operadores unarios disponibles:

El operador ! solo se puede usar en variables de tipo boolean o en expresiones que producen un resultado boolean, como una comparación.

Los operadores unarios se pueden usar con dos notaciones diferentes: la notación prefijada, donde el operador se coloca antes del operando, y la notación postfijada, donde el operador se coloca después del operando. La posición del operador influye en cuándo se aplica la operación.

Si el operador está en la posición prefijada, actúa sobre el operando antes de que se use en la expresión.

Si el operador está en la posición postfijada, actúa después de usar el operando.

Esta distinción puede influir en el resultado. Por ejemplo:

int i;  
i = 3;  
System.out.println(i++); 

En este ejemplo, la sentencia muestra 3 porque el incremento se realiza después de que la variable se use en println.

Por el contrario:

int i;  
i = 3;  
System.out.println(i++); 

Aquí, la instrucción muestra 4 porque el incremento se realiza antes de que se use la variable.

Es importante señalar que, si la variable no se usa inmediatamente en una expresión, la notación prefijada y la notación postfijada producen el mismo efecto. Por tanto, las siguientes dos líneas de código son equivalentes:

i++;  
++i; 

2. Los operadores de asignación

El operador de asignación en Java se representa con el símbolo...

1. Presentación

Las estructuras de control permiten actuar sobre el progreso de un programa. Con ellos, puede cambiar el orden en que se ejecutan las sentencias.

Existen dos familias principales: las estructuras de decisión, que permiten elegir entre varios caminos de ejecución según una condición y las estructuras de bucle, que permiten repetir un bloque de instrucciones, siempre que una condición sea cierta o hasta que lo sea.

2. Estructuras de control

if (condición) {  
    instrucción;   
} 

if (condición) {  
   instrucción1;  
   instrucción2;  
   // etc.  
} 

if (condición) { 
    //Instrucciones ejecutadas si la condición es verdadera   
} else { 
    // Instrucciones ejecutadas si la condiciónes falsa  
} 

if (condición1) {  
    // instrucciones condición1 es verdadera 
} else if (condición2) { 
    // instrucciones si condición2 es verdadera   
} else { 
    // instrucciones que se ejecutan si no se cumplen ninguna de 
    // las condiciones precedentes   
} 

1. Ejercicio 1

Para practicar cómo manipular arrays en Java, este ejercicio sugiere que trabaje con una variedad de cadenas de caracteres que representan los nombres de pila. El objetivo es aprender a recorrer un array, analizar su contenido y luego cambiar el orden de los elementos.

Instrucciones:

Consejos:

Este ejercicio le permitirá practicar varios conceptos tratados en el capítulo: declarar tablas, recorrer con bucles, comparar cadenas y modificar datos.

2. Ejercicio 2

En este ejercicio, creará un array con diez direcciones de correo electrónico y luego calculará la cuota de mercado de cada proveedor de correo en la lista. Esto le permitirá manipular cadenas y practicar el análisis de su contenido.

La cuota de mercado se refiere a la proporción...

1. Ejercicio 1

import java.util.Arrays;  
  
public class Exercice1 {   
   public static void main(String[] args) {   
      // Crear un array de cinco nombres   
      String[] names = {"Alice", "Bob", "Charles", "David", "Eve"}; 
 
      // Mostrar cada nombre uno por uno en la consola   
      System.out.println("Mostrar los nombres:");   
      for (String name : names) {   
         System.out.println(name);   
      }  
   
      // Buscar el nombre más largo    
      String longestName = "";    
      for (String name : names) {   
         if (name.length() > longestName.length()) {   
            longestName= name;   
         }    
      }   
      System.out.println("El nombre más largo es: " + longestName); 
     
      // Invertir el orden de los nombres en el array   
      for (int i = 0; i < names.length / 2; i++) {   
         String temp = names[i];   
         names[i] = names[names.length - 1 - i];   
         names[names.length - 1 - i] = temp;   
      } 
  
      // Mostrar de nuevo todos los nombres en orden inverso   
      System.out.println("Mostrar los nombres en orden inverso:"); 
      for (String name : names) {   
         System.out.println(name);   
      }   
   }...