Definición de una clase
public class NombreClase{
// Declaración de las propiedades
// Declaración de los comportamientos
}
Por el momento asumiremos que todos los elementos que declaremos serán
públicos.
Estilo de nombrado. El
nombre de la clase empieza por mayúsculas, sigue en minúsculas y se capitaliza
el comienzo de cada palabra. Ej: Persona, VentanaTipoA, ImpresoraLaser…
Declaración de las propiedades
Es el conjunto de características atribuibles a la clase que se define.
Al igual que existen variables:
è
Definidos como parámetros a una subrutina
è
O definidias dentro de una subrutina, localmente
Las propiedades se declaran como variables que pertenecen a la clase
que la constituye, por eso reciben el nombre de variables miembro o campos.
Ejemplo:
public class Empleado{
//
Declaración e inicialización de propiedades
public
String nombre = null;
public
String apellido1, apellido2, cargo;
public
double salario = 1000;
public
Date fechaAlta ,fechaBaja, fechaNacim;
public
Boolean estaDeBaja = false;
//
Comportamientos
// …
}
Declaración de los comportamientos
Los métodos son los encargados de definer los comportamientos de una
clase.
Los métodos se declaran igual que las subrutinas en C, así que hay que
concretar
è
Un nombre
è
De 0 a N parámetros de entrada
è
De 0 a 1 parámetros de salida
Estilo de nombrado. Tanto las
propiedades como los métodos se nombran en minúsculas y capitalizando el
comienzo de cada palabra except la primera.
Ejemplos (relativos a la clase Empleado):
public void cambioDeCargo(String nuevoCargo){
… };
public String obtenerCargo(){ … );
La diferencia entre los métodos y las subrutinas de C es que los
métodos pueden leer y escribir las propiedades o variables miembros de la
clase.
Ejemplos:
public void cambioDeCargo(String nuevoCargo){
cargo
= nuevoCargo;
}
public String obtenerCargo(){ // Si no hay
parámetros de entrada no se pone void entre los paréntesis
return
cargo;
}
Un ejemplo sencillo, la clase Bombilla:
public class Bombilla{
//
Tres propiedades
public
boolean encendida = false;
public
int potencia = 100;
public
int numEncendidos = 0;
//
Dos comportamientos
public
void encender(){
encendida
= true;
numEncendidos++;
System.out.println(“Bombilla
de ”+potencia+” vatios encendida”);
}
public
void apagar(){
encendida
= false;
System.out.println(“Bombilla
de ”+potencia+” vatios apagada”);
}
}
Características de las clases
è
Abstracción.
Todas las clases son una abstracción de las propiedades y
comportamientos de un conjunto de objetos.
è
Estado. Las
clases pueden poseer propiedades capaces de almacenar el estado de un objeto.
El estado de un objeto evoluciona en el tiempo a medida que éste es utilizado.
è
Responsabilidad.
Las clases deben garantizar que los objetos que se crean a partir de
ella siempre estén en un estado coherente independientemente de cómo sean
utilizados.
Creación de objetos
Los constructors de
objetos
Son unos métodos especiales que permiten la creación de objetos de la
clase que los contiene. Debe garantizar la inicialización de las propiedades
del objeto a valores coherentes.
Se declaran de la siguiente forma:
public NombreDeLaClase(lista de parámetros){
…
}
En cuanto a la sintaxis:
è
Se deben llamar exactamente igual que la clase
è
No hay que escribir ningún tipo de retorno
Ejemplo:
public class Bombilla{
//
Propiedades
public
int potencia;
public
int numEncendidos;
public
bolean encendida, fundida;
//
Método constructor
public
Bombilla(int potenciaInicial, int numEncendidosInicial){
encendida
= false;
fundida
= false;
potencia
= potenciaInicial;
if
(potencia <= 0)
potencia
= 20;
numEncendidos
= numEncendidosInicial;
if
(numEncendidos < 0)
numEncendidos
= 0;
}
//
Comportamientos
public
void encender(){
encendida
= true;
numEncendidos++;
System.out.println(“Bombilla
de ”+potencia+” vatios encendida”);
}
public
void apagar(){
encendida
= false;
System.out.println(“Bombilla
de ”+potencia+” vatios apagada”);
}
}
Cuando escribimos un constructor debemos saber que el compilador añade
al código compilado un conjunto de instrucciones antes de las nuestras.
Estas instrucciones generadas automáticamente se encargan de la
inicialización de las propiedades del objeto de la siguiente forma:
è
Si la propiedad declarada no se inicializa:
o Los
numerous y char se ponen a cero
o Los
lógicos se inicializan a false
o Las
referencias a objetos apuntan a null
è
Si la propiedad declarada se inicializa entonces
toma dicho valor inicial
Si no escribimos un constructor para una clase el compilador genera uno
por defecto (lo añade al código compilado, no al código fuente).
Dicho constructor por defecto es siempre un constructor público sin
parámetros ni código. Su mission es inicializar las propiedades del objeto con
las reglas antes descritas.
En nuestro ejemplo anterior se generaría
public Bombilla(){
…
}
que realizaría las siguientes inicializaciones:
è
potencia = 20;
è
numEncendidos = 0;
è
encendida = false;
è
fundida = false;
La instanciación y
utilización de objetos
Para crear o instanciar un objeto a partir de una clase necesitamos
è
Una referencia capaz de apuntar al objeto a crear
è
Asignar a dicha referencia el resultado de la
creación del objeto, que se realiza con el operador new y un constructor
de la clase
Ejemplo:
Bombilla b; // B es una referencia a objetos
de tipo bombilla
b = new Bombilla(100,5); // A la referencia b
le asignamos el objeto resultado de llamar al constructor. Hacemos que apunte
al objeto.
También lo podemos hacer todo en una sola línea
Bombilla b = new Bombilla(100,5);
Para utilizer un objeto necesito:
è
Una referencia que apunte al objeto que queremos
utilizer
è
Utilizar el operador ‘.’ para accede a sus miembros
(propiedades y métodos)
Ejemplo:
Bombilla b1 = new Bombilla(100,5);
Bombilla b2 = new Bombilla(60,0);
if (b1.fundida == false)
b1.encender();
b2.encender();
b1.apagar();
El método main
Es el punto de comienzo de un programa orientado a objetos y debe
cumplir que:
è
Siempre esté incluido en una clase
è
Tenga el siguiente prototipo: public static void main(String[] args)
è
El parámetro de entrada args es una table de
referencias a objetos de tipo String que se usa para recibir parámetros de la
línea de commandos del sistema, aunque también podemos ignorarlo si no hace
falta.
Para probar nuestras clases y manejar objetos cerrados a partir de
ellas crearemos una clase de pruebas que solo contenga el método main.
Ejemplo
Usa
Un posible código de PruebaBombilla sería:
public class PruebaBombilla{
// No
hay propiedades ni constructors en la clase
public
static void main(String args[]){
int
i;
Bombilla
b = new Bombilla(); // Creamos el objeto bombilla
//
La encedemos y apagamos 1000 veces
for(i=1;i<=1000;i++){
b.enceder;
b.apagar;
}
//
y otra vez más, ya debe estar fundida
b.encender();
b.apagar();
}
}
Características de
los objetos
è
Tienen un espacio de memoria propio
è
Como consecuencia de esto, cada objeto tiene una
identidad propia y conserva su estado interno
è
Independientemente de cómo sean manipilados, los
objetos deben tener siempre un estado interno coherente. Esto dependerá de cómo
se haya escrito la clase (ésta debe ser responsable).
0 comentarios:
Publicar un comentario