01-Conceptos Fundamentales de POO
La programación orientada a objetos se basa en la interacción entre objetos: refrigerador.abrir(); refrigerador.guardar(); refrigerador.cerrar();
02-Aproximación Orientada a Objetos
Utilizar y dirigir objetos sin necesidad de comprender el proceso interno, solo interesa el resultado final. Según el libro "Thinking in Java", todo puede tratarse como un objeto.
03-Relación entre Clases y Objetos
En la vida real tenemos objetos concretos como Juan o María. Para representarlos, extraemos las características comunes y creamos una abstracción. Una clase es la descripción de un objeto del mundo real, mientras que el objeto es la instancia real de esa clase.
// Programación orientada a objetos: tres pilares - encapsulamiento, herencia, polimorfismo // El desarrollo consiste en encontrar objetos para utilizar. Si no existen, se crean. // Uso de objetos, creación de objetos y mantenimiento de relaciones.
/*
- Relación entre clases y objetos.
- Objetos de la vida real: vehículo A, vehículo B.
- Para describir: extraer características comunes. Abstracción de lo concreto.
- Clase: descripción de una entidad del mundo real.
- Objeto: instancia concreta de esa clase, una entidad real. */
// Ejemplo: describir un automóvil (color, número de ruedas). // Los atributos corresponden a variables en la clase, el comportamiento a métodos. // Definir una clase significa describir el objeto, definir atributos y comportamiento. // Ambos forman los miembros de la clase (variables de instancia y métodos).
class Automovil { // Atributo: color String color = "verde"; // Atributo: número de ruedas int ruedas = 4;
// Comportamiento: movimiento
void mover()
{
System.out.println(color + ".." + ruedas);
}
}
public class AutomovilDemo { public static void main(String[] args) { // Fabricar un automóvil. En Java se utiliza el operador new. // Se crea una instancia en la memoria heap. Automovil auto = new Automovil();
// Cambiar el color del automóvil a azul. Dirigir el objeto.
// En Java se utiliza: objeto.miembro
auto.color = "azul";
auto.mover();
Automovil auto1 = new Automovil();
auto1.mover();
}
}
</div>04-Variables de Instancia y Variables Locales
=============================================
<div>```
/*
* Diferencias entre variables de instancia y variables locales.
* Ámbito de acción:
* - Variables de instancia: disponibles en toda la clase.
* - Variables locales: vigentes solo en el método o bloque donde se declaran.
* Ubicación en memoria:
* - Variables de instancia: almacenadas en heap (existen mientras el objeto exista).
* - Variables locales: almacenadas en stack.
*/
// Uso de objeto anónimo caso 1: cuando solo se llama un método una vez.
// Simplifica el código.
// Si se necesitan múltiples llamadas a miembros, debe asignarse a una variable.
// Uso de objeto anónimo caso 2: pasar como argumento a un método.
</div>Referencia fuerte, referencia débil, referencia suave, referencia fantasma.
06-Concepto de Encapsulamiento
==============================
El encapsulamiento consiste en ocultar los detalles internos del objeto y sus atributos, proporcionando únicamente métodos públicos para el acceso. Esto protege los datos y permite controlar cómo se modifican.
07-Encapsulamiento con Modificador Private
==========================================
Todos los atributos deeben ser privados y se accede a ellos mediante métodos getter y seter.
<div>```
package ejemploPersona;
/*
* private: modificador de acceso que oculta miembros (variables o métodos).
* Solo es accesible dentro de la propia clase.
*
* Al privatizar la edad, desde fuera no se puede acceder directamente.
* Sin embargo, las personas deben tener edad, entonces se proporcionan métodos de acceso.
*
* El encapsulamiento se manifiesta de muchas formas, private es una de ellas.
*
* Proporcionar métodos de acceso permite agregar validaciones y lógica de negocio.
* Esto aumenta la robustez del código.
*/
class Persona
{
private int edad;
public void establecerEdad(int valor)
{
if(valor > 0 && valor < 130)
{
edad = valor;
mostrar();
}
else
System.out.println("Edad inválida");
}
public int obtenerEdad()
{
return edad;
}
void mostrar()
{
System.out.println("edad = " + edad);
}
}
public class PersonaDemo {
public static void main(String[] args) {
Persona persona = new Persona();
persona.establecerEdad(25);
}
}
Características:
- El nombre del constructor debe ser idéntico al nombre de la clase.
- No se especifica tipo de retorno.
- No se utiliza return.
Función: inicializar el objeto.
Notas:
- El constructor por defecto tiene características especiales.
- Múltiples constructores coexisten mediante sobrecarga.
/*
- Al crear un objeto se invoca su constructor automáticamente.
- El constructor inicializa el objeto.
- Detalles importantes:
- Si no se define ningún constructor, Java añade uno vacío por defecto.
- Al definir un constructor personalizado, el por defecto desaparece.
- Diferencias entre constructores y métodos:
- El constructor se ejecuta al crear el objeto (inicialización).
- Los métodos se ejecutan cuando se llaman (añadir funcionalidad).
- El constructor se ejecuta una sola vez por objeto.
- Los métodos pueden llamarse múltiples veces.
- ¿Cuándo definir un constructor?
- Cuando el objeto tiene características o comportamientos que deben iniciarse. */
class Empleado { private String nombre; private int edad;
Empleado()
{
System.out.println("A: nombre=" + nombre + ", edad=" + edad);
llorar();
}
Empleado(String n)
{
nombre = n;
System.out.println("B: nombre=" + nombre + ", edad=" + edad);
llorar();
}
Empleado(String n, int e)
{
nombre = n;
edad = e;
System.out.println("C: nombre=" + nombre + ", edad=" + edad);
llorar();
}
public void establecerNombre(String n)
{
nombre = n;
}
public String obtenerNombre()
{
return nombre;
}
public void llorar()
{
System.out.println("llorando...");
}
}
public class ConstructorDemo {
public static void main(String[] args) {
Empleado emp1 = new Empleado();
emp1.obtenerNombre();
Empleado emp2 = new Empleado("carlos");
emp2.establecerNombre("miguel");
System.out.println(emp2.obtenerNombre());
Empleado emp3 = new Empleado("ana", 28);
emp3.establecerNombre("laura");
}
}
</div>09-Bloques de Inicialización
============================
<div>```
package ejemploBloqueInicializacion;
/*
* Al crear un objeto se invoca el constructor.
* El bloque de inicialización inicializa el objeto.
*
* Detalles del bloque de inicialización:
* Si no se define constructor, Java añade uno vacío por defecto.
* Al definir constructor personalizado, el por defecto desaparece.
*
* Diferencias entre constructores y métodos en sintaxis y ejecución.
* El constructor ejecuta al crear objeto (inicialización).
* Los métodos ejecutan al ser llamados (agrega funcionalidad).
*
* El constructor se ejecuta una vez por objeto.
* Los métodos pueden llamarse muchas veces.
*
* ¿Cuándo usar constructores?
* Cuando el objeto tiene características que necesitan inicialización.
*/
class Empleado
{
private String nombre;
private int edad;
/*
* Bloque de inicialización
* Función: inicializar el objeto.
* Se ejecuta al crear el objeto, antes que el constructor.
* Diferencia con constructor:
* El bloque inicializa todos los objetos, el constructor inicializa objetos específicos.
*
* En el bloque se define código común a todos los objetos.
*/
{
System.out.println("Bloque de inicialización ejecutado");
llorar();
}
Empleado()
{
System.out.println("A: nombre=" + nombre + ", edad=" + edad);
llorar();
}
Empleado(String n)
{
nombre = n;
System.out.println("B: nombre=" + nombre + ", edad=" + edad);
llorar();
}
Empleado(String n, int e)
{
nombre = n;
edad = e;
System.out.println("C: nombre=" + nombre + ", edad=" + edad);
llorar();
}
public void establecerNombre(String n)
{
nombre = n;
}
public String obtenerNombre()
{
return nombre;
}
public void llorar()
{
System.out.println("llorando...");
}
}
public class BloqueInicializacionDemo {
public static void main(String[] args) {
Empleado emp1 = new Empleado();
emp1.obtenerNombre();
Empleado emp2 = new Empleado("carlos");
emp2.establecerNombre("miguel");
System.out.println(emp2.obtenerNombre());
Empleado emp3 = new Empleado("ana", 28);
emp3.establecerNombre("laura");
}
}
/*
- this: se utiliza para distinguir entre variables locales y de instancia con el mismo nombre.
- ¿Por qué this resuelve este problema?
- ¿Qué representa exactly this?
- this: representa el objeto actual de la clase. ¿Cuál objeto específicamente?
- this representa el objeto que está llamando al método donde se usa.
- En otras palabras, el objeto que invoca la función que contiene this. */
class Persona { private String nombre; private int edad;
Persona(String nombre)
{
this.nombre = nombre;
}
Persona(String n, int a)
{
nombre = n;
edad = a;
}
public void hablar()
{
System.out.println("nombre = " + this.nombre + '\n' + "edad = " + this.edad);
}
public void mostrar()
{
System.out.println(this.nombre);
}
}
public class ThisDemo {
public static void main(String[] args) {
Persona persona = new Persona("carlos");
persona.hablar();
}
}
</div>11-Aplicación de this
=====================
<div>```
package ejemploThisAplicacion;
/*
* this: se utiliza para distinguir variables locales y de instancia con igual nombre.
* ¿Por qué this resuelve esto?
* ¿Qué representa exactamente?
*
* this: representa el objeto de la clase. ¿Cuál objeto específicamente?
* this representa el objeto que llama al método donde se usa.
*
* Aplicación de this: cuando un método necesita hacer referencia al objeto que lo llamó,
* se utiliza this. Cualquier método que use el objeto actual debe emplear this.
*/
class Persona
{
private String nombre;
private int edad;
Persona(int edad)
{
this.edad = edad;
}
Persona(String n, int a)
{
nombre = n;
edad = a;
}
public void hablar()
{
System.out.println("nombre = " + this.nombre + '\n' + "edad = " + this.edad);
}
public void mostrar()
{
System.out.println(this.nombre);
}
/*
* Necesidad: definir método para comparar si dos personas tienen la misma edad.
* Determinar si son de la misma generación.
*/
public boolean comparar(Persona p)
{
return this.edad == p.edad;
}
}
public class ThisAplicacionDemo {
public static void main(String[] args) {
Persona persona1 = new Persona(20);
Persona persona2 = new Persona(25);
boolean resultado = persona1.comparar(persona2);
System.out.println(resultado);
}
}
/*
- this() : permite llamar constructores desde otros constructores.
- Solo puede usarse en la primera línea del constructor.
- La inicialización debe ejecutarse primero. */
class Persona { private String nombre; private int edad;
Persona()
{
//this("ejemplo")
}
Persona(String nombre)
{
this.nombre = nombre;
}
Persona(String nombre, int edad)
{
this.edad = edad;
}
}
public class ThisConstructorDemo {
public static void main(String[] args) {
Persona persona = new Persona("carlos", 30);
}
}
</div>