En esta entrega introduciré los conceptos básicos de la programación orientada a objetos: Las clases y los objetos. Dichos conceptos no son específicos de Java, sino que son válidos para casi todos los lenguajes orientados a objetos. Incluso la forma de escribir el código Java que definen las clases es similar en otros lenguajes (como por ejemplo C++).

El concepto clave de la POO es la clase. Una clase no es más que un concepto (como mesa o perro), que a la hora de implementarlo se compone de conjunto de variables (que conforman su estado) junto con un conjunto de funciones que se aplican sobre ellas (que conforman su comportamiento). Un ejemplo de clase puede ser la clase Persona cuyos datos internos son por ejemplo: nombre, peso, altura, sexo, edad, y cuyos métodos son,

anda ();
come ();
habla ();
crece ();

La clase es el concepto. Para utilizarla tenemos que instanciarla (crear un objeto). Una clase es el correspondiente a un tipo de dato (como un entero) y un objeto el correspondiente a una variable (int a;). Por ejemplo una clase puede ser Persona y los objeto de la clase serían Pepe, Manolo, Margarita y Alejandro, que son todos Personas. En Java, la clase anterior se representaría de la siguiente forma:

public class Persona {
  private String nombre;
  private double peso;
  private double altura;
  private int edad;
  private int sexo;
  // Dos constantes para el sexo:
  public static final Hombre = 0;
  public static final Mujer = 1;
 
  public Persona (){
    nombre = "Desconocido";
    peso = 0;
    altura = 0;
    edad = 0;
    sexo = hombre;
  }
 
  public Persona (String n, double p, double a, int s, int e){
    nombre = n;
    peso = p;
    altura = a;
    sexo = s;
    edad = e;
  }
 
  public void anda (){
    // Al andar perdemos 100 g de peso
    peso -= 0.1;
  }
 
  public void come (){
    // Comemos 100 g, por lo que aumentamos el peso
    peso += 0.1;
  }
 
  public void habla (){
    System.out.print ("Hola, mi nombre es " + nombre + ", tengo " + edad + " años, mido " + altura + " metros, peso " + peso + " kg y soy ");
    if (sexo == 0){
      System.out.println ("un hombre.");
    }else{
      System.out.println ("una mujer.");
    }
  }
 
  public void crece (){
    if (edad < 18){
      altura += 0.1;
    }
    edad ++;
  }
}

Vamos por partes:

• La palabra reservada class indica que lo que sigue a continuación es la definición de una clase.
• Public indica que la clase será visible por todas las demás clases del paquete. Por ahora basta con que sepais que un paquete es un conjunto de clases. Podemos indicar que la clase que estamos escribiendo pertenece al paquete P si al principio del archivo escribimos package P;. Para utilizar un paquete P escribiremos import P;
• Persona es el nombre que le hemos dado a la clase. Cada clase que creemos deberá estar en el archivo NombreDeLaClase.java, en nuesto caso, la clase Persona estará en Persona.java.
• Dentro de la case vamos declarando las variables y métodos de la case, indicando su tipo:
  • private: Las variables y métodos private no podrán ser accedidas por ningúna otra clase. Lo más comun es que todas las variables sean privadas. De hecho, si no indicamos nada, las variables serán privadas por defecto, por lo que en el ejemplo anterior la palabra private es innecesaria realmente. Por ejemplo si intentamos acceder a la edad
    int edad = manolo.edad;
    daría un error. Para poder acceder a los datos o modificarlos tendríamos que crear métodos públicos dentro de la clase:

    public int getEdad (){
      return (edad);
    }
     
    public void setEdad (int e){
      edad=e;
    }

    Esto se hace por seguridad, para mantener en todo momento la consistencia interna de los datos. Tambien nos puede interesar definir métodos privados para ser usados por la clase, pero que no nos interesa que puedan ser usados fuera de ésta.

  • public: Las variables y métodos publicos pueden ser accedidas por otras clases. Es lo normal en la mayoría de los métodos, aunque ráramente una variable es pública (en general es de un mal estilo de programación). De hecho, para Java, toda función por defecto es pública si no se indica lo contrario.
  • protected: Es equivalente a private, salvo por que las clases que hereden de ésta sí podrán acceder al método o la variable.

Una función especial es la que lleva el nombre de la clase y no devuelve nada. Este método es el constructor y es llamado solo una vez, al crearse el objeto. En nuestro caso es la función Persona que inicializa los valores internos de la clase de forma que cuando llamemos a

Persona pepe = new Persona ("Pepe", 89.1f, 1.80f, 0, 40);

El objeto se creará con el nombre “Pepe”, el peso 89.1 kg, etc. El constructor no tiene porqué recibir parámetros. Al constructor que no tiene parámetros se le suele llamar constructor por defecto.

Opcionalmente se puede añadir la palabra reservada final. Dependiendo a qué se aplique puede significar una cosa u otra:

• Si se aplica sobre una variable, indica que la variable es constante y no podrá ser modificada. Es el equivalente al const de C++. Por ejemplo las variables PI=3.1415926535 o IVA=0.18 podrían ser variables finales:
  

  class Ejemplo{
    private final float PI;
    private final float IVA;
    public Ejemplo (){
      PI=3.14159265358979;
      IVA=0.18;
    }
  }

• Si se aplica sobre un método, indica que dicho método no podrá ser reescrito por una subclase (Ver herencia).
• Equivalentemente, si se aplica sobre una clase, indica que no se podrán crear clases que hereden de ésta.

Otro de los modificadores es la palabra reservada static:

• Cuando se aplica sobre una variable, indica que la variable pertenece a la clase, no al objeto, es decir, que en lugar de haber una variable por cada objeto que creemos, la variable será la misma para todos los objetos de la clase, por lo que podrán compartir un valor. Sin embargo, el acceso se hace como con cualquier otra variable. Por ejemplo, podemos usar la variable como contador del número de objectos de dicha clase:
  

  class Ejemplo{
    private static int contadorObjetos;
    Ejemplo (){
      contadorObjetos++;
    }
    int getNumObjetos (){
      return (contadorObjetos);
    }
  }

  
  También puede ser útil para definir constantes de la clase si añadimos la palabra final. Por ejemplo, la clase Math de Java tiene las constantes PI y E que pueden ser accedidas sin crear un objeto de la clase Math, ya que son estáticas: Math.PI; En nuestro ejemplo, hemos añadido las constantes Hombre y Mujer con valores 0 y 1 para indicar explícitamente cual es cual.
• Cuando se aplica sobre un método, igualmente el método no pertenece al objeto sino a la clase.
  

  Class Ejemplo{
    static int num (){
      return (3);
    }
  }

  
  Si creamos un objeto “obj” de la clase Ejemplo, no podremos llamar a la funcion obj.num (); sino que tendremos que llamarla de la forma Ejemplo.num ();. Esto es muy util para implementar funciones que no necesiten datos internos. De hecho, una función estática no puede acceder a datos no estáticos de la clase, ya que el método estático no pertenece a ningún objeto. Por ejemplo la clase Math tiene métodos estáticos para calcular la raíz cuadrada, el seno, coseno, logaritmo, etc. de forma que se puede llamar a los métodos sin crear un objeto: Math.sin (2*Math.PI);
  Uno de los usos más comunes de métodos estáticos es la función principal main. La función main es la primera en ejecutarse en un programa, la cual llamará a otras funciones. Si no estás familiarizado con el concepto, la función principal es la que se ejecuta al comenzar el programa y la que, al terminar, hace que el programa finalice. Al menos debe haber una función main en el programa, aunque puede haber más de una, y tendremos que indicar qué main ejecutaremos. A menudo se tienen más de un main para relalizar las pruebas a una clase. La forma de definir el main es:
  

  Class UnaClase{
    // Otras cosas de la clase
    public static void main (String [] args){
      // Codigo de la función principal
    }
  }