|
PROGRAMACION EN JAVA |
|
Objetos
En informática, un OBJETO es un conjunto de variables y de los métodos relacionadoscon esas variables. Los principios de la definición de objetos ayudan a los programadores a hacer código más robusto, mantenible y seguro; porque se pueden aislar a cada uno de esos objetos y tratarlo como un ente único, con su propia personalidad, sin que haya cientos de características que tengamos que tener presentes, tal como se hacía en la programación orientada a procedimiento.
A continuación se muestran algunas de las propiedades que se pueden aplicar a los objetos, tal como se han definido:
Casi todo puede ser considerado un objeto. El dinero, el helicóptero, una bicicleta, los perros, el automóvil. Los objetos representan cosas, simples o complejas, reales o imaginarias. Una antena parabólica es un objeto complejo y real. Un objeto Profesor, representa los detalles y actividades de una persona, no es esa persona en sí misma, es pues, imaginario. Una frase, un número complejo, una receta y una cuenta bancaria también son representaciones de cosas intangibles. Todas son objetos.
Algunas cosas no son objetos, sino atributos, valores o características de objetos. Es decir, no todas las cosas son objetos, ni son consideradas normalmente como objetos. Algunas de ellas son simplemente atributos de los objetos como el color, el tamaño y la velocidad. Los atributos reflejan el estado de un objeto, la velocidad del objeto avión, o el tamaño de un objeto edificio. Normalmente no tiene sentido considerar la velocidad como un objeto.
Abstracción Funcional
Muchas veces existen eventos o actividades propias del objeto, es decir las cosas que se sabe que el objeto hace, pero no se sabe como lo hace, es decir, no sabemos como está implementado ese evento. Para esto es que utilizamos la abstracción funcional, de manera que nos preocupemos por identificar los eventos, para luego ver como implementarlos
Similarmente, también existen características propias de un objeto, y para identificarlas, nos valemos de la llamada abstracción de datos, es decir cosas que sabemos que son parte del objeto que modelamos.
Es el término de orientación a objetos que describe la vinculación de unas operaciones y estado a un objeto particular. La encapsulación está íntimamente relacionada con la ocultación de la información, definiendo qué partes de un objeto son visibles y qué partes están ocultas.
La encapsulación abarca a la ocultación de la información:
Algunas partes son visibles (el interfaz público)
Otras partes son ocultas (o privadas)
También se fomenta la reusabilidad, ya que el código puede ser utilizado como una tecnología de caja negra (igual que los circuitos integrados en la industria electrónica). Y si se vuelve a pensar desde el punto de vista económico, esto viene a representar una ventaja de indudable valor
Niveles de Acceso
El nivel de acceso más restringido es 'private'. Un miembro privado es accesible sólo para la clase en la que está definido. Se utiliza este acceso para declarar miembros que sólo deben ser utilizados por la clase. Esto incluye las variables que contienen información que si se accede a ella desde el exterior podría colocar al objeto en un estado de inconsistencia, o los métodos que llamados desde el exterior pueden poner en peligro el estado del objeto o del programa donde se está ejecutando. Los miembros privados son como secretos, nunca deben contarseles a nadie. Para declarar un miembro privado se utiliza la palabra clave private en su declaración. La clase siguiente contiene una variable miembro y un método privados.
class Alpha {
private int soyPrivado;
private void métodoPrivado() {
System.out.println("métodoPrivado");
}
}
Los objetos del tipo Alpha pueden inspeccionar y modificar la variable soyPrivado y
pueden invocar el método métodoPrivado(), pero los objetos de otros tipos no pueden
acceder. Por ejemplo, la clase Beta definida aquí.
class Beta {
void métodoAccesor() {
Alpha a = new Alpha();
a.soyPrivado = 10; // ilegal
a.métodoPrivado(); // ilegal
}
}
no puede acceder a la variable soyPrivado ni al método métodoPrivado() de un objeto del
tipo Alpha porque Beta no es del tipo Alpha.
Si una clase está intentando acceder a una variable miembro a la que no tiene acceso--el
compilador mostrará un mensaje de error similar a este y no compilará su programa.
Beta.java:9: Variable iamprivate in class Alpha not accessible from class Beta. a.iamprivate = 10; // ilegal ^ 1 errorY si un programa intenta acceder a un método al que no tiene acceso, generará un error de compilación parecido a este.
Beta.java:12: No method matching privateMethod() found in class Alpha. a.privateMethod(); // ilegal 1 error
El siguiente especificador de nivel de acceso es 'protected' que permite a la propia clase, las subclases (con la excepción a la que nos referimos anteriormente), y todas las clases dentro del mismo paquete que accedan a los miembros. Este nivel de acceso se utiliza cuando es apropiado para una subclase de la clase tener acceso a los miembros, pero no las clases no relacionadas. Los miembros protegidos son como secretos familiares - no importa que toda la familia lo sepa, incluso algunos amigos allegados pero no se quiere que los extraños lo sepan. Para declarar un miembro protegido, se utiliza la palabra clave protected. Primero echemos un vistazo a cómo afecta este especificador de acceso a las clases del mismo paquete. Consideremos esta versión de la clase Alpha que ahora se declara para estar incluida en el paquete Griego y que tiene una variable y un método que son miembros protegidos.
package Griego;
class Alpha {
protected int estoyProtegido;
protected void métodoProtegido() {
System.out.println("métodoProtegido");
}
}
Ahora, supongamos que la clase Gamma, también está declarada como miembro del paquete Griego (y no es una subclase de Alpha). La Clase Gamma puede acceder legalmente al miembro estoyProtegido del objeto Alpha y puede llamar legalmente a su método métodoProtegido().
package Griego;
class Gamma {
void métodoAccesor() {
Alpha a = new Alpha();
a.estoyProtegido = 10; // legal
a.métodoProtegido(); // legal
}
}
Esto es muy sencillo. Ahora, investiguemos cómo afecta el especificador protected a una subclase de Alpha. Introduzcamos una nueva clase, Delta, que desciende de la clase Alpha pero reside en un paquete diferente - Latín. La clase Delta puede acceder tanto a estoyProtegido como a métodoProtegido(), pero solo en objetos del tipo Delta o sus subclases. La clase Delta no puede acceder a estoyProtegido o métodoProtegido() en objetos del tipo Alpha. métodoAccesor() en el siguiente ejemplo intenta acceder a la variable miembro estoyProtegido de un objeto del tipo Alpha, que es ilegal, y en un objeto del tipo Delta que es legal. Similarmente, métodoAccesor() intenta invocar a métodoProtegido() en un objeto del tipo Alpha, que también es ilegal.
import Griego.*;
package Latin;
class Delta extends Alpha {
void métodoAccesor(Alpha a, Delta d) {
a.estoyProtegido = 10; // ilegal
d.estoyProtegido = 10; // legal
a.métodoProtegido(); // ilegal
d.métodoProtegido(); // legal
}
}
Si una clase es una subclase o se cuenta en el mismo paquete de la clase con el miembro
protegido, la clase tiene acceso al miembro protegido.
El especificador de acceso más sencillo es 'public'. Todas las clases, en todos los paquetes tienen acceso a los miembros públicos de la clase. Los miembros públicos se declaran sólo si su acceso no produce resultados indeseados, si un extraño los utiliza. Aquí no hay secretos familiares; no importa que lo sepa todo el mundo. Para declarar un miembro público se utiliza la palabra clave public. Por ejemplo,
package Griego;
class Alpha {
public int soyPublico;
public void métodoPublico() {
System.out.println("métodoPublico");
}
}
Rescribamos nuestra clase Beta una vez más y la ponemos en un paquete diferente que la
clase Alpha y nos aseguramos que no están relacionadas (no es una subclase) de Alpha.
import Griego.*;
package Romano;
class Beta {
void métodoAccesor() {
Alpha a = new Alpha();
a.soyPublico = 10; // legal
a.métodoPublico(); // legal
Como se puede ver en el ejemplo anterior, Beta puede inspeccionar y modificar legalmente
la variable soyPublico en la clase Alpha y puede llamar legalmente al método
métodoPublico()
package Griego;
class Alpha {
int estoyEmpaquetado;
void métodoEmpaquetado() {
System.out.println("métodoEmpaquetado");
}
}
La clase Alpha tiene acceso a estoyEmpaquetado y a métodoEmpaquetado().
Además, todas las clases declaradas dentro del mismo paquete como Alpha también tienen
acceso a estoyEmpaquetado y métodoEmpaquetado().
Supongamos que tanto Alpha como Beta son declaradas como parte del paquete Griego.
package Griego;
class Beta {
void métodoAccesor() {
Alpha a = new Alpha();
a.estoyEmpaquetado = 10; // legal
a.métodoEmpaquetado(); // legal
}
}
Entonces Beta puede acceder legalmente a estoyEmpaquetado y
métodoEmpaquetado().
Las relaciones de herencia forman estructuras jerárquicas similares a un árbol. Una superclase existe en una relación jerárquica con sus subclases. Sin duda una clase puede existir sola, pero es cuando una clase con el mecanismo de herencia que se convierte ya sea en una superclase que proporciona atributos y comportamientos a otras clases, o en una subclase que hereda dichos atributos y comportamientos.
Una jerarquía de herencia puede tener una profundidad arbitraria dentro de las limitaciones físicas del sistema de que se trate, pero la mayor parte de las jerarquías de herencia sólo tienen unos cuantos niveles.
|
