Estructura de un programa en Java, método main

1. Introducción

Cuando empiezas a programar, parece que basta con escribir código línea tras línea y todo funcionará. Pero en cuanto el programa se vuelve más complejo, empieza la confusión: dónde está cada cosa, por qué está escrita, y si hay que cambiar una línea — ¿dónde está exactamente?

Por eso Java, como la mayoría de lenguajes modernos, nos propone una manera de «ordenar» el código por estantes, para que en cualquier momento se pueda entender qué hace el programa y encontrar rápidamente el lugar necesario.

Imagina una empresa. Tiene departamento de RR. HH., contabilidad, departamento de IT, departamento de logística, etc. Cada departamento — su área de responsabilidad, su personal y sus tareas.

En un programa en Java cada «departamento» de ese tipo es una clase. Una clase se encarga, por ejemplo, de trabajar con usuarios; otra, de los cálculos; y otra, de trabajar con archivos.

Esta es la estructura típica de un proyecto sencillo:

• Main.java — la oficina principal: aquí está el «punto de entrada», desde donde todo comienza.
• User.java — el departamento donde se almacenan y procesan los datos del usuario.
• Calculator.java — el departamento de cálculos.
• FileHelper.java — los especialistas en archivos.

Incluso en un programa muy pequeño suele haber al menos una clase. ¡Y los proyectos grandes — son todo un rascacielos de cientos de clases!

2. Una clase es una caja de herramientas

Java es un lenguaje orientado a objetos, y en él todo son objetos. Los tipos de objetos se llaman clases.

Una clase es como una caja o un armario en el que guardamos lo que necesitamos: variables, métodos. Imagina una caja con la etiqueta «Martillos»: dentro solo hay herramientas relacionadas con martillos.

class Example 
{
    // Aquí estarán nuestras herramientas: variables y métodos
}

Las clases suelen contener variables y funciones. En Java es habitual llamar campos a las variables de la clase, y métodos a las funciones de la clase. Pero el significado no cambia.

¿Recuerdas nuestro primer código?

System.out.println("¡Hola a todos!");

En este código hay tanto una clase como métodos:

• System — es una clase que contiene métodos para trabajar con el sistema.
• out — es un campo que es un objeto de la clase PrintStream.
• println — es un método de la clase PrintStream, que imprime texto en pantalla.

En cierto modo, toda la programación se reduce a escribir nuestras propias clases y métodos que llaman a métodos de otras clases.

3. Forma abreviada del método main()

En realidad, el programa mínimo en Java se ve así:

class Program 
{
    public static void main(String[] args) 
    {
        // Aquí va tu código
    }
}

Contiene al menos una clase, que debe incluir el método main con el siguiente encabezado (firma):

public static void main(String[] args)

Sin embargo, en Java 21 apareció la posibilidad de escribir el método main() de forma abreviada. Luego el compilador de Java (al compilar) lo convierte en el método main() correcto.

Por eso, cada vez que escribes un código como:

void main() 
{
    Scanner console = new Scanner(System.in);
    int age = console.nextInt();
    System.out.println("Edad: " + age);
}

El compilador de Java lo transforma en el código:

class Program 
{
    public static void main(String[] args) 
    {
        Scanner console = new Scanner(System.in);
        int age = console.nextInt();
        System.out.println("Edad: " + age);
    }
}

4. Una clase típica de Java

Una clase típica de Java se ve más o menos así:

public class MathUtils 
{
    // Variables estáticas (globales para la clase)
    static final double PI = 3.14159;
    static int callCounter = 0;

    // Método estático: cálculo del área de un círculo
    public static double circleArea(double radius) 
    {
        callCounter++;
        return PI * radius * radius;
    }

    // Método estático: encontrar el máximo de dos números
    public static int max(int a, int b) 
    {
        callCounter++;
        return (a > b) ? a : b;
    }

    // Método estático: cuántas veces se llamaron los métodos
    public static int getCallCount() 
    {
        return callCounter;
    }

    // Accedemos a los campos y métodos desde el método main() 
    public static void main(String[] args) 
    {
        System.out.println("Área del círculo: " + circleArea(5));
        System.out.println("Máximo: " + max(10, 42));
        System.out.println("Los métodos se llamaron " + getCallCount() + " veces");
    }
}

¿Qué vemos aquí?

• Una clase puede tener muchos métodos.
• Una clase puede tener sus propias variables.
• Los métodos de la clase pueden llamarse entre sí.
• Los métodos de la clase pueden acceder a variables comunes.
• Antes de cada método hay las mismas «palabras mágicas», por ejemplo: public static.
• Antes de cada método hay diferentes tipos: int, double, void.

A continuación veremos todos estos matices.

5. Los campos (variables) de clase son su memoria

Dentro de una clase se pueden almacenar variables, que a menudo se llaman campos (fields). Son como celdas de memoria donde guardamos ciertos datos.

public class MathUtils 
{
    // Variables estáticas (globales para la clase)
    static final double PI = 3.14159;
    static int callCounter = 0;
}    

Los campos permiten a la clase recordar algo entre llamadas a distintos métodos. Por ejemplo, contar cuántas veces se pulsó un botón. O cuántas veces se llamó a un método (callCounter). Puede haber tantos campos como se necesite.

6. Los métodos son las acciones que puede realizar la clase

Los métodos son las «habilidades» de nuestra clase. Si la clase es un empleado, los métodos son sus habilidades: lo que sabe hacer.

Por ejemplo, un método puede:

• imprimir algo en pantalla,
• calcular la suma de dos números,
• recibir datos «de entrada» y devolver un resultado.

Estructura de un método:

1. Tipo de valor de retorno (por ejemplo, void — si no devuelve nada, o int — si devuelve un número).
2. Nombre del método (por ejemplo, circleArea).
3. Parámetros entre paréntesis (pueden faltar).
4. Llaves { ... } — el cuerpo del método.

public class MathUtils 
{
    // Método estático: cálculo del área de un círculo
    public static double circleArea(double radius) 
    {
        callCounter++;
        return PI * radius * radius;
    }

    // Método estático: encontrar el máximo de dos números
    public static int max(int a, int b) 
    {
        callCounter++;
        return (a > b) ? a : b;
    }
}    

Aprenderás más sobre los métodos y todos los matices relacionados en las próximas lecciones.

7. Modificadores de acceso

En Java se puede determinar qué partes de una clase son accesibles desde otras clases y cuáles se quedan solo para uso interno. Para ello se usan los modificadores de acceso.

• public — visible para todos. Estos métodos y campos se pueden usar/llamar desde cualquier parte del programa.
• private — visible solo dentro de la propia clase. Son detalles internos que no deberían estar disponibles para otros. Como si no existieran.

public class MathUtils 
{
    // Variables estáticas (globales para la clase)
    private static final double PI = 3.14159;
    private static int callCounter = 0;

    // Método estático: cálculo del área de un círculo
    public static double circleArea(double radius) 
    {
        callCounter++;
        return PI * radius * radius;
    }
}    

Regla de oro: los campos suelen hacerse private, y hacia fuera se «sacan» solo los métodos necesarios con el modificador public. Más detalles sobre los modificadores de visibilidad — en las próximas lecciones.

8. Métodos y variables estáticos

Normalmente, en Java una clase se utiliza como plantilla para crear objetos. Escribes tu clase, luego creas objetos de esa clase con la palabra clave new. Y solo después llamas a métodos en los objetos.

Sin embargo, existe una segunda forma de usar una clase: como contenedor de variables y métodos globales que se pueden llamar desde cualquier parte del programa. Precisamente para esto se utiliza la palabra clave static. Le dice al compilador de Java que los métodos y campos de la clase no están vinculados a un objeto de la clase, sino directamente a la propia clase. Y por eso se pueden llamar sin crear objetos de la clase.

De hecho, usas constantemente métodos de este tipo:

Integer.parseInt();     // Método estático parseInt() de la clase Integer
String.valueOf();       // Método estático valueOf() de la clase String 
Double.isInfinite();    // Método estático isInfinite() de la clase Double 
Arrays.copy();          // Método estático copy() de la clase Arrays 

El método main() siempre se declara estático, ya que con él comienza la ejecución de tu programa Java. Antes de crear cualquier objeto.

9. Truco en IDEA

La firma completa del método main() se ve así:

public static void main(String[] args) 

Y para no escribirla cada vez en IntelliJ IDEA, existen atajos de teclado. Escribe simplemente psvm y pulsa Tab, e IntelliJ IDEA escribirá por ti este código:

public static void main(String[] args) 
{
    
}

Es fácil recordarlo — psvm — son las primeras letras de public static void main.