Este documento describe las variables y métodos de instancia y clase en Java. Explica que las variables y métodos de instancia pertenecen a objetos individuales, mientras que las variables y métodos estáticos pertenecen a la clase en general. También cubre el uso de constructores, finalizadores, constantes y un ejemplo de la clase Bicycle.

1. VARIABLES Y METODOS DE INSTANCIA
Una clase en Java puede contener variables y métodos. Las variables pueden ser
tipos primitivos como int, char, etc. Los métodos son funciones.
Por ejemplo, en el siguiente trozo de código podemos observarlo:
public MiClase {
int i;
public MiClase() {
i = 10;
}
public void Suma_a_i( int j ) {
i = i + j;
}
}
La clase MiClase contiene una variable (i) y dos métodos, MiClase que es el
constructor de la clase y Suma_a_i( int j ).
Ambito de una variable
Los bloques de sentencias compuestas en Java se delimitan con dos llaves. Las
variables de Java sólo son válidas desde el punto donde están declaradas hasta el
final de la sentencia compuesta que la engloba. Se pueden anidar estas sentencias
compuestas, y cada una puede contener su propio conjunto de declaraciones de
variables locales. Sin embargo, no se puede declarar una variable con el mismo
nombre que una de ámbito exterior.
El siguiente ejemplo intenta declarar dos variables separadas con el mismo
nombre. En C y C++ son distintas, porque están declaradas dentro de ámbitos
diferentes. En Java, esto es ilegal.
Class Ambito {
int i = 1; // ámbito exterior
{ // crea un nuevo ámbito
int i = 2; // error de compilación
}
}
Métodos y Constructores
Los métodos son funciones que pueden ser llamadas dentro de la clase o por otras
clases. El constructor es un tipo específico de método que siempre tiene el mismo
nombre que la clase.

2. 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.
Utilizando el código de ejemplo anterior, 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 dei 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.
Finalizadores
Java no utiliza destructores (al contrario que C++) ya que tiene una forma de
recoger automáticamente todos los objetos que se salen del alcance. No obstante
proporciona un método que, cuando se especifique en el código de la clase, el
reciclador de memoria (garbage collector) llamará:
// Cierra el canal cuando este objeto es reciclado
protected void finalize() {
close();
}
En esta sección, discutimos el uso de la palabra clave static para crears campos
ys métodos que pertenecen a la clase, en lugar de a una instancia de la clase.
Variables de Clase

3. Cuando un número de objetos se crean del mismo esquema de la clase, cada
uno tiene sus propias copias distintas de variables de instancia. En el caso de la
claseBicycle, las variables de instancia son cadence, gear, y speed. Cada
objeto Bicycle tiene sus propios valores para estas variables, almacenados en
diversas posiciones de memoria.
A veces, deseas tener variables que sean comunes a todos los objetos. Esto se
logra con el modificador static. Los campos que tienen el modificador static en
su declaración se llaman campos estáticos o variables de la clase. Estas están
asociadas con la clase, en lugar de a cualquier objeto. Cada instancia de la clase
comparte una variable de clase, que está en una localización fija en memoria.
Cualquier objeto puede cambiar el valor de una variable de clase, pero las
variables de clase pueden también ser manipuladas sin crear una instancia de la
clase.
Por ejemplo, suponga que desea crear un número de objetos Bicycle y asignar a
cada uno un número de serie, comenzando con 1 para el primer objeto. Este
número de identificación es único a cada objeto y es por lo tanto una variable de
instancia. Al mismo tiempo, necesita un campo para llevar la cuanta de cuántos
objetos Bicycle se han creado de modo que sepas qué ID asignar al siguiente.
Este campo no se relaciona con ningún objeto individual, sino con la clase en
como un todo. Para esto necesita una variable de clase, numberOfBicycles, como
sigue:
public class Bicycle{
private int cadence;
private int gear;
private int speed;
// agregar una variable de instancia para el ID de objeto
private int id;
// agregar una variable de clase para el número de objetos Bicycle
instanciados
private static int numberOfBicycles = 0;
......
}
Las variables de clase se referencian por el nombre de clase en sí mismo, como
en
Bicycle.numberOfBicycles
Esto hace claro que son variables de clase.

4. Nota: Puede también referirse a campos estáticos con una referencia de objeto
como
myBike.numberOfBicycles
pero esto no se recomienda porque no hace claro que estas son variables de
clase.
Puede usar el constructor de Bicycle para establecer la variable de instancia id e
incrementar la variable de clase numberOfBicycles:
public class Bicycle{
private int cadence;
private int gear;
private int speed;
private int id;
private static int numberOfBicycles = 0;
public Bicycle(int startCadence, int startSpeed, int startGear){
gear = startGear;
cadence = startCadence;
speed = startSpeed;
// incrementar el número de bicicletas y asignar un número de ID
id = ++numberOfBicycles;
}
// nuevo método para regresar la variable de instancia ID
public int getID() {
return id;
}
.....
}
Métodos de Clase
El lenguaje de programación Java soporta métodos estáticos así como variables
estáticas. Los métodos estáticos, que tienen el modificador static en sus
declaraciones, se deben invocar con el nombre de la clase, sin la necesidad de
crear una instancia de la clase, como en
ClassName.methodName(args)

5. Nota: Puede también referirse a métodos estáticos con una referencia de
objeto como
instanceName.methodName(args)
pero no se recomienda porque no hace claro que estas son variables de clase.
Un uso común para los métodos estáticos es el acceder a campos estáticos. Por
ejemplo, podríamos agregar un método estático a la clase Bicycle para acceder el
campo estático numberOfBicycles:
public static int getNumberOfBicycles() {
return numberOfBicycles;
}
No todas las combinaciones de variables de instancia y de clase se permiten:
 Los métodos de instancia pueden acceder variables de la instancia y a
métodos de la instancia directamente.
 Los métodos de instancia pueden acceder variables de la clase y a
métodos de la clase directamente.
 Los métodos de la clase pueden acceder variables de la clase y a métodos
de la clase directamente.
 Los métodos de la clase no pueden acceder variables de la instancia o a
métodos de la instancia directamente—estos deben utilizar una
referencia de objeto. También, los métodos de la clase no pueden utilizar
la palabra clave this ya que no hay instancia de this a la cual referirse.
Constantes
El modificador static, junto con el modificador final, también se utiliza para
definir constantes. El modificador final indica que el valor de este campo no
puede cambiar.
Por ejemplo, la siguiente declaración de variable define una constante
llamada PI, cuyo valor es una aproximación de pi (el cociente de la
circunferencia de un círculo a su diámetro):
static final double PI = 3.141592653589793;
Las constantes definidas de esta manera no pueden ser reasignadas, y es un
error de tiempo de compilación si su programa intenta hacerlo. Por convención,

6. el nombre de valores constantes se deletreado en letras mayúsculas. Si el
nombre se compone de más de una palabra, las palabras se separan por un
guión bajo (_).
Nota: Si se define un tipo primitivo o una cadena como una constante y el valor
es conocido en tiempo de compilación, el compilador substituye el nombre de la
constante en todas partes en el código con su valor. Esta se llama constante de
tiempo de compilación. Si el valor de la constante cambia en el mundo exterior
(por ejemplo, si se legisla que el pi realmente debe ser 3.975), necesitará
recompilar cualquier clase que utilice esta constante para obtener el valor
actual.
La Clase Bicycle
Después de todas las modificaciones hechas en esta sección, la clase Bicycle es
ahora:
public class Bicycle{
private int cadence;
private int gear;
private int speed;
private int id;
private static int numberOfBicycles = 0;
public Bicycle(int startCadence, int startSpeed, int startGear){
gear = startGear;
cadence = startCadence;
speed = startSpeed;
id = ++numberOfBicycles;
}
public int getID() { //obtener ID
return id;
}
public static int getNumberOfBicycles() { //obtener número de
bicicletas
return numberOfBicycles;

7. }
public int getCadence(){ //obtener cadencia
return cadence;
}
public void setCadence(int newValue){ //establecer cadencia
cadence = newValue;
}
public int getGear(){ //obtener engrane
return gear;
}
public void setGear(int newValue){ //establecer engrane
gear = newValue;
}
public int getspeed(){ //obtener velocidad
return speed;
}
public void applyBrake(int decrement){ //aplicar frenos
speed -= decrement;
}
public void speedUp(int increment){ //acelerar
speed += increment;
}
}