TIPOS DE CLASES

R/

Hasta ahora sólo se ha utilizado la palabra clave public para calificar el nombre de las clases que hemos visto, pero hay tres modificadores más. Los tipos de clases que podemos definir son:
abstract

Una clase abstract tiene al menos un método abstracto. Una clase abstracta no se instancia, sino que se utiliza como clase base para la herencia.

final

Una clase final se declara como la clase que termina una cadena de herencia. No se puede heredar de una clase final. Por ejemplo, la clase Math es una clase final.

public

Las clases public son accesibles desde otras clases, bien sea directamente o por herencia. Son accesibles dentro del mismo paquete en el que se han declarado. Para acceder desde otros paquetes, primero tienen que ser importadas.

synchronizable

Este modificador especifica que todos los métodos definidos en la clase son sincronizados, es decir, que no se puede acceder al mismo tiempo a ellos desde distintos threads; el sistema se encarga de colocar los flags necesarios para evitarlo. Este mecanismo hace que desde threads diferentes se puedan modificar las mismas variables sin que haya problemas de que se sobreescriban.

SUBCLASES

R/Una subclase se define mediante:

class B extends A
{
  // variables que B agrega a A
  int z;
  // Métodos que B agrega a A
  // Observe que B también posee x
  void Incz() { z= z+x; }
}

Se dice que la clase B hereda todas las variables y métodos de A. También se dice que B se deriva de A o que A es la clase base para B.

HERENCIA

R/
La Herencia es el mecanismo por el que se crean nuevos objetos definidos en términos de objetos ya existentes. Por ejemplo, si se tiene la clase Ave, se puede crear la subclase Pato, que es una especialización de Ave.

class Pato extends Ave {
        int numero_de_patas;
        }

La palabra clave extends se usa para generar una subclase (especialización) de un objeto. Una Pato es una subclase de Ave. Cualquier cosa que contenga la definición de Ave será copiada a la clase Pato, además, en Pato se pueden definir sus propios métodos y variables de instancia. Se dice que Pato deriva o hereda de Ave.
Además, se pueden sustituir los métodos proporcionados por la clase base. Utilizando nuestro anterior ejemplo de MiClase, aquí hay un ejemplo de una clase derivada sustituyendo a la función Suma_a_i():

import MiClase;
    public class MiNuevaClase extends MiClase {
        public void Suma_a_i( int j ) {
            i = i + ( j/2 );
            }
        }

Ahora cuando se crea una instancia de MiNuevaClase, el valor de i también se inicializa a 10, pero la llamada al método Suma_a_i() produce un resultado diferente:

MiNuevaClase mnc;
    mnc = new MiNuevaClase();
    mnc.Suma_a_i( 10 );

En Java no se puede hacer herencia múltiple. Por ejemplo, de la clase aparato con motor y de la clase animal no se puede derivar nada, sería como obtener el objeto toro mecánico a partir de una máquina motorizada (aparato con motor) y un toro (aminal). En realidad, lo que se pretende es copiar los métodos, es decir, pasar la funcionalidad del toro de verdad al toro mecánico, con lo cual no sería necesaria la herencia múltiple sino simplemente la compartición de funcionalidad que se encuentra implementada en Java a través de interfaces.

DESTRUCTOR EN JAVA

Un destructor es un método que se invoca automáticamente cuando el objeto se destruye. Java no posee destructores, porque tiene recolección de basuras. C++ posee destructores.

CONSTRUCTOR

R/El constructor es un tipo específico de método que siempre tiene el mismo nombre que la clase.

Cuando se declara una clase en Java, se pueden declarar uno o más constructores opcionales que realizan la inicialización cuando se instancia (se crea una ocurrencia) un objeto de dicha clase.

 Cuando se crea una nueva instancia de MiClase, se crean (instancian) todos los métodos y variables, y se llama al constructor de la clase:

MiClase mc;
    mc = new MiClase();

La palabra clave NEW se usa para crear una instancia de la clase.
Antes de ser instanciada con new no consume memoria, simplemente es una declaración de tipo. Después de ser instanciado un nuevo objeto mc, el valor de i en el objeto mc será igual a 10.
Se puede referenciar la variable (de instancia) i con el nombre del objeto:

mc.i++; // incrementa la instancia de i de mc

Al tener mc todas las variables y métodos de MiClase, se puede usar la primera sintaxis para llamar al método Suma_a_i() utilizando el nuevo nombre de clase MC:

mc.Suma_a_i( 10 );

y ahora la variable mc.i vale 21.

DEFINICION DE METODO

R/Un método es un procedimiento cuya invocación siempre va asociada a un objeto.

Los métodos se definen en la declaración de la clase:

class A {
  int x, y; // variables de instancia
  // Métodos
  void Set(int vx, int vy) { x= vx; y= vy; }
  void Incx() { x++; }
  void Print() { System.out.println(x+" "+y); }
}
A a= new A();
a.Set(10, 20);
a.Print();      // 10 20
a.Incx();
a.Print(); // 11 20
Incx(); // error, falta indicar el objeto
A a2= new A();
a2.Set(5, 6);
a2.Print();     // 5 6
a.Print();      // 11 20

METODO

R/un método tiene las siguiente sintaxis:
tipo-retorno nombre-método
       ( tipo-parámetro nombre, ... )
{ instrucciones }
Si el procedimiento no retorna nada se coloca void. En las instrucciones las variables que se accesen que no sean parámetros o variables locales del procedimiento deben ser variables de instancia del objeto.

Una variable de tipo objeto es una referencia (puntero) a un objeto:

A a1= new A();
A a2= new A();
A a3= a2;
a1.Set(1,2);
a2.Set(5,6);
a3.Set(8,9);
a1.Print(); // 1 2
a2.Print(); // 8 9
a3.Print(); // 8 9

En este caso las variables a2 y a3 referencian el mismo objeto, mientras que a1 y a2 referencian objetos distintos.

Una referencia puede ser pasada como argumento y puede ser retornada por un método.

class A {
  ...
  void CopyFrom(A from) { x= from.x; y= from.y }
  A MakeCopy()
  {
    A acopy= new A();
    acopy.Set(x, y);
    return acopy;
  }
}

A a1= new A();
a1.Set(1,2);
A a2= new A();
a2.CopyFrom(a1);
a2.IncX();
a2.Print(); // 2 2
a1.Print(); // 1 2
A a3=a1.MakeCopy();
a3.Print(); // 1 2

Dentro de un método, el identificador this contiene una referencia al objeto con que se invocó este método.

class A {
  ...
  void CopyTo(A to)
  { to.CopyFrom(this); }
}

En Java no existe enlace directo entre identificador y objeto como en C o Pascal:

En C o C++
  A a;   // a es el objeto
  A *pa; // pa es una referencia al objeto
En Pascal
  var a: A;  // a es el record
      a: A^; // a es una referencia al objeto

Las variables se pueden inicializar con la referencia nula:

A a;
a= null;
a.x= 0;    // error, a es la ref. nula

Un objeto puede referenciar otros objetos:

class Eslabon {
  Eslabon next;
  A a;
  void Encadenar(Eslabon anext) { next= anext; }
}
...
for(Eslabon e= prim; e!=null; e= e.next)
  e.a.Print();

Los arreglos y strings son objetos predefinidos.

String s= null;
s.substring(1,2); // error
int[] a= null;
a[0]=0;           // error

Se pueden crear arreglos de referencias a objetos. No se pueden crear arreglos de objetos.

A[] aArr= new A[10];
aArr[0].x=1; // error, aArr[0] es nulo
for (int i=0; i<aArr.length; i++)
  aArr[i]= new A();

Ningún objeto se destruye explícitamente: No hay free ni delete

A a= new A();
a= new A();   

El objeto que se creó primero ya no es alcanzable y por lo tanto el recolector de basura recuperará el espacio que ocupa.

COMO SE CREA UN OBJETO ?

R/ Todos los objetos se crean con new:

A a1= new A();

A es el tipo del objeto creado. También se dice que A es la clase del objeto o que el objeto es una instancia de la clase A. La variable a1 también es de tipo A, o análogamente a1 es de la clase A, porque a1 debe contener siempre referencias a objetos que pertenecen a la clase A.

                          

COMO SE CREA UNA CLASE?

R/COMO CREAR UNA CLASE: En java los programas o aplicaciones se escriben en ficheros que tienen la extencion .java
Una aplicación puede tener uno o más ficheros con extensión .java
Cada uno de estos ficheros .java contiene una Clase
Cada vez que se crea una nueva Clase, se crea su correspondiente fichero con el nombre de la Clase y con extensión .java
En nuestro caso, vamos a crear una Clase que la vamos a llamar HolaMundo siguiendo los siguientes pasos
nos situamos en la ventana Projects y con el botón derecho del ratón seleccionamos el paquete paqholamundo
elegimos New Other

En el cuadro de dialogo New File elegimos la categoria Java y el tipo de fichero Java Main Class y hacemos click sobre el boton NEXT

en el campo de Texto Class Name indicamos que la Clase se va a llamar HolaMundo y hacemos clic sobre el botón FINISH y Listo.