INICIO
tecnologia · programación
como hacer un nuevo proyecto en java, Espacio de trabajo con IntelliJ IDEA mostrando la estructura de un proyecto Java en el panel Project
tecnologia ·#3967 ·Lectura 7 min. · Redactor: Gonzalo E.Garcia

💻 Cómo crear tu primer proyecto en Java paso a paso

Respuesta corta
Verificado
Redactado por Humanos!

Un proyecto Java no es un fichero suelto: es el contenedor que agrupa fuentes, librerías, configuración y recursos para construir, ejecutar y mantener la aplicación.

01

Cómo monté mi primer proyecto en Java y lo que me hubiera gustado saber antes

Java lleva décadas siendo el pilar de medio mundo: apps móviles, servidores bancarios, sistemas de comercio electrónico, videojuegos... Da igual lo que quieras construir, si eliges Java, alguien ya resolvió la mayoría de problemas antes que tú. Y el primer obstáculo, siempre, es el mismo: ¿cómo demonios creo un proyecto nuevo que no se caiga a los diez minutos?


Yo recuerdo la primera vez que tuve que montar una arquitectura de software completa para una plataforma de ventas online. No era un HelloWorld en un fichero suelto, era decenas de módulos, librerías de terceros, ficheros de configuración y equipos trabajando sobre el mismo repo. En aquel momento entendí que un proyecto Java no es una carpeta con código, es un contenedor vivo que agrupa fuentes, paquetes, librerías, recursos y configuración todo junto. Sin esa estructura, todo se desmorona.


Así que antes de tocar el teclado, conviene tener claro qué lleva dentro un proyecto Java bien plantado:


  • Ficheros fuente (.java): el código en sí, organizado en paquetes.
  • Librerías y dependencias: todo lo externo que la app necesita para funcionar (log4j, drivers JDBC, frameworks web...).
  • Ficheros de configuración: pom.xml, build.gradle, application.properties... definen cómo se compila, se empaqueta y se despliega.
  • Recursos: imágenes, XML, ficheros de propiedades, templates. Cosas que no son código pero la app consume.

La estructura de carpetas que vas a ver en el 95 % de los proyectos profesionales es bastante estándar: src/main/java para las fuentes, lib para dependencias externas (aunque hoy casi todo se gestiona vía Maven o Gradle), target o bin como directorio de salida con las clases compiladas, y el fichero de configuración raíz. No te inventes una estructura propia el primer día, sigue la convención y luego ya personalizarás.


¿Y por qué no compilar un .java suelto con javac y tirar pa'lante? Porque en cuanto crezcas un mínimo, esa comodidad se convierte en pesadilla. Los proyectos te dan modularidad para separar responsabilidades, reutilización porque añades una librería y listo, colaboración porque varios devs tocan el mismo repo sin pisarse, y compilación y despliegue automatizados con Maven o Gradle. Para una demo de cinco líneas, vale un javac. Para cualquier cosa que tengas que mantener más de una semana, necesitas un proyecto.


Dicho esto, hay dos caminos principales: usar un IDE con interfaz gráfica (IntelliJ IDEA, Eclipse, NetBeans) o lanzarte por línea de comandos con Maven o Gradle. Yo, que llevo más de treinta años tocando sistemas, siempre prefiero el IDE para arrancar porque me ahorra una barbaridad de errores de configuración. Luego, cuando ya domino la estructura, puedo generar un esqueleto en dos segundos desde terminal.


Vayamos con IntelliJ IDEA, que es donde más cómodamente trabajo. Abres el IDE y desde la pantalla de inicio pulsas New | Project. Si ya tienes algo abierto, es File | New Project. En el asistente seleccionas Java como tipo de proyecto, le pones nombre (por ejemplo HelloWorld), cambias la ruta si te apetece y desactivas Create Git repository si no vas a usar control de versiones aún. En Build system, deja IntelliJ seleccionado.


Aquí viene el punto que me ha traído de cabeza más veces: el Java SDK. IntelliJ te pide un JDK para compilar y ejecutar. Si ya tienes uno registrado, lo eliges de la lista. Si lo tienes instalado en disco pero el IDE no lo conoce, usas Add JDK from Disk y le señalas la carpeta home del JDK. Y si no tienes ninguno, el propio IntelliJ ofrece Download JDK eligiendo versión y ruta de instalación, que es comodísimo. Deja desactivada la casilla Add sample code si quieres construir todo desde cero.


Con el proyecto cargado, abre la ventana Project con Alt+1 o desde View | Tool Windows | Project. Ahí ves toda la estructura en un árbol. Seleccionas la carpeta src, pulsas Alt+Insert, eliges el tipo de fichero y le das nombre. Listo, ya tienes tu primer archivo .java dentro del proyecto.


Un detalle moderno que me encanta: las versiones recientes de Java traen los compact source files. Son ficheros fuente que no necesitan la declaración public class ni el boilerplate de siempre. Perfectos para demos rápidas o tutoriales, el IDE genera la plantilla con el método main automáticamente.


Para escribir la lógica, apóyate en el autocompletado sin vergüenza. Tecleas IO y pulsas Ctrl+. para insertar la selección con punto final; de la lista eliges println. Al escribir la primera comilla, IntelliJ pone la segunda y te deja el cursor entre ambas. Y si quieres ir aún más rápido, escribe iop, Enter, y ya tienes la línea de impresión lista.


Compilar y ejecutar es un clic: la flecha verde del gutter, Run 'HelloWorld.main()'. El IDE compila con javac, coloca el bytecode en out y la JVM lo ejecuta. En la herramienta Run de abajo ves el comando, la salida y el código de salida 0 (todo bien). Si hay error de sintaxis, aparece ahí mismo.

“El error más silencioso al crear un proyecto nuevo está en la incoherencia entre el JDK del IDE, la versión de source/target del pom.xml y el runtime de destino.”

Dato clave
como hacer un nuevo proyecto en java, Terminal mostrando la generación de un proyecto Java con Maven y notas sobre pom.xml
Imagen

Terminal mostrando la generación de un proyecto Java con Maven y notas sobre pom.xml

02

Del archivo suelto al artefacto: la ruta real que sigo cada vez que arranco una app nueva

Tras tantas horas delante de una pantalla, te digo una cosa: la segunda vez que creas un proyecto Java es infinitamente más fácil que la primera, y eso es cierto tanto en IntelliJ como en Eclipse. Lo difícil no es el clic, es entender qué está pasando debajo. Y una vez lo ves, no hay marcha atrás.


Hablemos de Eclipse. Es un IDE veterano, potente, y sigue siendo la opción por defecto en muchas empresas grandes de telecomunicaciones y banca donde he trabajado. Al iniciarlo por primera vez te pide un Workspace, que es la carpeta raíz donde vivirán todos tus proyectos. Eliges directorio, Launch, y ya estás dentro.


Creas el proyecto con File | New | Java Project (o File | New | Project | Java | Java Project si no aparece directo). En el asistente rellenas nombre, seleccionas el JRE o JDK instalado y dejas el resto por defecto. Un truco que aprendí a golpes: desmarca la casilla create module-info.java mientras no trabajes con módulos Java 9+. Ese fichero genera más problemas que soluciones en los primeros proyectos.


La estructura en Package Explorer muestra src para fuentes, JRE System Library con las librerías de ejecución, y bin (automática) con los .class compilados. Sobre src, clic derecho y New | Package para crear el paquete; dentro, New | Class para la clase principal.


Todo programa Java necesita mínimo una clase con un método public static void main(String[] args). El clásico System.out.println("Hello, World!") sigue siendo válido. Guarda con Ctrl+S y ejecuta con clic derecho sobre el fichero y Run As | Java Application, o el botón Run de la toolbar. El resultado aparece en la ventana Console abajo; los errores del compilador también.


Ahora, la vía sin IDE, que es donde realmente entiendes qué hace cada herramienta. Abres terminal, navegas al destino y tiras un comando Maven:


mvn archetype:generate -DgroupId=com.labex.myapp -DartifactId=my-java-project -DarchetypeArtifactId=maven-archetype-quickstart -DarchetypeVersion=1.4 -DinteractiveMode=false


Eso te genera la estructura completa: src/main/java con la clase de ejemplo, target y pom.xml. Y ahí, en el pom.xml, está el corazón del proyecto. En <dependencies> añades librerías externas (log4j-core para logging, por ejemplo). En <properties> fijas source y target del compilador (por ejemplo 11) para que el bytecode se genere para esa versión. Y con el maven-jar-plugin declaras la clase principal como punto de entrada.


Cuando el código está listo, quieres empaquetar en un JAR. En IntelliJ: File | Project Structure (Ctrl+Alt+Shift+S), sección Artifacts, Add, JAR From modules with dependencies, seleccionas la clase main. El IDE genera el MANIFEST.MF con los metadatos. Construyes con Build | Build Artifacts y el JAR queda en out/artifacts. Para verificarlo, creas una configuración de ejecución JAR Application, pones la ruta al JAR y añades Build Artifacts en Before launch para que se reconstruya solo.


Un apunte sobre los compact source files en producción: son geniales para demos, pero fuera de paquetes. En un proyecto real, conviértelos a clase normal (cursor en void main, Alt+Enter, Convert into a regular class), crea el paquete con New | Package (tipo com.example.helloworld) y arrastra la clase dentro. IntelliJ dispara el refactoring Move, añade la declaración de package y actualiza referencias.


Y ojo con el ciclo completo de ejecución: cuando pulsas Run, IntelliJ encadena construir (javac compila a bytecode), colocar ese bytecode en out, y ejecutar con la JVM. En paralelo, el IDE analiza el fichero abierto con el widget Inspections, detectando desde errores de sintaxis hasta erratas. Es como tener un revisor de código permanentemente al lado.

Conclusión:

¿como hacer un nuevo proyecto en java?

Mira, llevamos tanto tiempo escuchando que Java es complejo, que a veces olvidamos que el reto no está en escribir un for o una lambda, sino en montar bien la casa antes de meter los muebles. Yo, después de tantos años levantando arquitecturas IT y viendo proyectos nacer y morir por una configuración mal alineada, estoy convencido de que ese primer momento, cuando decides qué JDK usar, si metes module-info o no, y qué versión de source/target fijas en el pom.xml, es lo que marca que tu app funcione en tu máquina y se caiga en la del compañero. No es un problema de código, es un problema de coherencia entre tres capas que deben mirar en la misma dirección. Así que antes de escribir una sola línea, verifica ese triángulo. El código de salida 0 te dice que compiló, no que va a arrancar en producción con otro runtime.

Fuentes: 1º JetBrains.com, 2º Geeksforgeeks.org, 3º Labex.io, 4º Tutorialesprogramacionya.com
IMAGEN1-AUTOR:Nexuscurioso|Licencia:Todos los derechos reservados|Url:---
IMAGEN2-AUTOR:Nexuscurioso|Licencia:Todos los derechos reservados|Url:---
Redacción: Gonzalo E.Garcia · Actualizado en: 11/11/2026
Valoración para Respuesta Valoración para Respuesta Valoración para Respuesta Valoración para Respuesta Valoración para Respuesta Valoración para Respuesta Valoración para Respuesta Valoración para Respuesta Valoración para Respuesta Valoración para Respuesta
4.0 / 5 · 55 valoraciones Valorar

¿Tienes algo que aportar? Envíanos tu respuesta