public class MiClase {
private String mensaje;
public MiClase(String mensaje) {
this.mensaje = mensaje;
}
public void saludar() {
System.out.println("¡Hola desde MiClase! Mensaje: " + mensaje);
}
}
import java.lang.reflect.Constructor;
import java.lang.reflect.Method;
public class Main {
public static void main(String[] args) throws Exception {
// Obtener la clase
Class<?> clase = Class.forName("MiClase");
// Obtener constructor
Constructor<?> constructor = clase.getConstructor(String.class);
// Crear una instancia
Object instancia = constructor.newInstance("Hola desde la reflexión");
// Obtener el método
Method metodo = clase.getMethod("saludar");
// Invocar el método en la instancia
metodo.invoke(instancia);
}
}
Class.forName("MiClase") para obtener el objeto Class de la clase MiClase.clase.getConstructor(String.class) y lo usamos para crear una nueva instancia con constructor.newInstance("Hola desde la reflexión").saludar utilizando clase.getMethod("saludar").metodo.invoke(instancia).Las anotaciones, o annotations en inglés, son metadatos que se pueden agregar a clases, métodos, variables u otros elementos del código en Java. Proporcionan información adicional sobre el código y se pueden usar para configurar o modificar el comportamiento del programa en tiempo de compilación, ejecución o incluso durante el proceso de desarrollo. Aquí tienes un ejemplo básico de cómo usar anotaciones en Java:
Supongamos que queremos crear una anotación DeprecatedAnnotation para marcar métodos obsoletos:
import java.lang.annotation.*;
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface DeprecatedAnnotation {
String reason() default "Este método está obsoleto";
}
Luego, podemos aplicar esta anotación a un método:
public class MyClass {
@DeprecatedAnnotation(reason = "Usa otro método en su lugar")
public void metodoObsoleto() {
System.out.println("Este es un método obsoleto");
}
public void metodoNuevo() {
System.out.println("Este es un método nuevo y mejorado");
}
}
Y finalmente, podemos leer esta anotación en tiempo de ejecución:
import java.lang.reflect.*;
public class Main {
public static void main(String[] args) throws Exception {
MyClass obj = new MyClass();
// Obtener la clase
Class<?> clase = obj.getClass();
// Obtener los métodos
Method[] metodos = clase.getDeclaredMethods();
// Iterar sobre los métodos y verificar si tienen la anotación
for (Method metodo : metodos) {
if (metodo.isAnnotationPresent(DeprecatedAnnotation.class)) {
DeprecatedAnnotation anotacion = metodo.getAnnotation(DeprecatedAnnotation.class);
System.out.println("El método " + metodo.getName() + " está marcado como obsoleto. Razón: " + anotacion.reason());
}
}
}
}
@DeprecatedAnnotation con un atributo reason que proporciona una razón para la obsolescencia del método.metodoObsoleto() en la clase MyClass.Main, usamos reflexión para obtener los métodos de MyClass, y luego verificamos si tienen la anotación @DeprecatedAnnotation aplicada.Las anotaciones son útiles para proporcionar información adicional sobre el código y pueden ser procesadas por herramientas de compilación, frameworks o incluso por el propio código en tiempo de ejecución.
La serialización y deserialización en Java son procesos que permiten convertir objetos en una secuencia de bytes (serialización) y viceversa (deserialización). Esto es útil para almacenar objetos en archivos, enviar objetos a través de la red o guardar objetos en bases de datos. En Java, puedes lograr esto fácilmente utilizando las clases ObjectOutputStream y ObjectInputStream. Aquí tienes un ejemplo básico:
Supongamos que tenemos una clase Persona que queremos serializar y deserializar:
import java.io.Serializable;
public class Persona implements Serializable {
private String nombre;
private int edad;
public Persona(String nombre, int edad) {
this.nombre = nombre;
this.edad = edad;
}
public String getNombre() {
return nombre;
}
public int getEdad() {
return edad;
}
}
import java.io.*;
public class Serializacion {
public static void main(String[] args) {
Persona persona = new Persona("Juan", 30);
try (FileOutputStream fileOut = new FileOutputStream("persona.ser");
ObjectOutputStream out = new ObjectOutputStream(fileOut)) {
out.writeObject(persona);
System.out.println("Objeto serializado correctamente.");
} catch (IOException e) {
e.printStackTrace();
}
}
}
import java.io.*;
public class Deserializacion {
public static void main(String[] args) {
try (FileInputStream fileIn = new FileInputStream("persona.ser");
ObjectInputStream in = new ObjectInputStream(fileIn)) {
Persona persona = (Persona) in.readObject();
System.out.println("Objeto deserializado correctamente.");
System.out.println("Nombre: " + persona.getNombre());
System.out.println("Edad: " + persona.getEdad());
} catch (IOException | ClassNotFoundException e) {
e.printStackTrace();
}
}
}
Persona implementa la interfaz Serializable, lo que indica que los objetos de esta clase pueden ser serializados.Persona y lo escribimos en un archivo llamado persona.ser.persona.ser y convertimos los bytes nuevamente en un objeto Persona.ObjectOutputStream y ObjectInputStream.Servlets y JSP (JavaServer Pages) son tecnologías utilizadas en el desarrollo web con Java. Los Servlets son programas Java que se ejecutan en el servidor web para procesar las solicitudes de los clientes y generar respuestas dinámicas, mientras que JSP es una tecnología que permite escribir páginas web dinámicas utilizando código Java embebido en HTML. Aquí tienes una introducción básica a Servlets y JSP:
Los Servlets son clases Java que extienden la clase javax.servlet.http.HttpServlet y son utilizados para manejar las solicitudes HTTP y generar respuestas dinámicas. Aquí hay un ejemplo básico de un Servlet:
import javax.servlet.*;
import javax.servlet.http.*;
import java.io.*;
public class MiServlet extends HttpServlet {
protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
response.setContentType("text/html");
PrintWriter out = response.getWriter();
out.println("<html><head><title>MiServlet</title></head>");
out.println("<body><h1>Hola desde MiServlet</h1></body></html>");
}
}
JSP permite escribir páginas web dinámicas utilizando HTML y código Java embebido. Aquí tienes un ejemplo básico de un archivo JSP:
<%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8"%>
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>Mi JSP</title>
</head>
<body>
<h1>Hola desde mi página JSP</h1>
<p>La fecha y hora actual es: <%= new java.util.Date() %></p>
</body>
</html>
Para que el contenedor de servlets pueda reconocer nuestros Servlets, es necesario configurarlos en el archivo web.xml:
<web-app>
<servlet>
<servlet-name>MiServlet</servlet-name>
<servlet-class>MiServlet</servlet-class>
</servlet>
<servlet-mapping>
<servlet-name>MiServlet</servlet-name>
<url-pattern>/miservlet</url-pattern>
</servlet-mapping>
</web-app>
HttpServlet y sobrescribimos el método doGet() para manejar las solicitudes GET. En este caso, simplemente escribimos una respuesta HTML básica.<% %> para generar contenido dinámico.web.xml, configuramos el Servlet para que sea accesible a través de la URL /miservlet.