Java (actualmente liberado por Oracle) es un lenguaje de programación que opera bajo su máquina virtual igualmente de nombre java (JVM - Java Virtual Machine), se podría ver también como un entorno o plataforma de programación. Ha tenido gran acogida empresarial y debido a eso es rico en conectores de bases de datos entre otros casos, incluso para criptomonedas y aplicaciones móviles para Android. La versión original del popular juego Minecraft fue desarrollada usando este lenguaje.
Java es un lenguaje clásico que es bueno tener como referencia. Plantea una modalidad de programación estándar (Java SE) y otra empresarial (Java EE). Mientras en el modo estándar se generan archivos en bytecodes con extensión .jar, en la modalidad empresarial se usan archivos con extensión .ear y .war orientados estrictamente a una arquitectura Web (que se despliegan en contenedores web o servidores de aplicaciones lógicos). Además, presenta una versión que sólo tiene el entorno de ejecución (JRE) y otra para desarrolladores (JDK) que agrega por ejemplo el compilador. Tanto JRE como JDK incorporan la JVM (Java Virtual Machine). Actuamente, existe un JDK más eficiente y versátil llamado GraalVM (liberado también por Oracle), el cual es mas bien un ecosistema que posibilita programar en variedad de lenguajes.
Esta es una referencia ágil para quién tenga nociones de programación o codifique con algún otro lenguaje, también a modo de repaso y uso frecuente. Siendo así, tener esta información como memoria te resultará simple de acceder a los fundamentos, incluso como prueba de concepto sobre el lenguaje.
Para quien tenga habilidades, experticia en programación y/o requiera agilidad en conceptos técnicos, pueden resumirse los siguientes tips esenciales del lenguaje:
int, double, float, boolean, Char, String, ArrayList. Las variables se definen iniciando con el tipo de datos y luego el nombre.void si no retorna valor) pero anteponiendo palabras como public o private (para indicar si es pública o privada), luego los parámetros van entre paréntesis (...) iniciando también con el tipo de datos (y separando los parámetros con coma ,). Además, se usa return para retornar un valor. La función principal de un programa se denomina main.{}. Las sentencias deben terminar siempre con punto y coma ;.C, Javascript, Kotlin, es decir que se cuenta con una anatomía cercana para el uso de if, for, while, incluso para el manejo de excepciones (try).class pero anteponiendo palabras como public o private (para indicar si es pública o privada).Java, siendo un lenguaje de acogida empresarial para aplicaciones del lado del servidor que puede incorporar trozos de SQL.package hello;
public class App {
public static void main (String args[]) {
System.out.println("Hi there!");
}
}
Se pueden declarar variables enunciando el tipo de datos como en el siguiente ejemplo:
String variable = new String("Ana");
int a = 1;
double b = 1.5;
Si estás iniciando en la programación bajo la JVM, una manera sencilla de comprender qué son los paquetes es verlos como las carpetas agrupadoras para organizar tu aplicación, y en muchas ocasiones pueden establecerse con un estilo semejante a un subdominio en internet de modo inverso, por ejemplo, si se piensa en un subdominio app.mycompany.com el paquete podría ser com.mycompany.app, de otro modo, se puede usar una carpeta de estructura simple que se refiera al nombre o alias del proyecto.
package project;
import java.util.*;
...
static int plus(int a, int b) {
return a + b;
}
// Esto es un comentario de fin de línea
/*
Este es un comentario de bloque
*/
if (i == 1) {
System.out.println("one");
}
else if (i == 2) {
System.out.println("two");
}
else {
System.out.println("aha");
}
for (int index = 0; index < a.length; index++) {
System.out.println(index);
}
int i = 0;
while (i < 10) {
i++;
}
try {
...
}
catch (Exception e) {
...
}
finally {
...
}
Puedes usar
throw(por ejemplo:throw Exception()) para forzar el lanzamiento de un error.
La programación orientada a objetos (OOP) tiene su propia base de conceptos que abre un capítulo aparte para su comprensión, se puede decir que se pasa de pensar en funciones a clases que agrupan métodos (funciones) y propiedades (variables), siendo de gran útilidad para la reutilización de código. Como referencia simplemente se presenta la anatomía de una clase.
public class Shape {
public static void main (String args[]) {
Shape shape = new Shape("square", 4);
}
public Shape (String name, int sides) {
System.out.println("This is a constructor!");
}
}
Para lograr json en Java se usan librerías, como Jackson, que permiten mapear un objeto a una cadena que representa el json o viceversa. Veremos algun ejemplo basado en la siguiente clase:
package com.example;
public class MyModel {
String firstName;
String lastName;
}
import com.example.MyModel;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
public class Example {
public String toJSON() throws JsonProcessingException {
ObjectMapper mapper = new ObjectMapper();
MyModel dto = new MyModel("Andrey", "C.");
String result = mapper.writeValueAsString(dto);
System.out.println(result);
}
}
import com.example.MyModel;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
public class Example {
public String fromJSON(String json) throws JsonProcessingException {
ObjectMapper mapper = new ObjectMapper();
MyModel dto = mapper.readValue(json, MyModel.class);
System.out.println(dto);
}
}
ActiveJ posibilita trabajar con un Servidor Web en Java. Plantearemos una estructura general de archivos y carpetas para el proyecto de ejemplo como la siguiente:
Veamos un ejemplo de código esencial para iniciar con un servidor o aplicación web.
package org.example;
import io.activej.http.AsyncServlet;
import io.activej.http.HttpResponse;
import io.activej.inject.annotation.Provides;
import io.activej.launcher.Launcher;
import io.activej.launchers.http.HttpServerLauncher;
import io.activej.promise.Promise;
public class MyWebApp extends HttpServerLauncher {
@Provides
AsyncServlet servlet() {
return request -> Promise.of(
HttpResponse.ok200()
.withPlainText("Hi there!"));
}
public static void main(String[] args) throws Exception {
Launcher launcher = new MyWebApp();
launcher.launch(args);
}
}
Uno de los gestores de paquetes de Java se llama Maven. Este gestor requiere un archivo pom.xml con ciertas propiedades en formato xml. Crearemos este archivo con el siguiente contenido:
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>org.example</groupId>
<artifactId>my-web-app</artifactId>
<version>5.0</version>
<name>my-web-app</name>
<properties>
<maven.compiler.source>11</maven.compiler.source>
<maven.compiler.target>11</maven.compiler.target>
</properties>
<build>
<plugins>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-compiler-plugin</artifactId>
<version>3.8.1</version>
</plugin>
</plugins>
</build>
<dependencies>
<dependency>
<groupId>io.activej</groupId>
<artifactId>activej-launchers-http</artifactId>
<version>5.0</version>
</dependency>
<dependency>
<groupId>ch.qos.logback</groupId>
<artifactId>logback-classic</artifactId>
<version>1.2.6</version>
</dependency>
</dependencies>
</project>
También es posible generar el proyecto co los archivos anteriores ejecutando desde la línea de comandos:
mvn archetype:generate -DarchetypeGroupId=io.activej -DarchetypeArtifactId=archetype-http -DarchetypeVersion=5.0
Podemos compilar y verificar consultando en el navegador la dirección: localhost:8080
Para continuar introdiciéndonos en Java, invito a ver la siguiente lista de videos que he seleccionado con una orientación en Spring Boot llegando finalmente a la programación reactiva con Spring Webflux…
© 2019 by César Arcila