Download Descripción de las clases, los objetos y cómo se relacionan, paso

6 -Descripción de las clases, los objetos y cómo se relacionan, paso
de mensaje
Programación Orientada a Objetos
Proyecto Curricular de Ingeniería de Sistemas
Descripción de las clases, los objetos y cómo se relacionan.
Como dicta el titulo de este punto un objeto es precisamente eso: "Una
clase en movimiento". Podemos ver la relación entre clase y objeto de este
modo.
Supongamos por ejemplo una clase llamada "Mamífero". Como en la "vida
misma" tu te puedes encontrar por la calle con "Personas", "Perros",
"Gatos" ... que evidentemente pertenecen a esa clase "Mamífero", pero no
te
vas
a
encontrar
con
un
"Mamífero"
a
secas.
Más o menos esa es la relación entre clase y objeto. Una clase es una
especificación de cómo debe ser un objeto para pertenecer a esa clase y
por consiguiente un objeto es un ejemplar individual de una clase.
Tomando como ejemplo nuestra clase "Fichas" vemos que todas las fichas
tienen que tener un color como característica que la defina. Es decir,
nuestros
objetos
"ficha"
serán
fichas
blancas,
negras,
etc.
A la hora de "actuar" por tanto se hará sobre un objeto en concreto. En un
objeto se puede acceder a sus métodos y a las variables miembro que
tenga, siempre claro que sean ambos declarados en la clase como
accesibles.
La accesibilidad para métodos y variables depende en primera instancia de
la accesibilidad a la clase a la que pertenecen. Si la clase nos es accesible
entonces
depende
en
segunda
instancia
de
estas
normas:
Accesibilidad de variables y métodos: depende de los siguientes
modificadores de acceso que se ponen (o no) delante de la variable en su
declaración o del método en su definición.
•
•
•
•
"public": Da accesibilidad completa a la variable, se puede ver desde
la propia clase, dentro y fuera del mismo "package" y en cualquier
"subclase" de la clase en la que se declara, ya esté en el mismo o en
distinto "package".
"protected": Se puede acceder desde la propia clase, desde el
mismo "package" y desde cualquier "subclase", pero no se puede
ver desde una clase de otro "package".
"private": Solo se puede acceder desde la propia clase.
"package": Es la opción por defecto (como si no se pone nada).
Proporciona accesibilidad desde el propio "package" y por tanto
lógicamente desde la propia clase y además desde cualquier
subclase que esté dentro del mismo "package".
Una vez tenemos claros las normas acerca de la accesibilidad en Java,
veamos unos ejemplos de utilización de los objetos en Java.
Descripción de los objetos. Cómo crearlos o instanciarlos a partir de
las clases y su utilización.
Lo primero que hay que hacer para utilizar un objeto es tenerlo ¿no?. Pues
vamos a entender primero cómo se crean los objetos para después pasar a
utilizarlos.
Instanciación de objetos:
Para instanciar un objeto el método que se utiliza es "new". "New" crea un
objeto de la clase que le especifiquemos pero antes de esto se tiene que
declarar la variable que contendrá ese nuevo objeto. Veámoslo en nuestra
clase Tablero vista anteriormente.
Fichas estadoTablero[][];
public Tablero(){estadoTablero=new Fichas [6][7];};
En estas dos líneas se engloba todo el mecanismo de creación de un objeto.
En la primera línea se declara una variable "estadoTablero" de la clase
"array". La clase "array" es una clase utilitaria de Java que esta incluida en
"Java.lang" y por lo tanto, como ya se comento una vez y se explicará
mejor mas adelante, se encuentra disponible desde cualquier programa en
Java.
En principio esta variable está vacía, no contiene ningún objeto, pero está
"preparada" para contener un objeto de la clase "array".
En la segunda línea de este código hay mas que comentar: Se trata de la
definición de un constructor sencillo para la clase "Tablero".
Cuando se ejecuta una sentencia "new" para crear un objeto de una clase,
lo que realmente se hace es llamar al método constructor correspondiente a
esa clase. Por ejemplo si ejecutamos esta sentencia:
Tablero miTablero = New Tablero();
Estamos llamando al método anterior:
public Tablero(){estadoTablero=new Fichas [6][7];};
Por tanto lo que conseguimos es crear la variable interna de "Tablero", que
hemos llamado "estadoTablero" como un objeto "array" de dimensiones 6x7
que son las dimensiones de un tablero de "cuatro en raya". Como vemos,
igual que con nuestra clase tablero y cualquier otra clase, también usamos
"new" para crear el "array".
Por último, y como puedes comprobar, para definir un constructor para la
clase simplemente definimos un método que como peculiaridad tiene el
mismo nombre de la clase en la que se define. En cuanto a su modificador
de acceso lo normal es que sea "public", pero puede ser también "private"
en cuyo caso solo será accesible desde un método "static" de la misma
clase.
Paso de mensajes:
Como "paso de mensajes" se entiende en programación orientada a objetos
lo que siempre hemos llamado en programación tradicional: "llamada a una
función". En el fondo si nos ponemos a pensar vemos básicamente que:
•
•
•
•
En primer lugar: Los programas "sobre el papel" son las clases.
En segundo lugar: Las clases "sobre papel" se relacionan con otras
clases. Por ejemplo nuestra clase Ficha utiliza para definir su
parámetro "color" a la clase "String" propia de Java.
En tercer lugar: En la "vida real", es decir, en funcionamiento, las
clases se muestran como "objetos".
Como conclusión: Son los objetos los que colaboran y se relacionan
con otros objetos, y lo hacen mediante el "paso de mensajes".
Para ejecutar un método de una clase se utiliza esta sintaxis:
NombreDeLaClase.nombreDelMetodo(parámetros del método);
Los pasos de mensajes tienen una ventaja con respecto a las llamadas a
función de los lenguajes tradicionales. La ventaja es que siempre llevan un
parámetro implícito: El objeto al que pertenece el propio método. Lo vemos
con un ejemplo muy sencillo.
Imaginamos un método y una función que simplifican una fracción pasada
como parámetro. La diferencia seria la siguiente al utilizar tanto el método
como la función.
Programación tradicional:
fraccion_simp = simplifica_fraccion(fraccion);
/*fraccion_simp guarda el resultado
de aplicar la función simplifica_fraccion
al parámetro fraccion*/
Programación orientada a objetos:
ObjetoFraccion.simplificaFraccion();
/*este caso lo podríamos entender como que
simplemente le decimos a la fracción que se
simplifique a ella misma "como ella sabe" */
Como vemos en Programación orientada a objetos no se pasa como
parámetro la fracción a simplificar puesto que es el mismo objeto el que es
la fracción y el que a su vez posee el método para simplificarla de acuerdo
con sus atributos internos.
Acceso a variables internas de un objeto:
Para acceder a una variable interna de un objeto esta nos tiene que ser
accesible según las normas vistas anteriormente. En caso de que si
simplemente podemos acceder a ella con la siguiente sintaxis:
NombreDeLaClase.nombreDeVariableInterna;
Por ejemplo supongamos que creamos un objeto de tipo ficha y se accederá al atributo color
de ficha desde la clase tablero (para este caso Ficha y tablero deben estar e el mismo paquete)
public class Tablero{
Ficha objFicha;
public void metodoEjemplo{
objFicha.color = “Azul”;
System.out.println(objFicha.color);
}
}
La referencia de variables y métodos con this:
En Java la palabra reservada this se usa para acceder a variables y
métodos del mismo objeto (ya creado) para facilitar la programación. This
no se puede usar con llamadas static de métodos.
public class Fecha
{
private int dia, mes anio:
public void manana(){
this.dia = this.dia + 1;
}
}
En este código resulta redundante el uso del this, pero puede entenderse
que this.dia es la variable de la clase. En el siguiente ejemplo se fija un
número de día pasando al método fijaDia().
public class Fecha{
private int dia, mes, anio;
public void fijaDia(int dia){
this.dia = dia;
}
}
Este ejemplo es completamente valido y legal, ya que el primer elemento
de la asignación se refiere a la variable de la clase, y el segundo elemento
de la asignación al parámetro del método fijaDia.
Ahora se vera un ejemplo que utilice lo hasta ahora visto:
import java.applet.Applet;
import java.awt.*;
import java.awt.event.*;
public class JugarGlobo extends Applet
implements ActionListener {
private Button agrandar, reducir;
private Globo miGlobo;
public void init() {
agrandar = new Button ("Agrandar");
add (agrandar);
agrandar.addActionListener(this);
reducir = new Button ("Reducir");
add (reducir);
reducir.addActionListener(this);
miGlobo = new Globo (20, 50, 50);
}
public void actionPerformed(ActionEvent event) {
if (event.getSource() == agrandar)
miGlobo.cambiarTamaño(10);
if (event.getSource() == reducir)
miGlobo.cambiarTamaño(-10);
repaint();
}
public void paint (Graphics g) {
miGlobo.mostrar(g);
}
}
import java.awt.*;
class Globo{
private int diametro;
private int xCoord, yCoord;
public Globo (int diametroInicial, int xInicial, int yInicial) {
diametro = diametroInicial;
xCoord = xInicial;
yCoord = yInicial;
}
public void cambiarTamaño (int cambio) {
diametro = diametro + cambio;
}
public void mostrar (Graphics g) {
g.drawOval (xCoord, yCoord, diametro, diametro);
}
}
A continuación se visualiza la vista de paquetes que provee elipse.
Y la siguiente figura visualiza la aplicación una vez ejecutada:
Para el Lector:
Como ejercicio practico visualice la forma en que en el explorador de paquetes eclipse marca
las características de las clases, atributos métodos, de color son las clases, que pasa cundo
algo es estático, cundo es privado etc.