- Clase
- Objeto
- Encapsulamiento
- Herencia
- Polimorfismo
- Asociación
- Composición
public class Persona {
private String nombre;
private int edad;
public Persona(String nombre, int edad) {//Constructor
this.nombre = nombre;
this.edad = edad;
}
public void saludar() {//método
System.out.println("Hola, soy " + nombre + " y tengo " + edad + " años.");
}
public static void main(String[] args) {//método
Persona persona1 = new Persona("Juan", 25);//Creación instancia de la clase Persona
System.out.println(persona1.nombre); // Imprime "Juan"
System.out.println(persona1.edad); // Imprime 25
persona1.saludar(); // Imprime "Hola, soy Juan y tengo 25 años."
}
}El
método saludar imprime un mensaje de saludo utilizando los valores de nombre y edad.
En
el método main, se crea una instancia de la clase Persona llamada persona1,
pasando los valores "Juan" y 25 para el nombre y la edad,
respectivamente. Luego, se accede a los atributos nombre y edad de la
instancia y se llama al método saludar, que
muestra un mensaje en la consola.
OBJETO
Un objeto es una instancia concreta de una clase. Posee propiedades (atributos) y comportamientos (métodos) definidos por su clase. Los objetos representan entidades del mundo real y se utilizan para interactuar con el sistema.
public class Persona {
private String nombre;
private int edad;
public Persona(String nombre, int
edad) {
this.nombre = nombre;
this.edad = edad;
}
public void saludar() {
System.out.println("Hola, soy " + nombre + " y tengo " + edad + " años.");
}
public static void main(String[] args) {
Persona persona1 = new Persona("Juan", 25);
persona1.saludar(); // Imprime "Hola, soy Juan y tengo 25
años."
}
}
En
el método main, se crea una instancia de Persona llamada persona1
con los valores "Juan" y 25 para el nombre y la edad,
respectivamente. Luego, se llama al método saludar de persona1,
lo cual muestra un mensaje de saludo en la consola.
ENCAPSULAMIENTO
La encapsulación es un principio de la POO que consiste en ocultar los detalles internos de un objeto y exponer solo una interfaz para interactuar con él. Permite proteger los datos y asegurar que solo puedan ser accedidos y modificados a través de métodos definidos en la clase.
public class Persona {
private String nombre;
private int edad;
public String getNombre() {
return nombre;
}
public void setNombre(String nombre) {
this.nombre = nombre;
}
public int getEdad() {
return edad;
}
public void setEdad(int edad) {
if (edad > 0) {
this.edad = edad;
} else {
System.out.println("La edad debe ser mayor que 0.");
}
}
}En
este ejemplo, los atributos nombre y edad están definidos como privados, lo que
significa que solo se pueden acceder a ellos desde dentro de la clase Persona.
Para acceder a estos atributos desde fuera de la clase, se proporcionan métodos
públicos de acceso, conocidos como getters y setters.
Los
métodos getNombre y getEdad son getters, que devuelven el valor de los
atributos nombre y edad, respectivamente.
ABSTRACCIÓN: La
abstracción es el proceso de simplificar un objeto o sistema enfocándose solo
en los aspectos relevantes para un contexto determinado. Permite definir clases
y objetos que representen conceptos del dominio de manera abstracta, sin
considerar todos los detalles de implementación.
HERENCIA
La herencia es un mecanismo que permite crear nuevas clases basadas en clases existentes, heredando sus propiedades y comportamientos. La clase existente se denomina clase base o superclase, mientras que la nueva clase se denomina clase derivada o subclase. La herencia facilita la reutilización de código y la extensibilidad.
Volvemos a utilizar nuestra clase Persona la cuál sería la clase existente, por lo tanto es nuestra clase base(superclase)
class Persona {
private String nombre;
private int edad;
public Persona(String nombre, int edad) {
this.nombre = nombre;
this.edad = edad;
}
public String getNombre() {
return nombre;
}
public void setNombre(String nombre) {
this.nombre = nombre;
}
public int getEdad() {
return edad;
}
public void setEdad(int edad) {
this.edad = edad;
}
public void saludar() {
System.out.println("Hola, soy " + nombre + " y tengo " + edad + " años.");
}
}Aplicaremos la herencia utilizando la clase Estudiante la cual se denomina clase derivada o subclase.
class Estudiante extends Persona {
private String curso;
public Estudiante(String nombre, int edad, String curso) {
super(nombre, edad);
this.curso = curso;
}
public String getCurso() {
return curso;
}
public void setCurso(String curso) {
this.curso = curso;
}
public void estudiar() {
System.out.println("Estoy estudiando " + curso);
}
}public class EjemploHerencia {
public static void main(String[] args) {
Estudiante estudiante = new Estudiante("Juan", 20, "Informática");
estudiante.saludar();
estudiante.estudiar();
}
}Ejercicio: De acuerdo a lo estudiado a este punto, ¿Cuáles son las salidas que nos dará la implementación del código?
POLIMORFISMO
El polimorfismo permite que un objeto pueda tomar diferentes formas y
comportarse de manera distinta en diferentes contextos. Puede manifestarse a
través de la sobrecarga de métodos (mismos nombres, diferentes parámetros) o la
sobrescritura de métodos (implementaciones diferentes en las subclases).
public class Animal {
public void hacerSonido() {
System.out.println("El animal hace un sonido.");
}
}
public class Perro extends Animal {
@Override
public void hacerSonido() {
System.out.println("El perro ladra.");
}
}
public class Gato extends Animal {
@Override
public void hacerSonido() {
System.out.println("El gato maulla.");
}
}
public class EjemploPolimorfismo {
public static void main(String[] args) {
Animal animal1 = new Perro();
Animal animal2 = new Gato();
animal1.hacerSonido();
animal2.hacerSonido();
}
}En este ejemplo, tenemos una clase base Animal con un método hacerSonido(). Las subclases Perro y Gato heredan de la clase Animal y sobrescriben el método hacerSonido() con su propia implementación.
En el método main(), creamos objetos de las subclases Perro y Gato pero los asignamos a variables de tipo Animal. Esto es posible debido al principio de polimorfismo en la programación orientada a objetos.
Al
llamar al método hacerSonido() en los objetos animal1 y animal2, se ejecutará
la implementación específica de cada subclase (Perro y Gato). Esto demuestra
cómo el mismo método puede comportarse de manera diferente dependiendo del tipo
de objeto al que se llama en tiempo de ejecución.
El
@Override es una anotación en Java que se utiliza para indicar que un método de
una subclase está sobrescribiendo un método de la clase base. Esta anotación es
opcional, pero se considera una buena práctica incluirla para mejorar la
legibilidad del código y evitar posibles errores.
ASOCIACIÓN
La asociación es una relación entre dos o más clases, donde cada clase conserva
su independencia. Puede haber asociaciones unidireccionales o bidireccionales,
y pueden ser de tipo uno a uno, uno a muchos o muchos a muchos.
public class Usuario {
private String nombre;
private int edad;
public Usuario(String nombre, int edad) {
this.nombre = nombre;
this.edad = edad;
}
public String getNombre() {
return nombre;
}
public int getEdad() {
return edad;
}
}
public class Biblioteca {
private String nombre;
private Usuario[] usuarios;
public Biblioteca(String nombre) {
this.nombre = nombre;
this.usuarios = new Usuario[100];
}
public void agregarUsuario(Usuario usuario) {
// Lógica para agregar un usuario a la biblioteca
// Aquí se puede implementar la asociación entre Usuario y Biblioteca
}
public void mostrarUsuarios() {
// Lógica para mostrar los usuarios de la biblioteca
// Aquí se puede acceder a los datos de los usuarios asociados
}
}
public class EjemploAsociacion {
public static void main(String[] args) {
Usuario usuario1 = new Usuario("Juan", 25);
Usuario usuario2 = new Usuario("María", 30);
Biblioteca biblioteca = new Biblioteca("Biblioteca Central");
biblioteca.agregarUsuario(usuario1);
biblioteca.agregarUsuario(usuario2);
biblioteca.mostrarUsuarios();
}
}En este ejemplo, las clases Usuario y Biblioteca están asociadas. La clase Usuario representa a un usuario con un nombre y una edad. La clase Biblioteca representa una biblioteca con un nombre y una lista de usuarios.
La asociación se establece a través del método agregarUsuario() en la clase Biblioteca. Este método permite agregar un usuario a la lista de usuarios de la biblioteca.
Mediante esta asociación, la clase Biblioteca puede acceder a los datos de los usuarios asociados y realizar operaciones relacionadas, como mostrar la lista de usuarios en el método mostrarUsuarios().
En
el método main(), creamos instancias de Usuario y una instancia de Biblioteca.
Luego, agregamos los usuarios a la biblioteca utilizando el método
agregarUsuario(). Finalmente, mostramos la lista de usuarios llamando al método
mostrarUsuarios() de la biblioteca.
Este ejemplo ilustra cómo las clases Usuario y Biblioteca están asociadas, permitiendo que la biblioteca gestione y acceda a los usuarios asociados.
COMPOSICIÓN
La composición es un tipo especial de asociación donde una clase contiene a
otras clases como parte de su estructura interna. La relación de composición es
más fuerte que la asociación, ya que las clases contenidas no existen de forma
independiente y su ciclo de vida está estrechamente ligado a la clase
contenedora.
public class Coche {
private String marca;
private Motor motor;
public Coche(String marca, String tipoMotor) {
this.marca = marca;
this.motor = new Motor(tipoMotor);
}
public String getMarca() {
return marca;
}
public String getTipoMotor() {
return motor.getTipo();
}
}
public class EjemploComposicion {
public static void main(String[] args) {
Coche coche = new Coche("Toyota", "Gasolina");
System.out.println("Marca: " + coche.getMarca());
System.out.println("Tipo de motor: " + coche.getTipoMotor());
}
}En este ejemplo, la clase Coche tiene una composición con la clase Motor. Cada instancia de Coche contiene un objeto Motor como parte de su estructura interna.
La clase Motor representa el motor de un coche y tiene un atributo tipo que indica el tipo de motor.
La clase Coche tiene un atributo marca para indicar la marca del coche y un atributo motor que es una instancia de la clase Motor.
En el constructor de Coche, se crea una instancia de Motor pasando el tipo de motor como argumento y se asigna a la variable motor.
En el método main(), creamos un objeto Coche y obtenemos la marca y el tipo de motor llamando a los métodos getMarca() y getTipoMotor() respectivamente.
La
composición se refleja en el hecho de que un coche está compuesto por un motor.
El objeto Motor es creado y gestionado por la clase Coche, y forma parte
integral de la estructura del coche.
La salida del programa será:
Marca: Toyota
Tipo de motor: Gasolina
.png)
.png)
.png)
.png)
.png)
.png)
.png)
.png)
.png)
.png)
