En la programación se utilizan CLASES y OBJETOS como entidades principales. Si bien ese paradigma de programación se llama "Orientación a Objetos", creo que es mejor empezando por las clases para explicarlo.
¿QUÉ ES UNA CLASE?
Una clase es una definición de las características y funciones de algo.
Por ejemplo puedo decir que para establecer la clase "Persona", yo defino que debo indicar el nombre, edad, fecha de nacimiento, etc. (son características, que llamaremos ATRIBUTOS) y que debe cumplir ciertas acciones (las FUNCIONES o MÉTODOS), por ejemplo que pueda contestar que nombre tiene o que edad tiene.
Asi, deberiamos definir la clase Persona:
Para eso tenemos una palabra reservada que es la palabra "class". Una "PALABRA RESERVADA" en programación es una palabra o conjunto de palabras que indican algo en el programa, deben escribirse exactamente igual (en éste caso, "clas" en vez de "class" no funcionaría) y no pueden usarse para otra cosa (en vez de definir la clase "Persona", podemos definir la clase "pirulo", "xxxx", etc pero no podemos definir la clase "Class" ni ninguna con palabras reservadas para el lenguaje).
Una clase puede ser PÚBLICA o PRIVADA.
Pública significa que la clase puede ser "vista" (es decir que su parte interna puede accederse) desde cualquier parte de un programa.
Privada significa que los "componentes" de la clase solo pueden usarse dentro de la clase.
(la diferencia de ésto lo veremos mejor mas adelante)
Ponemos:
public class Persona { }
Eso significa que declaramos la clase "Persona" como clase pública y después abrimos y cerramos llaves, la definición de esa clase estará dentro de las llaves (como si fueran los paréntesis que indican que términos están alcanzados en una ecuación matemática, cada vez que abrimos, debemos cerrar, y las abiertas adentro son subpartes de lo abierto mas afuera).
Hasta acá tenemos una cáscara vacía. Solo dijimos que existe un tipo de objetos que llamamos "Personas".
Debe aclararse que la "Clase" en programación no es el conjunto. Es decir que la clase "Persona" no es el conjunto de todas las personas, es la "definición" de que es una persona en el programa, dice que atributos tiene y que funciones puede usar. La clase, como es el definidor, no es una persona en particular, es el "molde" con el que construiremos personas.
PROPIEDADES O ATRIBUTOS
Ahora vamos a definir las características de "Persona" que nos interesan.
public class Persona {
//Propiedades
private String name;
private String lastName;
private String birthDate;
private int age;
private String gender;
}Analizando lo que escribimos:
La doble barra diagonal "//" se usa para poner comentarios, aclaraciones, titulos, etc.
Esa doble barra le indica a la computadora que lo que sigue no debe intentar ejecutarlo, son comentarios y no parte del programa.
Después definimos los atributos de la persona.
Cada atributo definimos si va a ser público o privado y el tipo de atributo que es, luego el nombre del atributo y terminamos con un punto y coma.
Asi en la primera sentencia ponemos que es privado, tipo "String" y que se llamará "Name".
Tipo: los tipos indican que se puede guardar dentro de ese atributo, Nombres de una persona pueden ser "Sofía", "Sara", "Simón", "Marcela", etc. por lo tanto lo ponemos como tipo "string", que significa una cadena de caracteres de cualquier tipo, podría ser "904" o "**;;/x", pero en el caso de 904, no lo toma como número, sino como un literal, como caracteres. El tipo "Int" significa número entero, es decir 14, 19, 21, 54, 108, etc lo toma como número pero no permite decimales.
Los nombres de los atributos se suelen poner en inglés (para facilitar que lo lean y entiendan en una empresa gente de otros países), se empiezan con minúscula y si se necesitan mas de una palabra para decir que es, se juntan (el espacio indica que se terminó el nombre del atributo) y para poder leerlo mejor se pone en mayúscula el inicio de cada palabra, por ejemplo "motherLastName". Esas son reglas de buena programación, pero nada impide no cumplirlas y llamar a los atributos de otra forma, por ejemplo llamar "XPQrrM", "Edad", "eDAD", "alter" (edad en alemán), "name"o "gender" a la edad de una persona, pero un tiempo después al leer el programa se complica recordar que significaba realmente ese atributo.
Bueno, hasta acá sabemos que tenemos una clase que describe una persona, y que una persona para nosotros tiene cinco características o atributos, que son representados por las VARIABLES name, lastname, birthDate, age y gender. Se llaman variables a los nombres seleccionados para representar los atributos, son "espacios" donde vamos a guardar los atributos. Por ejemplo puedo guardar "Sofía", "Sara" o "Simón" en name y puedo cambiarlos en cualquier momento, son variables.
Como ven, la descripción de los atributos o propiedades de la clase se hacen dentro de las llaves que pusimos al principio.
MÉTODO O FUNCIÓN CONSTRUCTOR
DLa clase es, como dijimos, una definición, no genera los objetos con los que vamos a trabajar. Asi que tenemos la clase "Persona" que es la descripción de las características y métodos que tendran esas entidades en el programa. Se llama INSTANCIA a la particularización de la clase, es decir que ya no hablamos de la clase "Persona", hablamos de una persona en particular, asi Sofía, Sara o Simón son diferentes instancias de la clase "Persona". Le decimos objeto, cuando hablamos de una instancia pero sin definir cual, asi podemos decir que la clase "Persona" tiene instanciados 3 objetos, la instancia "Sofía", la instancia "Sara" y la instancia "Simón".
Dentro de la clase, tenemos que definir el método que genera las instancias, es decir como construimos "Sofía", "Sara" o "Simón" a partir de la clase "Persona".
public class Persona {
//Propiedades
private String name;
private String lastName;
private String birthDate;
private int age;
private String gender;
//Constructor
public persona(String nameObject, String lastNameObject, String birthDateObject, int ageObject, String genderObject) {
name = nameObject;
lastName = lastNameObject;
birthDate = birthDateObject;
age = ageObject;
gender = genderObject;
}
}El símbolo igual se lee como una asignación, como si fuese una flecha hacia la izquierda, lo escrito se lee "cuando se reciba un valor en nameObject, se asignará a name, generando una instancia de la clase Persona, con ese valor y los siguientes recibidos".
Fijense que al terminar los parámetros abrimos una llave que cerramos después de "genderObject;" eso indica que parte del código define el método constructivo.
Esto define el método o función que generará una persona, entre paréntesis vemos una serie de entidades separadas por coma, se llaman PARÁMETROS, los parámetros son valores que se mandarán desde otra parte del progrma para instanciar la clase.
Asi que si en otra parte del programa ponemos:
Persona("Ana Sofía", "Alonso Carra", "15/02/1997", 21, "Femenino"), lo que sucede es que el constructor genera una instancia con esos datos que a partir de ese momento (ahora veremos como) puede usar los métodos definidos en la clase para esa instancia en particular.
Para usar esa instancia la debemos asignar a una variable, la llamamos Hijo1. Recordar que la asignación se hace con el símbolo igual, el igual debe leerse como si fuese una flecha a la izquierda, o sea que:
Persona Hijo1 = new Persona("Ana Sofía", "Alonso Carra", "15/02/1997", 21, "Femenino");
Se lee como "a Hijo1 se le ha asignado una instancia de la clase Persona, con los datos "Ana Sofía",...,etc"
La sintaxis es Clase Instancia = New Método Constructor
La palabra reservada "new" lo que indica es que vamos a instanciar la clase "Persona"
Lo que ha pasado es que la cadena alfabética "Ana Sofía" ha ingresado como valor de la variable nameObject y la variable name Object se asignó a la variable "name" de la clase "Persona" generando una particularización de esa clase (instancia). Lo mismo ha pasado con el resto de los valores (vease que el valor 21, por ser numérico, no está entre comillas).
MÉTODOS O FUNCIONES
Supongamos que ahora queremos que, dada una persona en particular, nos diga cual es su apellido y otra función que nos devuelva si es o no mayor de edad la persona en cuestión.
Entonces agregamos el siguiente código a la clase para el primer método (el otro método es mas complejo y lo retomaremos más adelante)
public class Persona {
//Propiedades
private String name;
private String lastName;
private String birthDate;
private int age;
private String gender;
//Constructor
public persona(String nameObject, String lastNameObject, String birthDateObject, int ageObject, String genderObject) {
name = nameObject;
lastName = lastNameObject;
birthDate = birthDateObject;
age = ageObject;
gender = genderObject;
}
//Métodos
public String getLastName() {
return lastName;
}
}
El método es simple, no tiene parámetros (fijense en los dos paréntesis sin nada en el medio) y dice que al ser pedido devuelve (return que es una palabra reservada) el valor de la variable lastName, terminando con punto y coma (todo entre las llaves correspondientes para indicar donde empieza y termina el método).
La variable Hijo1, que instanciamos antes, es una "bolsa" que tiene todos los datos y permite todos los métodos que definimos en la clase Persona. Asi como el número 14, por ejemplo, es una instancia de los "números naturales" y con el 14 podemos hacer cualquier operación (suma, resta, división, multiplicación, raíz, etc) que está definida para cualquier natural, con Hijo1 podemos hacer cualquier operación que esté definida para Persona. Pero como Persona puede tener varios métodos, ¿como le decimos cual método queremos usar en Hijo1?. Simple, ponemos un punto y a continuación el nombre del método. En éste caso ponemos:
Hijo1.getLastName();
Si eso lo asignamos (con el símbolo igual) a una variable que llamamos Apellido1, queda de la siguiente manera:
Apellido1 = Hijo1.getLastName();
Entonces Hijo 1 tiene todos los datos y funciones posibles de la clase Persona, mientras que Apellido1 tiene "Alonso Carra", es decir solamente el apellido de Hijo1. Mientras que Hijo1 es un objeto de la clase Persona, Apellido1 es una variable de tipo string.
Por ejemplo podría tener Hijo2, una instancia con otros datos y después preguntar si Apellido1 es igual a Apellido2 de Hijo2 (habiendo asignado previamente el apellido de Hijo2 a esa variable) o si son distintos.
ÁRBOL DE CLASES
Las clases pueden tener subclases y clases contenedoras (superclases). Muchas clases ya vienen en el lenguja, ya definidas y diseñadas. Es decir que tenemos clases qye armamos nosotros y clases que usamos. Por ejemplo la clase Printf que viene dada por el lenguaje permite mostrar en pantalla un valor pasado a la clase como parámetro. Es decir que printf(pirulo) mostrará en la pantalla el valor que tiene pirulo en ése momento del programa.
Supongamos que nuestra clase Persona tiene un método getName (no getLastName, que fue el que hicimos) que devuelve el nombre de la persona, si hacemos,
Printf(Hijo1.getName());
en la pantalla aparecerá "Ana Sofía" o si hacemos,
namePrint = Hijo1.getName();
Printf(namePrint);
en la pantalla aparecerá "Ana Sofía" igual
La diferencia es que en el primero lo hicimos juntos y en el segundo mas desmenuzado.
Pero Printf es una clase que viene dada por el lenguaje y esas clases se "empaquetan" en diferentes bibliotecas (muchas veces llamadas "librerias" en muchos textos, lo que es una mala traducción de library) de clases. Como dos clases de diferentes bibliotecas podrían tener el mismo nombre y para simplificar donde buscarlas, se le indica al programa donde encontrar la clase que se quiere usar.
Asi que la primera sentencia que pusimos se escribe, en realidad:
System.out.Printf(Hijo1.getName());
lo que significa que a la biblioteca System a la clase out en la subclase Printf la instanciamos con el parámetro sacado de la instancia Hijo1 de la clase Persona con el método getName.
Es decir que el punto separa tanto una clase de su superclase o subclase como una clase del método invocado.
Entonces supongamos que hicimos tres variables: Hijo1, Hijo2 e Hijo3, de la siguiente manera:
Persona Hijo1 = new Persona("Ana Sofía", "Alonso Carra", "15/02/1997", 21, "Femenino");
Persona Hijo2 = new Persona("Sara Inés", "Alonso Carra", "16/07/1999", 19, "Femenino");
Persona Hijo3 = new Persona("Simón", "Alonso Carra", "06/09/2000", 18, "Masculino");
Si hacemos,
namePrint = Hijo1.getName();
System.out.Printf(namePrint);
namePrint = Hijo2.getName();
System.out.Printf(namePrint);
namePrint = Hijo3.getName();
System.out.Printf(namePrint);
aparecerían "Ana Sofía", "Sara Inés" y "Simón" ya que aunque imprimimos en pantalla la misma variable, le fuimos asignando valores distintos en el medio.
System.out.Printf(Hijo1.getName());
System.out.Printf(Hijo2.getName());
System.out.Printf(Hijo3.getName());
daría el mismo resultado.
CONCLUSIONES
Es una primera aproximación a clases y objetos que son el nudo central de la programación, en mas de una vez dijimos "en otra parte del programa", podemos decir que dentro de un programa tenemos una parte "declarativa" donde definimos las clases que vamos a usar y otra parte "ejecutiva" donde instanciamos y usamos esas instancias para hacer el programa. Eso lo vamos a ir viendo de a poco.
No hay comentarios:
Publicar un comentario