Fundamentos de Programación en Java.

En el ámbito de la programación en Java, las cadenas de texto (strings), las clases (classes), los objetos (objects) y las subrutinas (subroutines) son conceptos fundamentales que forman la base de muchas aplicaciones y sistemas desarrollados en este lenguaje de programación orientado a objetos.

Comencemos con las cadenas de texto, que en Java se conocen como objetos de la clase String. Una cadena de texto es una secuencia de caracteres, como letras, números, símbolos y espacios, que se utilizan para representar información textual. En Java, las cadenas de texto son inmutables, lo que significa que una vez creadas, no se pueden modificar. Esto implica que cualquier operación que parezca modificar una cadena en realidad está creando una nueva cadena con los cambios aplicados. Por ejemplo:

javaCopy code
String saludo = "¡Hola, mundo!";
System.out.println(saludo); // Imprime: ¡Hola, mundo!

En este ejemplo, la cadena «¡Hola, mundo!» se asigna a la variable saludo. Aunque parece que se está modificando la cadena, en realidad se está creando una nueva cadena con el contenido «¡Hola, mundo!» y asignándola a saludo.

Las clases en Java son la base del sistema de tipos y la encapsulación en el lenguaje. Una clase es una plantilla para crear objetos. Define los campos (variables) y los métodos (funciones) que representan el comportamiento y los datos asociados con los objetos que se crearán a partir de ella. Por ejemplo, aquí hay una clase simple en Java:

javaCopy code
public class Persona {
    // Campos
    private String nombre;
    private int edad;
    
    // Constructor
    public Persona(String nombre, int edad) {
        this.nombre = nombre;
        this.edad = edad;
    }
    
    // Método
    public void saludar() {
        System.out.println("¡Hola, soy " + nombre + " y tengo " + edad + " años!");
    }
}

En este ejemplo, la clase Persona tiene dos campos: nombre y edad, un constructor que permite inicializar estos campos al crear un objeto de tipo Persona, y un método saludar() que imprime un saludo utilizando los valores de los campos nombre y edad.

Los objetos en Java son instancias de clases. Son entidades que combinan datos (almacenados en campos) y comportamiento (definido por los métodos de la clase). Cada objeto tiene un estado (los valores de sus campos) y un conjunto de operaciones que se pueden realizar en él (los métodos). Por ejemplo, aquí se crea un objeto Persona utilizando la clase definida anteriormente:

javaCopy code
public class Main {
    public static void main(String[] args) {
        Persona persona1 = new Persona("Juan", 30);
        persona1.saludar(); // Imprime: ¡Hola, soy Juan y tengo 30 años!
    }
}

En este fragmento de código, se crea un objeto Persona llamado persona1 con el nombre «Juan» y la edad 30. Luego se llama al método saludar() en este objeto, que imprime un saludo utilizando los valores proporcionados.

Las subrutinas, también conocidas como métodos o funciones, son bloques de código reutilizables que realizan una tarea específica. En Java, las subrutinas se definen dentro de clases y pueden ser invocadas por otros métodos dentro de la misma clase o desde otras clases. Estas subrutinas pueden o no devolver un valor. Por ejemplo, en la clase Persona anterior, el método saludar() es una subrutina que no devuelve ningún valor.

javaCopy code
// Método que devuelve un valor
public int obtenerEdad() {
    return edad;
}

// Método que no devuelve un valor
public void cumplirAnios() {
    edad++;
}

En el ejemplo anterior, obtenerEdad() es una subrutina que devuelve el valor del campo edad, mientras que cumplirAnios() es una subrutina que incrementa la edad en uno.

En resumen, en Java, las cadenas de texto se representan con objetos de la clase String, las clases son plantillas para crear objetos que combinan datos y comportamiento, los objetos son instancias de clases que tienen un estado y un conjunto de operaciones asociadas, y las subrutinas son bloques de código reutilizables que realizan tareas específicas y pueden o no devolver un valor. Estos conceptos son fundamentales para comprender y desarrollar aplicaciones en Java.

Por supuesto, profundicemos más en cada uno de estos conceptos dentro del contexto de la programación en Java.

Las cadenas de texto, representadas por objetos de la clase String, son utilizadas de manera extensa en prácticamente todos los programas Java. Aparte de simplemente almacenar y manipular texto, las cadenas de texto también ofrecen una variedad de métodos útiles para trabajar con ellas, como la concatenación, la búsqueda de subcadenas, la comparación, la conversión entre mayúsculas y minúsculas, entre otros.

Por ejemplo, considera el siguiente código:

javaCopy code
String frase = "La programación en Java es emocionante.";
System.out.println(frase.length());  // Imprime la longitud de la cadena
System.out.println(frase.charAt(3)); // Imprime el carácter en la posición 3
System.out.println(frase.substring(11, 15)); // Imprime "Java"
System.out.println(frase.contains("emocionante")); // Imprime true si la cadena contiene la palabra "emocionante"

Este pequeño fragmento de código ilustra algunas de las operaciones básicas que se pueden realizar con cadenas de texto en Java. La primera línea crea una cadena de texto, la segunda imprime su longitud, la tercera imprime el carácter en la posición 3 (contando desde 0), la cuarta imprime una subcadena de la posición 11 a la 15 (sin incluir la posición 15), y la quinta verifica si la cadena contiene la palabra «emocionante».

En cuanto a las clases en Java, son la piedra angular de la programación orientada a objetos en este lenguaje. Las clases definen la estructura y el comportamiento de los objetos que se crearán a partir de ellas. Cada clase puede contener campos (variables) y métodos (funciones), y puede heredar características de otras clases mediante la herencia.

Por ejemplo, considera una clase Vehiculo que podría tener los campos marca, modelo y año, así como métodos para establecer estos valores, obtener información sobre el vehículo, etc. Luego, podríamos tener subclases como Automovil o Motocicleta que heredan de la clase Vehiculo y agregan sus propios campos y métodos específicos.

Los objetos en Java son instancias de clases. Cada objeto tiene su propia copia de los campos definidos en su clase, pero comparte los métodos con todos los demás objetos de esa clase. Esto permite crear múltiples instancias de una clase y trabajar con ellas de forma independiente.

Por ejemplo, considera la clase Rectangulo, que podría tener campos para la longitud y el ancho del rectángulo, así como métodos para calcular el área y el perímetro. Podríamos crear varios objetos Rectangulo con diferentes dimensiones y realizar cálculos específicos en cada uno de ellos.

javaCopy code
public class Rectangulo {
    private double longitud;
    private double ancho;

    public Rectangulo(double longitud, double ancho) {
        this.longitud = longitud;
        this.ancho = ancho;
    }

    public double calcularArea() {
        return longitud * ancho;
    }

    public double calcularPerimetro() {
        return 2 * (longitud + ancho);
    }
}

javaCopy code
public class Main {
    public static void main(String[] args) {
        Rectangulo rect1 = new Rectangulo(5, 3);
        Rectangulo rect2 = new Rectangulo(7, 4);

        System.out.println("Área del rectángulo 1: " + rect1.calcularArea());
        System.out.println("Perímetro del rectángulo 1: " + rect1.calcularPerimetro());

        System.out.println("Área del rectángulo 2: " + rect2.calcularArea());
        System.out.println("Perímetro del rectángulo 2: " + rect2.calcularPerimetro());
    }
}

En este ejemplo, creamos dos objetos Rectangulo con diferentes dimensiones y luego calculamos el área y el perímetro de cada uno de ellos.

Finalmente, las subrutinas (también conocidas como métodos o funciones) son bloques de código que realizan una tarea específica. En Java, las subrutinas se definen dentro de clases y pueden ser invocadas por otros métodos dentro de la misma clase o desde otras clases. Estas subrutinas pueden o no devolver un valor.

Por ejemplo, en una clase Calculadora, podríamos tener métodos para sumar, restar, multiplicar y dividir números. Cada uno de estos métodos podría realizar la operación deseada y devolver el resultado, si corresponde.

javaCopy code
public class Calculadora {
    public int sumar(int a, int b) {
        return a + b;
    }

    public int restar(int a, int b) {
        return a - b;
    }

    public int multiplicar(int a, int b) {
        return a * b;
    }

    public double dividir(double a, double b) {
        if (b != 0) {
            return a / b;
        } else {
            throw new IllegalArgumentException("No se puede dividir por cero.");
        }
    }
}

javaCopy code
public class Main {
    public static void main(String[] args) {
        Calculadora calc = new Calculadora();

        System.out.println("Suma: " + calc.sumar(5, 3));
        System.out.println("Resta: " + calc.restar(5, 3));
        System.out.println("Multiplicación: " + calc.multiplicar(5, 3));
        System.out.println("División: " + calc.dividir(5, 3));
    }
}

En este ejemplo, creamos un objeto Calculadora y utilizamos sus métodos para realizar varias operaciones aritméticas con números enteros y de punto flotante.

En resumen, en el contexto de la programación en Java, las cadenas de texto (strings), las clases (classes), los objetos (objects) y las subrutinas (subroutines) son elementos fundamentales que se utilizan para representar datos, definir la estructura y el comportamiento de los programas, crear instancias de esos programas y modularizar el código para hacerlo más fácil de mantener y reutilizar. Estos conceptos forman la base de la programación en Java y son esenciales para cualquier desarrollador que trabaje con este lenguaje.