No es un bug, es una característica no documentada

domingo, 15 de marzo de 2015

Programación. Java. Clases, objetos y paquetes

15:35 Posted by Inazio , No comments

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