Programación Orientada a Objetos

 

Introducción a La Programación Orientada a Objetos

La programación orientada a objetos o POO (OOP según sus siglas en inglés) es un paradigma de programación que usa los objetos en sus interacciones, para diseñar aplicaciones y programas informáticos. Está basado en varias técnicas, incluyendo herencia, abstracción, polimorfismo y encapsulamiento. Su uso se popularizó a principios de la década de los años 1990. En la actualidad, existe variedad de lenguajes de programación que soportan la orientación a objetos.

Definiciones de los Elementos primordiales de la programación orientada a objetos.

Objeto: entidad que contiene datos (atributos) y comportamiento (métodos). Los datos definen el estado del objeto, el comportamiento define su funcionalidad.

Clase: una clase “C” define los datos (atributos) y comportamiento (métodos) de cada objeto “O” que se cree por instanciación a partir de “C”.

Atributos	Instanciación	Resultado
Nombre	Instanciación	Nombre: Pedro
Cedula	Instanciación	Cedula: 12345678
Edad	Instanciación	Edad: 30
Empresa	Instanciación	Empresa: UC

Encapsulamiento: es la combinación de atributos y métodos en la misma entidad, lo que permite controlar el acceso de datos.

Ocultamiento de Información: es la definición de restricciones de acceso a ciertos atributos y/o métodos.

Restricciones de Acceso:  

Público: cuando un atributo o método se define como público, objetos de otras clases pueden acceder a ellos libremente.

Privado: cuando un método o atributo se define privado, solo el objeto en cuestión puede accederlo y no fuera de él.

Interfaz de Una Clase: define el medio de comunicación fundamental entre objetos. Debido al ocultamiento de información, todos los atributos deben declararse como privados. Por lo tanto los atributos no forman parte de la interfaz, solo los métodos públicos.

Metodos Observadores y Modificadores (Getters y Setters): Complementan el concepto de ocultamiento de información. Debido que otros objetos no deben manipular directamente los datos de un objeto, los métodos observadores y modificadores proveen acceso controlado a los datos.

UML (Unified Modeling Languaje): lenguaje unificado de modelado. Es un lenguaje grafico estandarizado para la visualización, especificación, construcción y documentación de un sistema de software. Cuenta con varios tipos de diagramas:

Diagramas de Estructura: de clases, de componentes, de objetos, de estructura compuesta, de despliegue, de paquetes.

Diagramas de Comportamiento: de actividades, de casos de uso, de estados.

Diagramas de Interacción: de secuencia, de comunicación, de tiempos y de vista de interacción.

Clases en UML:

Vista Restringida: Notación

Nombre de Clase

Ejemplo:

Estudiante

Vista Detallada: Notación

Nombre de La Clase

Atributo1 : Tipo Atributo2 : Tipo Atributo3 : Tipo AtributoN : Tipo

Metodo1 (parámetros) Metodo2 (parámetros) Metodo3 (parámetros) MetodoN (parámetros)

Restricciones de Acceso:

+: Publico

-: Privado

#: Protegido

Ejemplo:

Estudiante:

-          Cedula

-          Nombre

-          Edad

-          Promedio

+    modificar_edad (e : entero)

+    modificar_promedio (p : real)

+    consultar_cedula ()

+    consultar_edad ()

Interrelaciones Entre Clases: definen conexiones semánticas entre los elementos del modelo.

Herencia: es un mecanismo que permite que los datos y el comportamiento de una clase sean incluidos o utilizados como base para otras clases. Bajo este esquema se relaciona una clase base y una o varias clases derivadas. La clase base contiene todos los datos y comportamiento compartidos por las clases derivadas de ella.

Clase Base

Subclase1

Subclase2

SubclaseN

                   

              

La clase base es conocida como superclase, y las clases derivadas como subclases.

# Protegido: define que los métodos protegidos solo pueden ser accedidos por la clase base y sus derivadas. Extiende el acceso a las clases hijas.

Cuando se hereda de una clase base, se crea una nueva clase que contiene todos los atributos de la clase base y contiene a demás la interfaz de esa clase. La herencia es una interrelación entre dos o más clases. Es una interrelación de tipo “es un”.

Generalización/Especificación: son principios de abstracción que permiten definir clases como un refinamiento de otras clases. La clase más general se denomina clase padre o superclase, y las derivadas clases hijas o subclases.

Asociación: es una interrelación general entre dos o más clases.

Empresa

Empleado

Multiplicidad: se define como el número de instancias relacionadas por medio de la asociación.

N…M siendo el mínimo N y el máximo M.

0…* cero o mas

1…* 1 o mas

Agregación: es una interrelación de tipo “tiene un”. Modela una interrelación “es parte de” entre dos o más clases.

Composición: es una interrelación de agregación de agregación “más fuerte”. El objeto parte permanece solo con el todo, cuando el todo desaparece, la parte también. 

Paso de Mensajes: es el proceso mediante el cual un objeto envía datos a otro objeto o solicita un servicio de otro objeto por medio de la llamada a un método.

Pseudocodigo: Definición de Clases

Clase <identificador de clase>

Privado

<Identificador de atributo> : tipo

Proc <identificador de procedimiento> (argumentos)

Func <identificador de función> (argumentos) : tipo

Protegido

//atributos y métodos protegidos

Publico

//métodos públicos

Fclase

//implementación de los métodos

Func <identificador de clase> : : <identificador de método> (argumentos) : tipo

Inicio

            //cuerpo del método

Finfunc

Proc <identificador de clase> : : <identificador de metodo> (argumentos)

Inicio

            //cuerpo del metodo

Fproc

Ejemplo de definición de una clase

Clase Punto2D

Privado

X,Y : real

Público:

Punto2D() //constructor sin parámetros

Punto2D(val x,y : real) //constructor con parámetros definidores de instancia

Proc setX (val x : real ) //modificadores

Proc setY (val y : real ) //modificadores

Func getX () : real //consultores

Func getY () : real //consultores

Fclase

//Implementación de los Métodos

Punto2D::Punto2D()

Inicio

            X = 0

            Y = 0

Fin

Punto2D::Punto2D(val x1,y1 : real)

Inicio

            X = x1

            Y = y1

Fin

Proc Punto2D::setX(val x1 : real)

Inicio

            X = x1

Fin

Proc Punto2D::setY(val y1 : real)

Inicio

            Y = y1

Fin

Func Punto2D::getX(val x1 : real) : real

Inicio

            Retornar (X)

Fin

Func Punto2D::getY(val y1 : real) : real

Inicio

            Retornar (Y)

Fin

Pasó de Mensajes:

Para métodos no constructores

<identificador>.<identificador del metodo> ( parametros )

Para constructores

<identificador>( parametros ) : <identificador del constructor>

Ejemplo usando la clase Punto2D

Algoritmo Puntos

Var

V: real

P1: Punto2D

P2 (5.0,2.4) : Punto2D

Inicio

P1.setX(3.0)

V = P2.getY()

Escribir (v)

Fin

Herencia:

Clase < identificador de clase derivada> hereda_de <identificador de clase base>

            //definición de atributos y métodos

Fclase

//implementación de atributos y métodos

Nota: un ejercicio para ver la herencia es implementar la clase punto 3D como herencia de la clase punto 2D, haciendo uso de los métodos de punto 2D para crear métodos de punto 3D. Otro ejemplo es implementando punto3D como herencia de punto 2D pero con acceso directo a los atributos de punto2D, al declarar como protegidos los atributos de punto2D. Para acceder a los métodos de la superclase se usa la palabra reservada “super”. Su estructura es:

Super <nombre del metodo> (parametros)

Polimorfismo: es una característica que permite a diferentes clases responder al mismo mensaje, implementando cada una de ellas el método de manera adecuada.

Tipos de Polimorfismo

Sobrecarga (overloading / static polymorphism): es una característica que permite proporcionar operaciones con el mismo nombre pero signaturas diferentes (es decir, operaciones de igual nombre pero que difieren en el tipo de datos o cantidad de parámetros).

Sobreescritura (overriding /dynamic polimorphism): es una característica que permite definir en una subclase una operación que restringe o modifica el comportamiento original de la misma, pero preservando su signatura.

Constructores y Destructores: los constructores definen un objeto “0” de una clase “C”. Cada objeto representa una instancia de esa clase. Los constructores sin parámetros definen los datos del objeto en un estado base o estándar, o estado de inicialización. Los constructores con un parámetro son conocidos como constructores copia, que permiten realizar una copia exacta de una instancia en otra instancia diferente. Es usado sobre todo cuando los atributos de una clase definen un tipo recursivo, para evitar que en vez de realizar una copia exacta, se realice una “referenciacion” de un objeto a otro. De esta forma se prevee que al modificar un objeto, el otro tenga que cambiar. Un constructor con “n” parámetros (n = cantidad de atributos de la clase) define una instancia determinada para un objeto. Se definen como métodos que tienen el mismo nombre de la clase.

Los destructores por otra parte permiten la liberación de memoria de un objeto que ya no será usado. En los lenguajes sin recolección de basura, es necesario implementar estos destructores para poder liberar el espacio ocupado. Son métodos definidos con el nombre de la clase, similar a los constructores pero anteponiéndole el símbolo “~”.

Ejemplo: ~<identificador de clase>(parametros)

Ejemplos Programados (C++) 

//Clase persona

class Person{
   //Atributos

   private:
        std::string nombre;
        std::string apellido;
        std::string cedula;
        int anno_nacimiento;
        //constantes
        static const int EDAD_VOTANTE = 18;
        static const int EDAD_MAYOR = 65;
      
    public:
        //Constructores
        Person(std::string n, std::string a, std::string c, int aa) : nombre(n), apellido(a), cedula(c), anno_nacimiento(aa){}
        Person() : nombre(""), apellido(""), cedula(""), anno_nacimiento(1990){}
      
        void modNombre(std::string n){
            nombre = n;
        }
      
        void modApellido(std::string a){
            apellido = a;
        }
      
        void modCedula(std::string c){
            cedula = c;
        }
      
        void modAnno(int aa){
            anno_nacimiento = aa;
        }
      
        std::string obtNombre(){
            return nombre;
        }
      
        std::string obtApellido(){
            return apellido;
        }
      
        std::string obtCedula(){
            return cedula;
        }
      
        int obtAnno(){
            return anno_nacimiento;
        }
      
        int edad(int anno);
      
        bool puedeVotar(int anno);
      
        bool esAdultoMayor(int anno);
      
        //sobrecarga de operadores
        bool operator==(const Person& per) const;
        bool operator!=(const Person& per) const;
};