En Java, las clases son plantillas para crear objetos. Los objetos son instancias específicas de una clase que pueden contener datos y métodos relacionados. Aquí hay un ejemplo básico de cómo se definen clases y se crean objetos en Java.
// Definición de la clase Persona
class Persona {
// Atributos
String nombre;
int edad;
// Método 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.");
}
}
public class ClasesYObjetos {
public static void main(String[] args) {
// Creación de objetos
Persona persona1 = new Persona("Juan", 30);
Persona persona2 = new Persona("María", 25);
// Acceso a atributos y métodos de los objetos
System.out.println("Nombre de persona1: " + persona1.nombre);
System.out.println("Edad de persona2: " + persona2.edad);
persona1.saludar();
persona2.saludar();
}
}
Definición de la Clase Persona:
Persona con dos atributos (nombre y edad) y un constructor que inicializa estos atributos.Creación de Objetos:
persona1 y persona2 utilizando el constructor de la clase Persona.Acceso a Atributos y Métodos:
..saludar() para cada objeto.En Java, los métodos son bloques de código que realizan una tarea específica. La sobrecarga de métodos es la capacidad de tener varios métodos con el mismo nombre en una clase, pero con diferentes parámetros.
class Operaciones {
// Método sumar para dos números enteros
public int sumar(int a, int b) {
return a + b;
}
// Método sumar para tres números enteros
public int sumar(int a, int b, int c) {
return a + b + c;
}
// Método sumar para dos números decimales
public double sumar(double a, double b) {
return a + b;
}
// Método sumar para un número entero y un número decimal
public double sumar(int a, double b) {
return a + b;
}
}
public class MetodosYSobrecarga {
public static void main(String[] args) {
Operaciones operaciones = new Operaciones();
// Ejemplos de llamadas a los métodos
System.out.println("Suma de 5 y 3: " + operaciones.sumar(5, 3));
System.out.println("Suma de 5, 3 y 2: " + operaciones.sumar(5, 3, 2));
System.out.println("Suma de 2.5 y 3.5: " + operaciones.sumar(2.5, 3.5));
System.out.println("Suma de 5 y 2.5: " + operaciones.sumar(5, 2.5));
}
}
Definición de la Clase Operaciones:
Operaciones que contiene varios métodos llamados sumar.Sobrecarga de Métodos:
sumar con el mismo nombre pero diferentes tipos o números de parámetros.Llamadas a los Métodos:
sumar con diferentes argumentos.En Java, un constructor es un tipo especial de método que se utiliza para inicializar objetos. Se llama automáticamente cuando se crea un objeto de una clase. Aquí tienes un ejemplo de cómo se utilizan los constructores en Java.
class Persona {
String nombre;
int edad;
// Constructor por defecto
public Persona() {
nombre = "Sin nombre";
edad = 0;
}
// Constructor con parámetros
public Persona(String nombre, int edad) {
this.nombre = nombre;
this.edad = edad;
}
// Método para mostrar información de la persona
public void mostrarInformacion() {
System.out.println("Nombre: " + nombre);
System.out.println("Edad: " + edad);
}
}
public class Constructores {
public static void main(String[] args) {
// Creación de objetos utilizando diferentes constructores
Persona persona1 = new Persona();
Persona persona2 = new Persona("Juan", 30);
// Mostrar información de las personas
System.out.println("Persona 1:");
persona1.mostrarInformacion();
System.out.println("\nPersona 2:");
persona2.mostrarInformacion();
}
}
Definición de la Clase Persona:
Persona con dos atributos (nombre y edad).Constructores:
Uso de Constructores:
persona1 y persona2 utilizando diferentes constructores.La herencia es un concepto fundamental en la programación orientada a objetos que permite a una clase heredar atributos y métodos de otra clase. En Java, se implementa utilizando la palabra clave extends. Veamos un ejemplo:
// Clase base o superclase
class Animal {
String nombre;
public Animal(String nombre) {
this.nombre = nombre;
}
public void comer() {
System.out.println(nombre + " está comiendo.");
}
}
// Clase derivada o subclase
class Perro extends Animal {
public Perro(String nombre) {
super(nombre); // Llama al constructor de la superclase
}
public void ladrar() {
System.out.println(nombre + " está ladrando.");
}
}
public class Herencia {
public static void main(String[] args) {
Perro miPerro = new Perro("Bobby");
miPerro.comer(); // Método heredado de la clase Animal
miPerro.ladrar(); // Método propio de la clase Perro
}
}
Definición de la Clase Animal:
Animal es la superclase que tiene un atributo nombre y un método comer.Definición de la Clase Perro:
Perro es una subclase de Animal que hereda el atributo nombre y el método comer.ladrar.Constructor de la Subclase:
Perro llama al constructor de la superclase Animal usando super(nombre).Creación de Objetos:
miPerro de la clase Perro.El polimorfismo es otro concepto importante en la programación orientada a objetos que permite a los objetos de diferentes clases responder al mismo mensaje de manera diferente. Esto se logra mediante el uso de métodos con el mismo nombre pero con comportamientos diferentes en las clases hijas.
// Clase base o superclase
class Animal {
public void hacerSonido() {
System.out.println("El animal hace un sonido.");
}
}
// Clase derivada o subclase
class Perro extends Animal {
@Override
public void hacerSonido() {
System.out.println("El perro ladra.");
}
}
// Otra subclase
class Gato extends Animal {
@Override
public void hacerSonido() {
System.out.println("El gato maulla.");
}
}
public class Polimorfismo {
public static void main(String[] args) {
Animal miAnimal;
miAnimal = new Perro();
miAnimal.hacerSonido(); // Salida: El perro ladra
miAnimal = new Gato();
miAnimal.hacerSonido(); // Salida: El gato maulla
}
}
Definición de Clases:
Animal con un método hacerSonido().Perro y Gato que sobrescriben el método hacerSonido() con comportamientos específicos.Polimorfismo:
Animal que puede apuntar a objetos de cualquier subclase.hacerSonido() a través de la referencia miAnimal, y el comportamiento específico de cada subclase es ejecutado.Anulación de Métodos (Override):
hacerSonido() de la superclase para proporcionar su propia implementación.La abstracción es el proceso de ocultar los detalles de implementación y mostrar solo la funcionalidad relevante de un objeto. En Java, se puede lograr la abstracción utilizando clases abstractas e interfaces. Una clase abstracta es una clase que no se puede instanciar y que puede contener métodos abstractos y concretos.
// Clase abstracta
abstract class Animal {
String nombre;
public Animal(String nombre) {
this.nombre = nombre;
}
// Método abstracto (sin implementación)
public abstract void hacerSonido();
// Método concreto
public void dormir() {
System.out.println(nombre + " está durmiendo.");
}
}
// Subclase que extiende la clase abstracta
class Perro extends Animal {
public Perro(String nombre) {
super(nombre);
}
// Implementación del método abstracto
@Override
public void hacerSonido() {
System.out.println("El perro ladra.");
}
}
public class AbstraccionYClasesAbstractas {
public static void main(String[] args) {
// No se puede crear una instancia de Animal (clase abstracta)
// Animal miAnimal = new Animal("Animal");
// Se puede crear una instancia de Perro (subclase de Animal)
Perro miPerro = new Perro("Bobby");
miPerro.hacerSonido(); // Salida: El perro ladra
miPerro.dormir(); // Salida: Bobby está durmiendo
}
}
Clase Abstracta:
Animal que contiene un atributo nombre, un constructor y un método abstracto hacerSonido().dormir() con implementación.Método Abstracto:
hacerSonido() en la clase Animal es un método abstracto, que significa que no tiene implementación en la clase abstracta.Clase Derivada:
Perro que extiende la clase abstracta Animal.hacerSonido() en la subclase.Uso de la Clase Abstracta:
