Estructura básica de un programa Java
Introducción
Entender la estructura básica de un programa Java es fundamental para cualquier persona que esté iniciándose en este lenguaje de programación. Java es un lenguaje orientado a objetos, lo que significa que todo el código se organiza en clases y objetos. Esta organización no es arbitraria; sigue reglas específicas que permiten que el código sea ordenado, mantenible y escalable. En este artículo, exploraremos los elementos estructurales que conforman un programa Java, desde los paquetes hasta los métodos, y cómo estos componentes trabajan juntos para formar aplicaciones funcionales.
Componentes de un programa Java
Paquetes
Los paquetes en Java son directorios que contienen clases relacionadas entre sí. Proporcionan un mecanismo para organizar y agrupar clases según su funcionalidad, evitando conflictos de nombres y mejorando la modularidad.
La declaración de un paquete debe ser la primera línea del código fuente (exceptuando comentarios) y se realiza mediante la palabra clave package:
package com.ejemplo.miproyecto;
// Resto del código...
En este ejemplo, com.ejemplo.miproyecto es el nombre del paquete. La estructura de directorios correspondiente sería:
com/
└── ejemplo/
└── miproyecto/
└── MiClase.java
Importaciones
Después de la declaración del paquete, podemos importar clases o paquetes completos que vayamos a utilizar en nuestro código. Esto nos permite usar clases de otras bibliotecas o paquetes sin tener que escribir su nombre completo (incluyendo el paquete) cada vez.
package com.ejemplo.miproyecto;
import java.util.Scanner; // Importa una clase específica
import java.util.*; // Importa todas las clases del paquete java.util
import static java.lang.Math.PI; // Importa un miembro estático
// Resto del código...
Clases
Las clases son los bloques de construcción fundamentales en Java. Una clase es una plantilla que define el estado (atributos) y el comportamiento (métodos) de los objetos que se crearán a partir de ella.
package com.ejemplo.miproyecto;
import java.util.Scanner;
public class Calculadora {
// Atributos de la clase
private int resultado;
// Métodos de la clase
public void sumar(int a, int b) {
resultado = a + b;
}
public int getResultado() {
return resultado;
}
}
En este ejemplo, Calculadora es una clase que tiene un atributo resultado y dos métodos: sumar y getResultado.
Métodos
Los métodos en Java definen el comportamiento de una clase. Contienen instrucciones que realizan operaciones específicas y pueden aceptar parámetros y devolver valores.
public int multiplicar(int a, int b) {
return a * b; // Realiza una multiplicación y devuelve el resultado
}
El método main
El método main es especial en Java porque actúa como punto de entrada para la ejecución del programa. Todo programa Java ejecutable debe tener un método main con la siguiente firma:
public static void main(String[] args) {
// Código a ejecutar
}
public: Permite que el método sea accesible desde fuera de la clase.static: El método pertenece a la clase, no a instancias específicas.void: El método no devuelve ningún valor.main: El nombre específico que Java busca como punto de entrada.String[] args: Un array de cadenas que puede recibir argumentos de la línea de comandos.
Variables y constantes
Las variables son espacios de memoria que almacenan valores. En Java, todas las variables deben declararse con un tipo específico antes de usarse.
int edad = 25; // Variable de tipo entero
double salario = 1500.5; // Variable de tipo doble precisión
String nombre = "Ana"; // Variable de tipo cadena
boolean activo = true; // Variable de tipo booleano
Las constantes son variables cuyos valores no pueden cambiar después de la inicialización. Se declaran con la palabra clave final:
final double PI = 3.14159; // Constante
final int DIAS_SEMANA = 7; // Constante
Bloques de código
Los bloques de código en Java se delimitan por llaves {} y pueden contener declaraciones, sentencias y otros bloques. Los más comunes son:
- Bloques de clase: Contienen los atributos y métodos de una clase.
- Bloques de método: Contienen el código que se ejecuta cuando se llama al método.
- Bloques de control: Asociados a estructuras de control como bucles y condicionales.
Comentarios
Los comentarios son texto que se ignora durante la compilación y sirven para documentar el código:
// Este es un comentario de una línea
/*
* Este es un comentario
* de múltiples líneas
*/
/**
* Este es un comentario de documentación (Javadoc)
* @param x Descripción del parámetro
* @return Descripción del valor de retorno
*/
Ejemplo de un programa completo
A continuación, veamos un ejemplo completo que ilustra todos los componentes estructurales de un programa Java:
package com.ejemplo.calculadora;
import java.util.Scanner;
/**
* Clase Calculadora que realiza operaciones aritméticas básicas.
*/
public class Calculadora {
// Constante
private final String VERSION = "1.0";
// Atributo
private int memoria;
/**
* Constructor de la clase Calculadora.
*/
public Calculadora() {
this.memoria = 0;
}
/**
* Suma dos números y almacena el resultado en memoria.
* @param a Primer número
* @param b Segundo número
*/
public void sumar(int a, int b) {
memoria = a + b;
}
/**
* Resta dos números y almacena el resultado en memoria.
* @param a Primer número
* @param b Segundo número
*/
public void restar(int a, int b) {
memoria = a - b;
}
/**
* Devuelve el valor almacenado en memoria.
* @return El valor actual de la memoria
*/
public int getMemoria() {
return memoria;
}
/**
* Devuelve la versión de la calculadora.
* @return La versión de la calculadora
*/
public String getVersion() {
return VERSION;
}
/**
* Método principal que inicia la ejecución del programa.
* @param args Argumentos de la línea de comandos
*/
public static void main(String[] args) {
// Crear una instancia de la clase Scanner para leer la entrada del usuario
Scanner scanner = new Scanner(System.in);
// Crear una instancia de la calculadora
Calculadora calc = new Calculadora();
// Mostrar información
System.out.println("Calculadora Java versión " + calc.getVersion());
// Solicitar datos al usuario
System.out.print("Introduce el primer número: ");
int num1 = scanner.nextInt();
System.out.print("Introduce el segundo número: ");
int num2 = scanner.nextInt();
// Realizar operaciones
calc.sumar(num1, num2);
System.out.println("La suma es: " + calc.getMemoria());
calc.restar(num1, num2);
System.out.println("La resta es: " + calc.getMemoria());
// Cerrar el scanner
scanner.close();
}
}
Estructura de archivos y directorios
En proyectos Java reales, la estructura de archivos y directorios es importante para la organización y la compilación correcta:
-
Estructura básica:
MiProyecto/ ├── src/ │ └── com/ │ └── ejemplo/ │ └── miproyecto/ │ ├── Principal.java │ └── Utilidades.java ├── bin/ # Archivos compilados (.class) └── lib/ # Bibliotecas externas (.jar) -
Estructura de un proyecto Maven (común en aplicaciones empresariales):
MiProyecto/ ├── src/ │ ├── main/ │ │ ├── java/ │ │ │ └── com/ejemplo/miproyecto/ │ │ │ └── Principal.java │ │ └── resources/ │ │ └── config.properties │ └── test/ │ └── java/ │ └── com/ejemplo/miproyecto/ │ └── PrincipalTest.java ├── target/ # Archivos compilados y empaquetados └── pom.xml # Archivo de configuración de Maven
Convenciones de nomenclatura
Java sigue ciertas convenciones de nomenclatura que, aunque no son obligatorias, son ampliamente adoptadas por la comunidad:
- Paquetes: Todo en minúsculas, usando el dominio invertido como prefijo (ej.
com.empresa.proyecto). - Clases e interfaces: Notación PascalCase, comenzando con mayúscula (ej.
MiClase,Calculadora). - Métodos y variables: Notación camelCase, comenzando con minúscula (ej.
calcularTotal,nombreCompleto). - Constantes: Todo en mayúsculas, separando palabras con guion bajo (ej.
MAX_VALOR,PI).
Resumen
La estructura básica de un programa Java incluye paquetes para organizar el código, importaciones para usar clases externas, clases que definen objetos, métodos que implementan comportamientos, y el método main como punto de entrada. Esta organización jerárquica y orientada a objetos es una de las fortalezas de Java, permitiendo crear aplicaciones modulares, mantenibles y escalables. Comprender estos elementos fundamentales te proporcionará una base sólida para avanzar en tu aprendizaje de Java y empezar a desarrollar programas más complejos.