La programación orientada a objetos o POO

Es un paradigma de programación que usa objetos y sus interacciones, para diseñar

aplicaciones y programas informáticos. Está basado en varias técnicas, incluyendo herencia,
abstracción, polimorfismo y encapsulamiento.

Clase (informática)

Una clase es una construcción que se utiliza como un modelo (o plantilla) para crear objetos de
ese tipo.

Una clase es un contenedor de uno o más datos (variables o propiedades miembro) junto a las
operaciones de manipulación de dichos datos (métodos). Las clases pueden definirse como
estructuras (struct), uniones (union) o clases (class) pudiendo existir diferencias entre cada una
de las definiciones según el lenguaje. Además las clases son agrupaciones de objetos que
describen su comportamiento.

class Nombre {
// Variables miembro (habitualmente privadas)
miembro_1; //lista de miembros
miembro_2;
miembro_3;

// Funciones o métodos (habitualmente públicas)

funcion_miembro_1( ); // funciones miembro conocidas
funcion_miembro_2 ( ); // funciones como métodos

// Propiedades (habitualmente públicas)

propiedad_1;
propiedad_2;
propiedad_3;
propiedad_4;
}

Instancia (informática)

La palabra Instancia significa: Solicitud o Insistencia.

Una instancia de un programa es una copia de una versión ejecutable del programa que ha
sido escrito en la memoria del computador.

Una instancia de un programa es creada típicamente por el click de usuario en un icono de una
interfaz Gráfica para usuarios GUI o por la entrada de un comando en una interfaz de línea de
comandos CLI y presionando la tecla ENTER. Instancias de programas pueden ser creadas por
otros programas.
Objeto (programación)

En el paradigma de programación orientada a objetos (POO, o bien OOP en inglés), un objeto

se define como la unidad que en tiempo de ejecución realiza las tareas de un programa.
También a un nivel más básico se define como la instancia de una clase.

En el mundo de la programación orientada a objetos (POO), un objeto es el resultado de la

instanciación de una clase. Una clase es el anteproyecto que ofrece la funcionalidad en ella
definida, pero ésta queda implementada sólo al crear una instancia de la clase, en la forma de
un objeto. Por ejemplo: dado un plano para construir sillas (una clase de nombre clase silla),
entonces una silla concreta, en la que podemos sentarnos, construida a partir de este plano,
sería un objeto de clase silla. Es posible crear (construir) múltiples objetos (sillas) utilizando la
definición de la clase (plano) anterior.

Herencia (informática)

En orientación a objetos la herencia es el mecanismo fundamental para implementar la

reutilización y extensibilidad del software. A través de ella los diseñadores pueden construir
nuevas clases partiendo de una jerarquía de clases ya existente (comprobadas y verificadas)
evitando con ello el rediseño, la modificación y verificación de la parte ya implementada. La
herencia facilita la creación de objetos a partir de otros ya existentes, obteniendo
características (métodos y atributos) similares a los ya existentes.

Es la relación entre una clase general y otra clase más especifica. Por ejemplo: Si declaramos
una clase párrafo derivada de una clase texto, todos los métodos y variables asociadas con la
clase texto, son automáticamente heredados por la subclase párrafo.

La herencia es uno de los mecanismos de la programación orientada a objetos, por medio del
cual una clase se deriva de otra, llamada entonces clase base o clase padre,(a veces se le
denomina superclase pero no es muy comun), de manera que extiende su funcionalidad. Una
de sus funciones más importantes es la de proveer Polimorfismo.

public class Mamifero{

private int patas;
private String nombre;
public void imprimirPatas(){
JOptionPane.showMessageDialog(null," Tiene " + patas +
"patas\n","Mamifero",JOptionPane.INFORMATION_MESSAGE);
}
public Mamifero(String nombre, int patas){
this.nombre = nombre;
this.patas = patas;
}
}

public class Perro extends Mamifero {

public Perro(String nombre){
super(nombre, 4);
 }
}

public class Gato extends Mamifero {

public Gato(String nombre){
super(nombre, 4);
}
}

public class CrearPerro {

public static void main(String [] args) {
Perro perrito = new Perro("Canelita");
perrito.imprimirPatas(); /*Está en la clase mamífero*/
}
}

Polimorfismo (informática)

En programación orientada a objetos el polimorfismo se refiere a la capacidad para que varias

clases derivadas de una antecesora utilicen un mismo método de forma diferente.

Como se mencionó anteriormente, el concepto de polimorfismo se puede aplicar tanto a

funciones como a tipos de datos. Así nacen los conceptos de funciones polimórficas y tipos
polimórficos. Las primeras son aquellas funciones que pueden evaluarse o ser aplicadas a
diferentes tipos de datos de forma indistinta; los tipos polimórficos, por su parte, son aquellos
tipos de datos que contienen al menos un elemento cuyo tipo no está especificado.

Se puede clasificar el polimorfismo en dos grandes clases:

Polimorfismo dinámico (o polimorfismo paramétrico) es aquél en el que el código no incluye

ningún tipo de especificación sobre el tipo de datos sobre el que se trabaja. Así, puede ser
utilizado a todo tipo de datos compatible.
Polimorfismo estático (o polimorfismo ad hoc) es aquél en el que los tipos a los que se aplica
el polimorfismo deben ser explicitados y declarados uno por uno antes de poder ser utilizados.

Ejemplo de polimorfismo

#include<iostream>
using namespace std;

class figura {
public:
float base;
float altura;
public:
float captura();
virtual unsigned float perimetro()=0;
virtual unsigned float area()=0;
};

class rectangulo: public figura{

public:
void imprime();
unsigned float perimetro(){return 2*(base+altura);}
unsigned float area(){return base*altura;}
};

class triangulo: public figura{

public:
void muestra();
unsigned float perimetro(){return 2*altura+base}
unsigned float area(){return (base*altura)/2;}
};

void figura::captura(){
cout<<"CALCULO DEL AREA Y PERIMETRO DE UN TRIANGULO
ISÓSCELES Y UN RECTANGULO:" <<endl;
cout<<"escribe la altura: ";
cin>>altura;
cout<<"escribe la base: ";
cin>>base;
cout<<"EL PERIMETRO ES:" << perimetro();
cout<<"EL AREA ES:" << area();
};

Atributos

Los atributos son las caracterísiticas individuales que diferencian un objeto de otro y
determinan su apariencia, estado u otras cualidades. Los atributos se guardan en variables
denominadas de instancia, y cada objeto particular puede tener valores distintos para estas
variables.

Las variables de instancia también denominados miembros dato, son declaradas en la clase
pero sus valores son fijados y cambiados en el objeto.

Además de las variables de instancia hay variables de clase, las cuales se aplican a la clase y a
todas sus instancias. Por ejemplo, el número de ruedas de un automóvil es el mismo cuatro,
para todos los automóviles.

Método (informática)
En la programación orientada a objetos, un método es una subrutina asociada exclusivamente
a una clase (llamados métodos de clase o métodos estáticos) o a un objeto (llamados
métodos de instancia). Análogamente a los procedimientos en los lenguajes imperativos, un
método consiste generalmente de una serie de sentencias para llevar a cabo una acción, un
juego de parámetros de entrada que regularán dicha acción y, posiblemente, un valor de salida
(o valor de retorno) de algún tipo.
• En algunos lenguajes de programación
orientados a objetos:
– Los objetos son datos
– Las clases son tipos de datos
• En ruby las clases también son objetos
de tipo Class:
10.class => FixNum
"hola".class => String
Fixnum.class => Class
String.class => Class
Float.class => Class
Class.class => Class

Accesores (Accessors)
Los Accesores en Ruby provienen de la clase Module, ellos permiten no tener que definir
métodos accesores esplícitamente (getters y setters). Además, permiten ahorar lineas
importantes de código.

Los accesores más importantes son:

attr
attr_reader
attr_writer
attr_accessor

Un getter es un método que "consigue" el valor de una característica específica. Un setter es

un método que "fija" el valor de una característica específica. En Ruby, el valor que se consigue
o fija con los setters o getters, respectivamente, es el que toma la variable de instancia que
definen.

attr

El módulo accesor attr crea un getter único, que incluye la creación de un método para
acceder a una variable de instancia con el mismo nombre.

attr :nombre, true

El método que crea attr tiene el mismo nombre del símbolo que se le pasa a manera de
argumento (nombre). A su vez, la variable de instancia a la que permite el acceso también
tiene el mismo nombre del símbolo (@nombre).

Cabe destacar el segundo argumento, ese true. Este segundo argumento puede tomar dos
valores lógicos, true o false (no se escribe nada si es false). Si toma el valor true, el módulo attr
permite además de la creación de un getter, un setter (opcional, pues depende de si el
segundo argumento es true o false); si es false, se omite la creación del setter.

En resumen, veamos cómo nos facilita este accesor unas líneas de código:
Creamos una clase cualquiera:

class Todoruby
def initialize (nombre)
@nombre = nombre
end
def nombre
@nombre
end
end

Ahora creemos la misma clase pero usando attr:

class Todoruby
attr :nombre, true
end

Eso simplemente, ya que attr ya nos definió el método nombre y nos creó una variable de
instancia (@nombre) que permite acceder a ese método.

attr_reader

El módulo accesor attr_reader permite la creación de uno o más getters, que incluye la
creación de uno o más métodos para acceder a una o más variables de instancia con sus
nombres correspondientes.

attr_reader :nombre, :ancho, :alto

Los métodos y las variables de instancia que crea attr_reader tienen igual nombre que sus
símbolos respectivos.

attr_reader se pasa sin más argumentos (no existe el argumento true como en attr).

attr_writer

El módulo accesor attr_writer permite la creación de uno o más setters, que incluye la creación
de uno o más métodos para acceder a una o más variables de instancia con sus nombres
correspondientes.

attr_writer :nombre, :ancho, :alto

Los métodos y las variables de instancia que crea attr_writer tienen igual nombre que sus
símbolos respectivos.

attr_writer se pasa sin más argumentos (no existe el argumento true como en attr).

attr_accessor
El módulo accesor attr_accessor permite la creación de un attr_writer y un attr_reader para
cada variable de instancia que crean, representadas por el símbolo que se les pasa como
argumento.

Permiten reducir esto:

class Persona
def nombre
@nombre
end
def nombre=(nombre)
@nombre = nombre
end
def edad
@edad
end
def edad=(edad)
@edad = edad
end
end

a esto:

class Persona
attr_accessor :nombre, :edad
end

Parámetros
En informática, un parámetro es un tipo de variable que es recibida por una función,
procedimiento o subrutina.

Un parámetro influye en el comportamiento o el resultado de la ejecución de la función,

procedimiento o subrutina (de ahora en más sólo procedimiento) que lo recibe. Son muy
utilizados en la programación.

En general, en la definición de un procedimiento, es incluida una lista ordenada de

parámetros; de esta manera, cada vez que el procedimiento es llamado, los argumentos de esa
llamada pueden ser asignados a los correspondientes parámetros. Aquí se expone sutilmente
la diferencia técnica entre parámetro y argumento, aunque muchas veces son tratados como
sinónimos.

La semántica de cómo pueden ser declarados los parámetros y cómo los argumentos son
pasados a los parámetros de los procedimientos, son definidos por cada lenguaje de
programación.
Encapsulamiento (informática)
En programación modular, y más específicamente en programación orientada a objetos, se
denomina encapsulamiento al ocultamiento del estado, es decir, de los datos miembro, de un
objeto de manera que sólo se puede cambiar mediante las operaciones definidas para ese
objeto.
Cada objeto está aislado del exterior, es un módulo natural, y la aplicación entera se reduce a
un agregado o rompecabezas de objetos. El aislamiento protege a los datos asociados a un
objeto contra su modificación por quien no tenga derecho a acceder a ellos, eliminando
efectos secundarios e interacciones.
Encapsulamiento Se dice que es el empaquetado de métodos y atributos dentro de un objeto,
mediante una interfaz gráfica. La clave está precisamente en el envoltorio del objeto .
Como se puede observar de los diagramas, las variables del objeto se localizan en el centro o
núcleo del objeto. Los métodos rodean y esconden el núcleo del objeto de otros objetos en el
programa. Al empaquetamiento de las variables de un objeto con la protección de sus
métodos se le llama encapsulamiento. Típicamente, el encapsulamiento es utilizado para
esconder detalles de la puesta en práctica no importantes de otros objetos. Entonces, los
detalles de la puesta en práctica pueden cambiar en cualquier tiempo sin afectar otras partes
del programa.

Formas de encapsular

Estándar (Predeterminado)
Abierto: Hace que el miembro de la clase pueda ser accedido desde el exterior de la Clase y
cualquier parte del programa.
Protegido: Solo es accesible desde la Clase y las clases que heredan (a cualquier nivel).
Semi cerrado: Solo es accesible desde la clase heredada
Cerrado: Solo es accesible desde la Clase.
En el encapsulamiento hay analizadores que pueden ser semánticos y sintácticos.