La principal diferencia entre Java y los demás lenguajes de programación por objetos es que con estos últimos es posible programar por objetos, mientras que con Java se tiene absolutamente que programar por objetos. Por eso es necesario explicar qué quiere decir programar por objetos. En concreto la programación se desarrolla de la misma forma que los lenguajes "normales", pero tanto los datos como las funciones que los trabajan se organizan en estructuras llamadas clases.
Las clases son prototipos de objetos, es decir, son estructuras abstractas (no demasiado, como veremos) que se pueden instalar y, por eso, crear un objeto (pero también más de uno).
La clase define todas las propiedades de los objetos que pertenecen a aquella clase, llamadas atributos, y las funciones que se usarán para actuar sobre ellos, llamados métodos. Por ejemplo es posible definir una clase de las personas como sigue:

Inicio clase personas
   Atributo añodenacimiento
   Método calculaedad (añocorriente)
Fin clase personas

La clase de las personas establecida de esta forma tiene un atributo que es añodenacimiento, que es seguramente un número entero, y un método que, basándose en el año corriente que le pongamos, calcula la edad de la persona. Usando el formalismo de Java, para definir la clase personas tendremos que escribir:

clase personas
{
   public ent añodenacimiento;
   public ent calcula edad ( ent añocorriente )
{
envía ( añocorriente - añodenacimiento );
}
}

Como acabamos de ver explicamos tanto el método cuanto el atributo como public. Veremos ahora lo que significa y veremos también la clase empieza por { y acaba por }, lo mismo pasa con los métodos. Esto nos recuerda mucho al C, y hay que decir que la sintaxis de Java es muy similar, casi igual, a la de C, mientras que para los que no conocen el C, los corchetes representan el empezar y el terminar del lenguaje pascal. La clase tendrá un llamado constructor (uno o más) que es un método peculiar que normalmente se utiliza para inicializar los atributos cuando se establece la clase de un objeto. Es una función que no tiene ningún tipo de return y tiene el mismo nombre que la clase. Decimos que puede haber más de un constructor, sin embargo, el nombre del constructor tiene que ser el mismo que el de la clase. A los que están acostumbrados a programar con lenguajes no orientados a los objetos, todo esto les puede resultar algo raro, sin embargo es posible porque Java realiza el llamado overloading de funciones, es decir funciones con el mismo nombre que tienen parámetros diferentes (en el lenguaje informático se llaman parámetros formales) son distintas, y a la hora de establecerlas se elige la función basándose en el parámetro (llamado parámetro actual).
Esto vale para todos los métodos, no sólo para los constructores.

clase personas
{
   public ent añodenacimiento;
   public String Apellidos=new String();
   // Constructores
public personas(ent añodenacimiento)
{
this("No sé");
this.añodenacimiento=añodenacimiento;
}

public personas(String Apellidos)
{
this(0);
this.Apellidos=Apellidos;
}

public personas(ent añodenacimiento , String Apellidos)
{
añodenacimiento=añodenacimiento;
this.Apellidos=Apellidos;
}

// Función que calcula la edad del sujeto;
public int calculaedad ( ent añocorriente )
{
return ( añocorriente - añodenacimiento );
}
}


Las líneas que empiezan por // son comentarios, el ordenador los ignora, pero hay otros dos tipos de comentarios, los que se ponen entre /* y / que permiten definir comentarios sobre más de una línea. Se llaman comentarios de documentación y se tienen que encontrar antes de la declaración de las clases, de los miembros de las clases (atributos o métodos) o de los constructores, y hay que incluírlos en la posible documentación del código que se genera automáticamente.

En el ejemplo vemos que hay tres constructores, distintos por parámetros formales, que tienen el mismo nombre. Además vemos un nuevo atributo que son los Apellidos, ésa es una cadena, que se define como public String Apellidos=new String(); la parte que está delante del signo igual resulta clara, la parte que se encuentra a la derecha del mismo signo un poco menos, ese new String() crea un nuevo objeto de la clase String y llama a su vez al constructor que no tiene parámetros. Esto es el procedimiento tipo que usa Java para crear los objetos de una clase. No hay que sorprenderse de que el tipo de dato cadena sea una clase, porque con Java es posible usar objetos que representen todos los tipos de datos del lenguaje, insertadoos para completar el lenguaje, y llamados confecciones que a veces resultan muy útiles. Si embargo, es posible usar también los valores.
Así, por ejemplo, trabajaremos tanto con enteros como con objetos que representan enteros. Por último, resulta bastante evidente en el ejemplo que los constructores tienen voluntariamente unos parámetros que tienen a su vez el mismo nombre de los atributos. Esto también es posible en Java y quiere decir que cuando hay un valor a la izquierda del signo igual tiene que encontrase el atributo, y a la derecha el parámetro. De todos modos si no queremos confundirnos podemos usar la referencia this; escribiendo, por ejemplo, this.añodenacimiento, esto quiere decir atributo. This se refiere al objeto, y en el ejemplo anterior lo encontramos también como llamada a la función this(0), en este caso se refiere a un constructor del objeto y se llamará constructor personas (ent añodenacimiento), con el valor 0. Es por tanto posible en un constructor llamar a un constructor distinto de la misma clase, con tal que la llamada sea la primera instrucción del constructor y que el constructor sea diferente del actual.
Llegados a este punto, estamos listos para crear objetos que pertenezcan a la clase que acabamos de definir. Tenemos tres formas de hacerlo porque hemos creado tres constructores que son:

personas Pietro=nuevas personas(1974);

o

personas Pietro=nuevas personas("Castellucci");

o

personas Pietro=nuevas personas(1974,"Castellucci");

ahora queremos crear otro objeto de la clase personas

personas Lina=nuevas personas(1975);

o

personas Lina=nuevas personas("Marucci");

o

personas Lina=nuevas personas(1975,"Marucci");

a este punto he creado dos objetos de la clase personas que tienen que ver con la llamada clase inst_of, los objetos se llaman uno Pietro y el otro Lina. También es posible copiar las referencias de los objetos, por ejemplo es posible escribir:

personas Pietro2=Pietro;

Construidos los objetos puedo crear los métodos, indicando Objeto.Método. Por ejemplo es posible crear los métodos:

Pietro.calculaedad(2000);
Pietro2.calculaedad(2000);
Lina.calculaedad(2000);

Ahora introduzcamos unos atributos y unos métodos particulares, los llamados miembros estáticos. Por como hemos definido los miembros de la clase, no nos resulta posible hacer una referencia directa de la clase atributos y métodos ( personas.añodenacimiento es un error), y esto porque estos trabajan sobre una instancia de la clase, es decir sobre un objeto, pero a veces puede ser útil escribir métodos y atributos que se puedan crear sin tener que llamar al objeto, y que puedan ser llamados directamente desde la clase. Para hacer esto necesitamos declararlos estáticos, por ejemplo:

clase TítulosEmpresaEquis
{
public static int TipodeInterés=3;
public String Propietario=new String();
public static float InteresesDevengados (int Período)
{
return((Período * TipodeInterés )/100)
}
TítulosEmpresaExis(String nombre)
{
Propietario=nombre;
}
}

Entonces podremos decidir, por ejemplo, llamar a un objeto de la clase TítulosEmpresaExis sólo si nos conviene, por ejemplo haciendo:

if (TítulosEmpresaEquis.InteresesDevengados(12)>1000)
CompraAcciones(10000);

Donde CompraAcciones (int X) es una función que llama X TítulosEmpresaEquis.

Introduzcamos ahora la relación is_a entre clases. Establecida una clase, es posible crear una nueva clase partiendo de ésta haciendo, como se dice en nuestra jerga, una especialización de la primera clase. La nueva clase que creamos está relacionada is_a con la primera. Creada una clase estudiante de la clase (llamada superclase) personas, la nueva clase hereda de la primera todos los métodos y los atributos, con la posibilidad de definir unos atributos y unos métodos nuevos o de volver a definir otros. En Java, la estensión de una clase se manifiesta con la palabra clave extends.

clase estudiante extends personas
{
ent inscripción;
// Constructores
public estudiante(ent añodenacimiento)
{
super(añodenacimiento,"No Conocido");
}

public estudiante (String Apellidos)
{
super(0,Apellidos);
}

public estudiante(int añodenacimiento , String Apellidos)
{
super(añodenacimiento,Apellidos);
}

}

Como vemos en el ejemplo, la clase estudiante hereda todos los métodos y los atributos de la clase personas, define un nuevo atributo inscripción, y en sus constructores llama a los constructores de la clase personas con el nombre de super.().
Super() puede ser, como this(), una llamada de otro constructor (entre parántesis van los parámetros posibles) o una referencia a la clase (a la superclase en este caso). Entonces, super.añodenacimiento representa el atributo añodenacimiento de la superclase personas. Las relaciones is_a y inst_of son las dos relaciones más importantes de los modelos por objetos. Ahora, en conclusión, ponemos un ejemplo que comentaremos a continuación para explicar el significado del public que introducimos anteriormente, y del private y protected (los atributos y los métodos pueden llamarse public, private y protected).

clase A
{
public int a;
private int b;
protected int c;
// Sus métodos, atributos y constructores
}

clase B extends A
{
public float a;
private float b;
protected float c;
// Sus métodos, atributos y constructores
}

clase C
{
// Sus métodos, atributos y constructores
}

Hemos definido tres clases, A,B y C, B se define partiendo de A volviendo a definir los tres atributos, de enteros a reales.
En A, en sus constructores y en sus métodos, tenemos aceso a los mismos atributos de tipo entero, sin limitaciones, es decir, podemos escribirlos y leerlos a nuestro antojo.
En B y C pasa lo mismo con los propios atributos, pero vamos a ver lo que sucede para los de las demás clases.
Por ejemplo, en B (en uno de sus métodos) si escribimos expresiones con a,b y c, escribiremos unas expresiones pera unos float (en Java es muy importante el tipo de las expresiones). Sin embargo, para referirnos a los atributos homónimos de A de la que se ha heredado, tenemos que escribir, como sabemos, super.a, super.b y super.c (que son unos enteros).
Nuestro compilador Java no dará problemas para las primeras dos, pero nos dará error para el tercero. Esto porque el c de A está protegido (protected) que quiere decir que es posible leer y escribir aquel atributo sólo internamente a la calse a la que pertenece, pero no es posible leerlo y escribirlo de clases ajenas o de subclases.