post icon

Programación Orientada a Objetos: Clases y Objetos

Desde la universidad y el trabajo he notado constantemente que los conceptos del paradigma de la Programación Orientada a Objetos hace temblar hasta al mas experimentado programador tradicional, me parecen que no son difíciles de comprender pero es un poco duro masticarlos ya que nos hacen cambiar de manera radical nuestra manera de pensar en código, por eso decidí escribir un tutorial entregados en varios artículos, explicando los conceptos de este paradigma.

En Internet encontrarán miles de guías, tutoriales, libros, blog, foros que explican estos conceptos a su manera. He llegado en conclusión que las personas por algún motivos sólo les llega la explicación de algunos de éstos autores y no todos (como me paso a mí y a mis compañeros), espero poder llegar a explicar y dar a entender estas ideas. Para facilitar la comprensión, en el tutorial escribiré ejemplos prácticos en 2 lenguajes distintos: Java y Visual Basic. (No elijo C# por su parecido sintáctico con Java). También cuando sea necesario contextualmente veremos SQL aplicado.

La definición que da la Wikipedia sobre la Programación Orientada a Objetos (de ahora en más OOP) es la siguiente:

La programación orientada a objetos o POO (OOP según sus siglas en inglés) 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. 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.

En la primer parte comenzaremos con 2 conceptos muy sencillos, que son las clases y los objetos, aún así siendo sencillos producen tanta duda en programadores que comienzan a introducirse en el Mundo OOP.

Una clase es un mapeo, una abstracción conceptual, definición o descripción de un cualquier “cosa” del mundo real, esas definiciones se logran mediante atributos y acciones propias de la clase. Y el objeto es la instancia, algo “real” que plasma las definiciones de su clase.

Es un poco engorroso comprenderlo así no?, con una idea más práctica es más sencillo. Se puede decir que una persona es una clase, por que las personas están compuestas por varios atributos que la definen, por ejemplo sus brazos, ojos, bocas, altura, peso, tez, género, nombre, apellido, nacimiento, nacionalidad, todo esto son abstracciones conceptuales que definen a una persona. Si plasmamos esto en el plano real, Yo soy un objeto, Tú eres otro objeto, Linus Torvals es otro objeto de la clase persona, todos somos un objeto o una instancia de la clase persona y cada uno tenemos nuestros atributos que nos definen como tal.

Aplicados a la OOP estas ideas, una clase tiene prácticamente n-atributos, pero para resolver un sistema no necesitamos de todos ellos, sólo debemos abstraer los conceptos que son requeridos para el contexto del sistema, dicho en otras palabras, un atributo típico de la clase persona suele ser Número de Documento de Identidad y sus nombres. En la mayoría de los sistemas o contextos a resolver es un atributo válido, pero que sucede si estamos creando un sistema para una hospital materno, donde sólo se hacen partos? Estos atributos no se ven aplicados al contexto, ya que los bebés al nacer recién no se registran aún y por ende no tienen nombres, apellidos y mucho menos documento de identidad. Se comprende? Es por eso que sólo debemos dedicarnos a mapear los atributos relevantes dentro de nuestro contexto.

Vamos ya a lo práctico y creemos la clase Persona en los lenguajes de programación citados arriba.

Java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
package devtroce;
 
public class Persona {
 
	/**
	 * @author GeekZero@DevTroce.com
	 */
 
	// lista de atributos que la definen
	private String Nombre;
	private String Apellido;
	private String Documento;
	private int Peso;
	private String Ojos;
	private char Sexo;
 
	// metodo para poder ejecutar la clase en Java (irrelevante para el conceto estudiado)
	public static void main(String[] args) {
		// instancia de la clase persona
		// el nombre del objeto debe ser distinto que el nombre de su clase,
		// puede tener cualquiera que querramos
		Persona persona = new Persona();
 
		// asignación de valores al objeto
		persona.Nombre = "Linus";
		persona.Apellido = "Torvals";
		persona.Documento = "777";
		persona.Peso = 80;
		persona.Ojos = "Azul";
		persona.Sexo = 'M';
 
		// instancia de la clase persona
		Persona otraPersona = new Persona();
 
		// asignación de valores al objeto
		otraPersona.Nombre = "Winona";
		otraPersona.Apellido = "Raider";
		otraPersona.Documento = "666";
		otraPersona.Peso = 65;
		otraPersona.Ojos = "Marrones";
		otraPersona.Sexo = 'F';
 
		// listado
		System.out.println("La primer persona es: " + persona.Nombre + " " + persona.Apellido);
		System.out.println("La segunda persona es: " + otraPersona.Nombre + " " + otraPersona.Apellido);
	}
}

Visual Basic

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
' @author GeekZero@DevTroce.com
 
Public Class Persona
 
    ' lista de atributos que la definen
    Private Nombre As String
    Private Apellido As String
    Private Documento As String
    Private Peso As Integer
    Private Ojos As String
    Private Sexo As Char
 
    Public Sub Mostrar()
        ' instancia de la clase persona
        ' el nombre del objeto debe ser distinto que el nombre de su clase,
        ' puede tener cualquiera que querramos
        Dim persona As Persona = New Persona
 
        ' asignación de valores al objeto
        persona.Nombre = "Linus"
        persona.Apellido = "Torvals"
        persona.Documento = "777"
        persona.Peso = 80
        persona.Ojos = "Azul"
        persona.Sexo = "M"
 
        ' instancia de la clase persona
        Dim otraPersona As Persona = New Persona
 
        ' asignación de valores al objeto
        otraPersona.Nombre = "Winona"
        otraPersona.Apellido = "Raider"
        otraPersona.Documento = "666"
        otraPersona.Peso = 65
        otraPersona.Ojos = "Marrones"
        otraPersona.Sexo = "F"
 
        ' listado
        Debug.WriteLine("La primer persona es: " + persona.Nombre + " " + persona.Apellido)
        Debug.WriteLine("La segunda persona es: " + otraPersona.Nombre + " " + otraPersona.Apellido)
 
    End Sub
 
End Class

Ahora si, muy sencillo no? Alguno me dirán, pero con este ejemplo no lograste gran cosa, y es cierto. Aún no es la forma definitiva que escribiremos código OOP más adelante, sólo es para comprender el concepto y diferencia entre una clase y objeto. Una vez que veamos otros conceptos como Setter, Getter y Métodos será más interesan la manera que declararemos las clases.

Otra pregunta que puede surgir es para que andar creando variables a diestra y siniestra? es para luego ir reutilizando y obligatorio y necesario crear una variable por cada campo de nuestras tabla (esto ya hablando de un sistema real con tablas y no sólo concepto volátiles). Estoy seguro que en la gran mayoría de los tutoriales que encontrarán sólo llegará hasta aquí, pero cuando yo estudiaba me hubiera gustado que me hubieran dicho de entrada que éstas cosas son a parte de una abstracción conceptual, son también un mapeo de nuestras tablas de la Base de Datos, les dejo el script DDL SQL de una supuesta tabla.

T-SQL

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
USE [OOP]
GO
 
CREATE TABLE [dbo].[Persona](
	[IdPersona] [int] IDENTITY(1,1) NOT NULL,
	[Nombre] [varchar](50) NOT NULL,
	[Apellido] [varchar](50) NOT NULL,
	[Documento] [varchar](20) NOT NULL,
	[Peso] [int] NOT NULL,
	[Ojos] [varchar](15) NOT NULL,
	[Sexo] [char](1) NOT NULL,
 CONSTRAINT [PK_Persona] PRIMARY KEY CLUSTERED 
(
	[IdPersona] ASC
)WITH (PAD_INDEX  = OFF, STATISTICS_NORECOMPUTE  = OFF, IGNORE_DUP_KEY = OFF, ALLOW_ROW_LOCKS  = ON, ALLOW_PAGE_LOCKS  = ON) ON [PRIMARY]
) ON [PRIMARY]
 
GO
 
ALTER TABLE [dbo].[Persona]  WITH CHECK ADD  CONSTRAINT [CK_Persona] CHECK  (([Sexo]='M' OR [Sexo]='F'))
GO
 
ALTER TABLE [dbo].[Persona] CHECK CONSTRAINT [CK_Persona]
GO

Comentarios desde Facebook:

  1. avatar
    Irene NETHERLANDS Mozilla Firefox Windows
    13 septiembre 2011 at 04:47 #

    Claro, didáctico y directo, muchas gracias!

Trackbacks/Pingbacks

  1. Programación Orientada a Objetos: Setter y Getter | DevTroce.com WordPress - 5 septiembre 2010

    […] con el ejemplo que veiamos en la  primer parte del tutorial, agregaremos éste nuevo concepto al código ya existente. Verán que al final se ejecutará lo […]

Responder