Programación Orientada a Objetos

Conocida como POO o en inglés OOP es una forma de programación cuando se necesita implementar objetos para su control fácil y eficiente.

Conceptos

Abstracción

Es cuando tomamos un objeto de la vida real y tomamos sus características en una clase.
Un ejemplo:

  • Un automóvil es un vehículo motorizado con cuatro ruedas, usa un tipo de combustible y tiene marca y modelo.

De esto podemos tomar sus variables:

  • Combustible
    • Tipos:
      1. Diesel
      2. Gasolina
  • Marca
  • Modelo
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
public class Automovil {
    private Integer combustible;
    private String marca;
    private String modelo;
    public Automovil() {}
    public Automovil(Integer combustible, String marca, String modelo) {
        this.combustible = combustible;
        this.marca = marca;
        this.modelo = modelo;
    }
}

Por lo que sé instancia:
Automovil miAuto = new Automovil(1, 'Ford', 'Explorer');
Donde 1 = Diesel

Encapsulamiento

Esto se refiere a "proteger" los datos de un objeto para que estos no sean accesibles desde el exterior.
Tomando el ejemplo anterior:

  • Definiendo las variables que serán habitadas como privadas. (Esto evita acceder a esas variables desde el exterior de la misma clase)
  • Si se quiere cambiar un valor a un objeto ya establecido, entonces se deben crear métodos para esa tarea.
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
public class Automovil {
    private Integer combustible; // privado
    private String marca; // privado
    private String modelo; // privado
    public Automovil() {}
    public Automovil(Integer combustible, String marca, String modelo) {
        this.combustible = combustible;
        this.marca = marca;
        this.modelo = modelo;
    }
}

Principio de ocultación

Va muy de la mano con Encapsulamiento. Es eso que se encarga de ocultar las variables del código externo, y, además, crea los métodos para la operación del objeto. Evitando modificar valores de objetos mediante el acceso a estas variables.
Y si se quiere modificar u obtener un valor de un objeto, entonces se deben crear métodos que realizan estas operaciones.
En resumen:
Evitamos modificar un valor de una variable mediante código externo:

1
2
3
Automovil miAuto = Automovil(1, 'Ford', 'Exporer');
// NO PODEMOS MODIFICAR ESOS VALORES (1, ford, explorer)
miAuto.combustible = 2; // ESTO ESTA MAL. y no se puede XD (variables tipo privadas)

Debemos realizar esa operación con métodos. Entonces a nuestra clase se le agrega:

1
2
3
public setCombustible (Integer tipo) {
    this.combustible = tipo;
}

Para luego modificar ese valor con el método:

1
2
Automovil miAuto = Automovil(1, 'Ford', 'Exporer');
miAuto.setCombustible(2); // esto esta bien uwu

Polimorfismo

No sé, pero creo que es cuando dos clases se las quiere combinar, pero resulta que se deben parsear o mapear valores para su compatibilidad. (No me hagas caso, honestamente no entiendo esta parte.)

Herencia

La herencia es una forma de agrupar objetos que comparten una característica en común.
El mejor ejemplo es:
- Los mamíferos
- Un perro, elefante, jirafa, yo, tú, somos mamíferos.

Pero, siguiendo nuestro ejemplo anterior:
- Un vehículo es motorizado y:
- Tiene marca
- Tiene modelo
- Tiene tipo de combustible
- Una bocina uwu
- Son vehículos
- Un auto
- Una moto
- Un avión
(Pues comparten las características de un vehículo)

Por lo que:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
public class Vehiculo {
    private Integer combustible; // privado
    private String marca; // privado
    private String modelo; // privado
    public Vehiculo() {}
    public Vehiculo (Integer combustible, String marca, String modelo) {
        this.combustible = combustible;
        this.marca = marca;
        this.modelo = modelo;
    }
    public tocaBocina() {
        System.out.println("PI PIIIIIIIIIIIIIIIIIIIIIIIIIII!");
    }
}

Y el objeto seria:

1
2
3
4
5
6
7
public class Automovil extends Vehiculo {
    private Integer nroPuertas;
    public Automovil() {}
    public Automovil(Integer nroPuertas) {
        this.nroPuertas= nroPuertas;
    }
}

Y se llamaría:

1
2
3
Automovil miAuto = Automovil(4);
miAuto.tocaBocina();
// se imprime: "PI PIIIIIIIIIIIIIIIIIIIIIIIIIII!"

Modularidad

Es cuando hacemos que nuestro programa tenga módulos totalmente independientes.
Un ejemplo es cuando programamos en Python el acceso a una base de datos:

  1. Con este principio, al administrador de la base de datos queda en un
    archivo .py diferente al resto.
  2. Las operaciones CRUD quedan en otro .PY
  3. etc...

De esta forma no queda un archivo tan extenso y se pueden mejorar los módulos por separados de forma fácil y eficiente en casos de problemas, mantenimiento y/o mejoras.

Acoplamiento

Es cuando un módulo depende de otro.
Existen:

  • Alto acoplamiento: Un módulo A depende de un módulo B. Por lo que si uno de estos módulos no existe, el otro no podrá existir.
  • Bajo acoplamiento: Un módulo A depende de un módulo B, pero uno no depende 100% del otro. (Esta es la recomendación)

Cohesión

No lo entiendo muy bien. Pero creo que se refiere a cuando una clase o cualquier código cumple con su propósito sin más ni menos. Perfectamente limitado. (Eso es alta cohesión)