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

Visual Basic
1
2 Public Class Persona
3
4 ' lista de atributos que la definen
5 Private Nombre As String
6 Private Apellido As String
7 Private Documento As String
8 Private Peso As Integer
9 Private Ojos As String
10 Private Sexo As Char
11
12 Public Sub Mostrar()
13 ' instancia de la clase persona
14 ' el nombre del objeto debe ser distinto que el nombre de su clase,
15 ' puede tener cualquiera que querramos
16 Dim persona As Persona = New Persona
17
18 ' asignación de valores al objeto
19 persona.Nombre = "Linus"
20 persona.Apellido = "Torvals"
21 persona.Documento = "777"
22 persona.Peso = 80
23 persona.Ojos = "Azul"
24 persona.Sexo = "M"
25
26 ' instancia de la clase persona
27 Dim otraPersona As Persona = New Persona
28
29 ' asignación de valores al objeto
30 otraPersona.Nombre = "Winona"
31 otraPersona.Apellido = "Raider"
32 otraPersona.Documento = "666"
33 otraPersona.Peso = 65
34 otraPersona.Ojos = "Marrones"
35 otraPersona.Sexo = "F"
36
37 ' listado
38 Debug.WriteLine("La primer persona es: " + persona.Nombre + " " + persona.Apellido)
39 Debug.WriteLine("La segunda persona es: " + otraPersona.Nombre + " " + otraPersona.Apellido)
40
41 End Sub
42
43 End Class
Ahora sí, 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
USE [OOP]
2
GO
3
4
CREATE TABLE [dbo].[Persona](
5
[IdPersona] [int] IDENTITY(1,1) NOT NULL,
6
[Nombre] [varchar](50) NOT NULL,
7
[Apellido] [varchar](50) NOT NULL,
8
[Documento] [varchar](20) NOT NULL,
9
[Peso] [int] NOT NULL,
10
[Ojos] [varchar](15) NOT NULL,
11
[Sexo] [char](1) NOT NULL,
12
CONSTRAINT [PK_Persona] PRIMARY KEY CLUSTERED
13
(
14
[IdPersona] ASC
15
)WITH (PAD_INDEX = OFF, STATISTICS_NORECOMPUTE = OFF, IGNORE_DUP_KEY = OFF, ALLOW_ROW_LOCKS = ON,
16
ALLOW_PAGE_LOCKS = ON) ON [PRIMARY]
17
) ON [PRIMARY]
18
19
GO
20
21
ALTER TABLE [dbo].[Persona] WITH CHECK ADD CONSTRAINT [CK_Persona] CHECK (([Sexo]='M' OR [Sexo]='F'))
22
GO
23
ALTER TABLE [dbo].[Persona] CHECK CONSTRAINT [CK_Persona]
24
GO
25
Programación Orientada a Objetos: Setter y Getter

Siguiendo con la segunda entrega del tutorial de OOP, continuaremos con los conceptos de Setters y
Getters.

Es aquí donde empieza a entrar en juego uno de los pilares del paradigma OOP, el encapsulamiento.
No es exclusivamente set y get los que definen dicho pilar pero ellos implementan y permiten que
suceda (también entran los métodos)

Que significa encapsular? Es poder definir el alcance, visibilidad de cualquier atributo o método de una
clase, esto nos otorga un par de beneficios, como que nadie asigne valores por equivocación
o sobrescriban funcionalidades cuando no deben. También permite la programación que se llama “Caja
Negra“, al tener atributos y métodos privados un programador que usará esa clase, no necesitará
conocer como lo hace, sino solamente que hace.

Es buena práctica crear los atributos con el modificador private mientras que el setter y getter con
public aunque esto no es la ley tampoco, puede existir algún caso que necesite romper
esta recomendación. De ésta manera las variables atributos podrán ser accedidas y modificadas no
directamente sino a través de los set y get.

Siguiendo con el ejemplo que veíamos en la primer parte del tutorial, agregaremos éste nuevo
concepto al código ya existente. Verán que al final se ejecutará lo mismo pero esta vez ya utilizando los
Setter y Getter, además que desde otras clases externas no podrán más modificar ni acceder a los
atributos de la clase, obligatoriamente deberán pasar por el Set y Get.
JAVA
1 package devtroce;
2
3 public class Persona {
4
5 // lista de atributos que la definen
6 private String Nombre;
7 private String Apellido;
8 private String Documento;
9 private int Peso;
10 private String Ojos;
11 private char Sexo;
12
13 public String getApellido() {
14 return Apellido;
15 }
16
17 public void setApellido(String Apellido) {
18 this.Apellido = Apellido;
19 }
20
21 public String getDocumento() {
22 return Documento;
23 }
24
25 public void setDocumento(String Documento) {
26 this.Documento = Documento;
27 }
28
29 public String getNombre() {
30 return Nombre;
31 }
32
33 public void setNombre(String Nombre) {
34 this.Nombre = Nombre;
35 }
36
37 public String getOjos() {
38 return Ojos;
39 }
40
41 public void setOjos(String Ojos) {
42 this.Ojos = Ojos;
43 }
44
45 public int getPeso() {
46 return Peso;
47 }
48
49 public void setPeso(int Peso) {
50 this.Peso = Peso;
51 }
52
53 public char getSexo() {
54 return Sexo;
55 }
56
57 public void setSexo(char Sexo) {
58 this.Sexo = Sexo;
59 }
60
61 // método para poder ejecutar la clase en Java (irrelevante para el concepto estudiado)
62 public static void main(String[] args) {
63 // instancia de la clase persona
64 // el nombre del objeto debe ser distinto que el nombre de su clase,
65 // puede tener cualquiera que queramos
66 Persona persona = new Persona();
67
68 // asignación de valores al objeto
69 persona.setNombre("Linus");
70 persona.setApellido("Torvals");
71 persona.setDocumento("777");
72 persona.setPeso(80);
73 persona.setOjos("Azul");
74 persona.setSexo('M');
75
76 // instancia de la clase persona
77 Persona otraPersona = new Persona();
78
79 // asignación de valores al objeto
80 otraPersona.setNombre("Winona");
81 otraPersona.setApellido("Raider");
82 otraPersona.setDocumento("666");
83 otraPersona.setPeso(65);
84 otraPersona.setOjos("Marrones");
85 otraPersona.setSexo('F');
86
87 // listado
88 System.out.println("La primer persona es: " + persona.getNombre() + " " + persona.getApellido());
89 System.out.println("La segunda persona es: " + otraPersona.getNombre() + " " + otraPersona.getApellido());
90 }
91 }
Visual Basic .Net
1 Public Class Persona
2
3 ' lista de atributos que la definen
4 Private _Nombre As String
5 Private _Apellido As String
6 Private _Documento As String
7 Private _Peso As Integer
8 Private _Ojos As String
9 Private _Sexo As Char
10
11 Public Property Nombre() As String
12 Get
13 Return _Nombre
14 End Get
15 Set(ByVal value As String)
16 _Nombre = value
17 End Set
18 End Property
19
20 Public Property Apellido() As String
21 Get
22 Return _Apellido
23 End Get
24 Set(ByVal value As String)
25 _Apellido = value
26 End Set
27 End Property
28 Public Property Documento() As String
29 Get
30 Return _Documento
31 End Get
32 Set(ByVal value As String)
33 _Documento = value
34 End Set
35 End Property
36 Public Property Peso() As String
37 Get
38 Return _Peso
39 End Get
40 Set(ByVal value As String)
41 _Peso = value
42 End Set
43 End Property
44 Public Property Ojos() As String
45 Get
46 Return _Ojos
47 End Get
48 Set(ByVal value As String)
49 _Ojos = value
50 End Set
51 End Property
52 Public Property Sexo() As String
53 Get
54 Return _Sexo
55 End Get
56 Set(ByVal value As String)
57 _Sexo = value
58 End Set
59 End Property
60
61 Public Sub Mostrar()
62 ' instancia de la clase persona
63 ' el nombre del objeto debe ser distinto que el nombre de su clase,
64 ' puede tener cualquiera que queramos
65 Dim persona As Persona = New Persona
66
67 ' asignación de valores al objeto
68 persona.Nombre = "Linus"
69 persona.Apellido = "Torvals"
70 persona.Documento = "777"
71 persona.Peso = 80
72 persona.Ojos = "Azul"
73 persona.Sexo = "M"
74
75 ' instancia de la clase persona
76 Dim otraPersona As Persona = New Persona
77
78 ' asignación de valores al objeto
79 otraPersona.Nombre = "Winona"
80 otraPersona.Apellido = "Raider"
81 otraPersona.Documento = "666"
82 otraPersona.Peso = 65
83 otraPersona.Ojos = "Marrones"
84 otraPersona.Sexo = "F"
85
86 ' listado
87 Debug.WriteLine("La primer persona es: " + persona.Nombre + " " + persona.Apellido)
88 Debug.WriteLine("La segunda persona es: " + otraPersona.Nombre + " " + otraPersona.Apellido)
89 End Sub
90
91 End Class
Programación Orientada a Objetos: Constructores y Sobrecarga

La última entrega sobre POO fue ya unos meses atrás y hablábamos de los Setters y Getters, hoy
tocaremos un tema sencillo también que son los Constructores de Clases. Ya que tocamos el tema
aprovecharemos para saber que son las sobrecargas y como se usan (también los utilizaremos cuando
veamos los métodos).

El fin de un constructor es asignar “obligar” a asignar valores a los atributos de nuestra clase, al
momento de ser instanciado. Aunque si vamos por el sentido estricto de la programación podríamos
escribir casi cualquier código allí dentro pero no es recomendable. Un constructor debe tener definido
su alcance (en la mayoría de los casos será public) y no debe retornar ningún tipo de valor incluyendo
en void. Además que debe tener el mismo nombre que su clase. Es muy común agregar validaciones
dentro de los constructores, es uno de los lugares donde se escribirá una sola vez así como en los
setters y getters.

También notaremos que una clase puede tener más de un constructor, eso es lo que conocemos por
sobrecarga de constructores. Todos tienen el mismo nombre pero necesariamente deben variar en la
cantidad, orden y tipos de datos que reciban (al menos en uno de ellos debe haber una variante para
poder identificar cual se ejecutará). Siguiendo con el código anterior agregaremos constructores a los
Setters y Getters que teníamos.
JAVA
1 package devtroce;
2
3 public class Persona {
4
5 // lista de atributos que la definen
6 private String Nombre;
7 private String Apellido;
8 private String Documento;
9 private int Peso;
10 private String Ojos;
11 private char Sexo;
12
13 // Constructores
14
15 public Persona() {
16 this.setNombre("");
17 this.setApellido("");
18 this.setDocumento("");
19 this.setPeso(0);
20 this.setOjos("");
21 this.setSexo('');
22 }
23
24 public Persona(String Nombre, String Apellido, String Documento, int Peso, String Ojos, char Sexo) {
25 this.setNombre(Nombre);
26 this.setApellido(Apellido);
27 this.setDocumento(Documento);
28 this.setPeso(Peso);
29 this.setOjos(Ojos);
30 this.setSexo(Sexo);
31 }
32
33 public Persona(int Peso, String Nombre, String Apellido, String Documento, String Ojos, char Sexo) throws
34 Exception {
35 if (Peso < 0)
36 throw new Exception("No se admiten peso menores a 0");
37 this.setNombre(Nombre);
38 this.setApellido(Apellido);
39 this.setDocumento(Documento);
40 this.setPeso(Peso);
41 this.setOjos(Ojos);
42 this.setSexo(Sexo);
43 }
44
45 public Personal(String Nombre, String Apellido, String Documento) {
46 this.setNombre(Nombre);
47 this.setApellido(Apellido);
48 this.setDocumento(Documento);
49 this.setPeso(0);
50 this.setOjos("");
51 this.setSexo('');
52 }
53
54 public String getApellido() {
55 return Apellido;
56 }
57
58 public void setApellido(String Apellido) {
59 this.Apellido = Apellido;
60 }
61
62 public String getDocumento() {
63 return Documento;
64 }
65
66 public void setDocumento(String Documento) {
67 this.Documento = Documento;
68 }
69
70 public String getNombre() {
71 return Nombre;
72 }
73
74 public void setNombre(String Nombre) {
75 this.Nombre = Nombre;
76 }
77
78 public String getOjos() {
79 return Ojos;
80 }
81
82 public void setOjos(String Ojos) {
83 this.Ojos = Ojos;
84 }
85
86 public int getPeso() {
87 return Peso;
88 }
89
90 public void setPeso(int Peso) {
91 this.Peso = Peso;
92 }
93
94 public char getSexo() {
95 return Sexo;
96 }
97
98 public void setSexo(char Sexo) {
99 this.Sexo = Sexo;
100 }
101
102 // método para poder ejecutar la clase en Java (irrelevante para el concepto estudiado)
103 public static void main(String[] args) throws Exception{
104 // instancia de la clase persona
105 // el nombre del objeto debe ser distinto que el nombre de su clase,
106 // puede tener cualquiera que queramos
107 Persona persona = new Persona();
108 // asignación de valores en el constructor
109 Persona otraPersona = new Persona("Winona", "Raider", "666", 65, "Marrones", 'F');
110
111 // asignación de valores al objeto
112 persona.setNombre("Linus");
113 persona.setApellido("Torvals");
114 persona.setDocumento("777");
115 persona.setPeso(80);
116 persona.setOjos("Azul");
117 persona.setSexo('M');
118
119 // listado
120 System.out.println("La primer persona es: " + persona.getNombre() + " " + persona.getApellido());
121 System.out.println("La segunda persona es: " + otraPersona.getNombre() + " " + otraPersona.getApellido());
122 }
123 }
Visual Basic .Net
1 Public Class Persona
2
3 ' lista de atributos que la definen
4 Private _Nombre As String
5 Private _Apellido As String
6 Private _Documento As String
7 Private _Peso As Integer
8 Private _Ojos As String
9 Private _Sexo As Char
10
11 ' Si no se incluye el parámetro
12 Public Sub New()
13 ' MyBase.New() siempre debe estar en el constructor
14 MyBase.New()
15 End Sub
16
17 Public Sub New(ByVal Nombre As String, ByVal Apellido As String, ByVal Documento As String, ByVal Peso As Integer,
18 ByVal Ojos As String, ByVal Sexo As Char)
19 ' MyBase.New() siempre debe estar en el constructor
20 MyBase.New()
21
22 _Nombre = Nombre
23 _Apellido = Apellido
24 _Documento = Documento
25 _Peso = Peso
26 _Ojos = Ojos
27 _Sexo = Sexo
28 End Sub
29
30 Public Sub New(ByVal Peso As Integer, ByVal Apellido As String, ByVal Documento As String, ByVal Nombres As
31 String, ByVal Ojos As String, ByVal Sexo As Char)
32 ' MyBase.New() siempre debe estar en el constructor
33 MyBase.New()
34 If Peso < 0 Then
35 Throw New Exception("El peso no debe ser menor a 0")
36 End If
37 _Nombre = Nombre
38 _Apellido = Apellido
39 _Documento = Documento
40 _Peso = Peso
41 _Ojos = Ojos
42 _Sexo = Sexo
43 End Sub
44
45 Public Sub New(ByVal Nombre As String, ByVal Apellido As String, ByVal Documento As String)
46 ' MyBase.New() siempre debe estar en el constructor
47 MyBase.New()
48
49 _Nombre = Nombre
50 _Apellido = Apellido
51 _Documento = Documento
52 _Peso = 0
53 _Ojos = ""
54 _Sexo = ""
55 End Sub
56
57 Public Property Nombre() As String
58 Get
59 Return _Nombre
60 End Get
61 Set(ByVal value As String)
62 _Nombre = value
63 End Set
64 End Property
65
66 Public Property Apellido() As String
67 Get
68 Return _Apellido
69 End Get
70 Set(ByVal value As String)
71 _Apellido = value
72 End Set
73 End Property
74 Public Property Documento() As String
75 Get
76 Return _Documento
77 End Get
78 Set(ByVal value As String)
79 _Documento = value
80 End Set
81 End Property
82 Public Property Peso() As String
83 Get
84 Return _Peso
85 End Get
86 Set(ByVal value As String)
87 _Peso = value
88 End Set
89 End Property
90 Public Property Ojos() As String
91 Get
92 Return _Ojos
93 End Get
94 Set(ByVal value As String)
95 _Ojos = value
96 End Set
97 End Property
98 Public Property Sexo() As String
99 Get
100 Return _Sexo
101 End Get
102 Set(ByVal value As String)
103 _Sexo = value
104 End Set
105 End Property
106
107 Public Sub Mostrar()
108 ' instancia de la clase persona
109 ' el nombre del objeto debe ser distinto que el nombre de su clase,
110 ' puede tener cualquiera que queramos
111 Dim persona As Persona = New Persona
112
113 ' asignación de valores al objeto
114 persona.Nombre = "Linus"
115 persona.Apellido = "Torvals"
116 persona.Documento = "777"
117 persona.Peso = 80
118 persona.Ojos = "Azul"
119 persona.Sexo = "M"
120
121 ' instancia de la clase persona
122 Dim otraPersona As Persona = New Persona("Winona", "Rider", "666", 65, "Marrones", Convert.ToChar("F"))
123
124 ' listado
125 Debug.WriteLine("La primer persona es: " + persona.Nombre + " " + persona.Apellido)
126 Debug.WriteLine("La segunda persona es: " + otraPersona.Nombre + " " + otraPersona.Apellido)
127 End Sub
128
129 End Class