Java: programación orientada a objetos.

Los objetos hemos dicho que son una agrupación de datos.

Están formados por unos atributos y unos métodos: correspondiendo, en metafísica al ser y operar de las cosas.

Los objetos se crean a partir de las clases de tipos de datos.

Por ejemplo, la clase Hora, crea objetos hora concretos, como las 10:30.

Para crear objetos hora hemos de difinir primero y perfectamente la clase Hora: 

 public class Hora{

        private int horas;

        private int minutos;

Esta es la cabecera de la clase Hora. Decimos que esta clase está formada por dos atributos, también llamados variables de instancia, pues al objeto también se le llama instancia.

La hora, objeto, está formada por dos enteros, uno que representa las horas, atributo, y el otro que representa al otro atributo minutos. Por lo tanto el objeto hora está compuesto por dos datos enteros: una agrupación de datos.

A continuación definimos el constructor, método con el que se crean los objetos horas.

public Hora(int horas, int minutos){

     this.horas = horas;

     this.minutos = minutos;

}

El constructor es un método especial que siempre es public, no retorna nada, no es void, y toma el nombre de la clase.

this se refiere o corresponde el objeto que se construirá. Su atributo o variable de objeto será el valor que se le pase a través de la variable local mediante el parámetro material (correspondiente al parámetro formal) int horas. Cómo hay dos atributos, lo mismo se puede decir para el otro.

 Puede haber muchos constructores.  Por ejemplo uno que nos de la hora actual, que ahora no es el momento de ver.

El constructor sirve para construir los objetos, pero eso lo veremos al ejecutar la clase Hora.

Métodos. Hemos dicho que definen el operar del objeto. Por lo tanto definiremos los que nos convengan.

Por ejemplo, si queremos comparar dos horas, podemos hacerlo así:

public boolean anteriorQue( Hora h1 ){

    if(this.horas<h1.horas) return true;

    else if(this.horas== h1.horas &&

              this.munutos<h1.minutos) return true;

    else return false;

}

Con esto podemos comparar la hora que construyamos con el constructor (this) con la hora que pasemos mediante parámetros formales/materiales.

Quizá nos parezca que éste método sirve para muy poco, y nos interese calcular la diferencia en minutos entre dos horas.

Ésto en concreto lo podemos hacer mediante los dos tipos de métodos que existen:

MÉTODOS ESTÁTICOS Y

MÉTODOS DINÁMICOS.

Para ello conviene conocer que existen dos tipos de variables: variables locales y variables de instancia o atributos. A éstas últimas podemos acceder mediante el this. A las variables locales mediante parámetros de los métodos, o sin más definiéndolas dentro del bloque del método.

Así pues, cuando en método pueda funcionar con variables locales, será un método estático, y cuando requiera objetos o variables de objeto será un método de objeto o dinámico.

Método que calcula la diferencia de minutos de dos horas de modo estático:

public static int aMinutos( Hora h1){

      int horas = h1.horas;

      int minutos = h1.minutos;

return horas*60+minutos;

}

No hemos utilizado para nada los atributos de objetos o variables de instancia, hemos utilizado variables locales únicamente, a través del parámetro del método. 

Obtenemos un resultado entero no vinculado con el objeto hora h1, como si fuera también una variable local.

Vamos a hacerlo con un método dinámico o de objeto. Para utilizarlo hemos de utilizar objetos.

public int difMinutos( Hora h2){

    aMinutos(this)-aMinutos(h2);

}