Esc.

Técnica N°32 DE 14 Laboratorio de POO- 5°año CSC

Variables de Instancia y Variables de Clase

Cuando se define una clase en POO, las variables que se definen dentro de ella son variables que
tendrán diferentes valores con cada una de las instancias que se generan al crear objetos nuevos a
partir de dicha clase.

Una variable de instancia normalmente se define como privada, para que no se pueda modificar
desde otra clase, solo a través de los métodos (como ya lo estudiamos), pero puede ser definida como
pública y en ese caso no se requiere de hacer uso de algún método para tomar su valor o modificarla
(no es recomendable por el control de la variable por la misma clase).

Una variable de clase es aquella que solamente tiene un valor para toda la clase y debe ser definida
como static (estática) para que no se cree un nuevo valor con cada instancia.

La palabra static nos sirve para definir algo que no tiene que ver con las instancias de la clase, sino con
toda la clase.

Cuando a alguna variable o a algún método le anteponemos la palabra static, esto define que será
única (variable) o único (método) para toda la clase.

Las variables de instancia se utilizan a través de los métodos de la clase y estos son utilizados por
objetos. Es decir si tenemos la clase Cuenta, para utilizar la cuenta bancaria, con el constructor vacío
Cuenta() y el Constructor(double saldo) con parámetro y definimos algunos objetos como lo siguiente:

Cuenta cuenta1, cuenta2, cuenta3;

cuenta1= new Cuenta();

cuenta2= new Cuenta(1500.0);

cuenta3= new Cuenta(3000.0);

Al usar la palabra new estamos creando un nuevo objeto de la clase y con esto estamos utilizando una
nueva plantilla de variables de instancia para el objeto creado, cuenta1, cuenta2, cuenta3 son objetos
nuevos de la clase Cuenta y por cada variable que tiene definida Cuenta en la clase, cada uno de estos
objetos podrá tener un valor diferente.

IMPORTANTE. Es sumamente importante que después de declarar un

objeto para una clase (Cuenta objeto;) hagamos la creación del objeto,
es decir utilicemos la instrucción new Cuenta() para ese objeto ( objeto =
new Cuenta(); ) de otra manera el objeto no ha sido creado y no se pueden
utilizar los métodos, pues Java marcará el error NullPointerException.

En el ejemplo anterior, si tenemos el método setSaldo(double saldo), para modificar el saldo de la

cuenta y el método getSaldo(), para acceder al saldo de la cuenta, las siguientes pudieran ser
instrucciones válidas:

cuenta1.setSaldo(2200.0);
cuenta2.setSaldo(350.50);
System.out.println("Saldo de pedro = " + cuenta3.getSaldo());

1
La manera de utilizar un método por un objeto es utilizando el formato objeto.método(parámetros); .

El siguiente es un ejemplo que muestra el uso de las variables de instancia y variables
estáticas:
Supongamos que tenemos en la clase Punto una variable de clase llamada puntos, esta
variable nos servirá para saber el número de objetos que se han creado de la clase, la clase Punto a
usar sería:

public class Punto { Punto

private int x; // variable para la coordenada en x - x: int
private int y; // variable para la coordenada en y - y: int
private static int puntos=0; - puntos=0: int

public Punto() { // método para construir un objeto sin

parámetros
x = 0;
y = 0;

puntos++;
}
public Punto(int x, int y) { // método para construir un objeto con
valores enteros
this.x = x;
this.y = y;
puntos++;
}
public Punto(double x, double y) { // método para construir un objeto
con valores double
this.x = (int) x;
this.y = (int) y;
puntos++;
}
public Punto(Punto obj) { // método para construir un objeto con otro
objeto
this.x = obj.obtenX();
this.y = obj.obtenY();
puntos++; }
public int obtenX() { // método que te dá el valor de la coordenada x
return x; }
public int obtenY() { // método que te dá el valor de la coordenada y
return y; }
public void cambiaX(int x) { // método que sirve para cambiar el
valor //de la coordenada x this.x = x;
}
public void cambiaY(int y) { // método que te sirve para cambiar el valor
de la coordenada y this.y = y;
}

2
public String toString() { // para obtener un objeto Punto en formato
String return "(" + obtenX() + "," + obtenY() + ")";
}
public static int getPuntos() { // para acceder a la cantidad de objetos
creados
return puntos;
}
}

Nota: que la variable puntos y el método getPuntos() ambos fueron definidos como estáticos, esto
implica que será un solo valor de esto para toda la clase, no un valor diferente por instancia (objeto)
creada de la clase. También observa como la variable puntos es incrementada en uno cada vez que se
crea un objeto de la clase (en cualquier constructor).

Esta clase la podemos utilizar con la aplicación:

public class AplicacionPunto1 {

private static Punto a, b, c, d, e;
public static void main(String[] args) {
a = new Punto();
System.out.println(" Punto a = " + a.toString());
System.out.println("Puntos creados =" + Punto.getPuntos());
b = new Punto(1, 2);
c = new Punto(3.0, 4.0);
System.out.println(" Punto b = " + b.toString());
System.out.println(" Punto c = " + c.toString());
System.out.println("Puntos creados =" + Punto.getPuntos());
d = new Punto(b); e = new Punto(c);
System.out.println(" Punto d = " + d.toString());
System.out.println(" Punto e = " + e.toString());
System.out.println("Puntos creados =" + Punto.getPuntos());
}}

El resultado que nos mostraría sería:

3
Observamos como es que después de crear el elemento a y desplegar el valor de puntos creados, solo
despliega 1, después al crear b y c, se tienen 3 y al final ya se tienen los 5.

También es importante hacer notar que el método getPuntos() fue utilizado a través de la clase Punto,
ya que es un método estático y debe ser utilizado a través de la clase.

Lo anterior no es un requisito, pero es lo más común, ya que podemos tener una llamada a un método
estático, pero a través de un objeto de la clase y funciona exactamente igual, veamos ahora una
aplicación que está ligeramente cambiada, pero nos da el mismo resultado que la anterior:

public class AplicacionPunto1 {

private static Punto a, b, c, d, e;
public static void main(String[] args) {
a = new Punto();
System.out.println(" Punto a = " + a.toString());
System.out.println("Puntos creados =" + a.getPuntos());
b = new Punto(1, 2);
c = new Punto(3.0, 4.0);
System.out.println(" Punto b = " + b.toString());
System.out.println(" Punto c = " + c.toString());
System.out.println("Puntos creados =" + b.getPuntos());
d = new Punto(b);
e = new Punto(c);
System.out.println(" Punto d = " + d.toString());
System.out.println(" Punto e = " + e.toString());
System.out.println("Puntos creados =" + e.getPuntos());
}
}

En esta aplicación podemos observar cómo es que el método estático getPuntos() también puede ser
usado a través de un objeto de la clase, pero es importante recordar que es una sola variable para toda
la clase.

4
Recolección de Basura

En Java cada vez que utilizamos la palabra new, estamos creando una nueva referencia a memoria y
más tarde cuando ya no la usemos, no necesitamos borrarla (como se haría normalmente en C++), ya
que Java automáticamente los borra gracias a una clase llamada GarbageCollector, la cual se encarga
de estar revisando los objetos que ya son obsoletos y no se vuelven a utilizar.

La recolección de memoria permite que Java pueda reutilizar la memoria que se tenía bloqueada para
el uso de algún dato primitivo (int, double, etc) o algún objeto.

Constantes:

En un programa, las constantes se utilizan para almacenar datos (valores) –en la memoria de la
computadora– que no podrán cambiar durante la ejecución del programa. Para ello se utiliza la
palabra reservada final.

Nota: Realiza los ejemplos para comprender mejor los conceptos incorporados en este tutorial.

Ejercicio Propuesto:

1. En un local de ventas, se desea obtener el total de ventas realizadas por cada vendedor, para
poder calcular el importe de comisión que cobrará cada uno. Se pide:
a. Mostrar en pantalla un recibo con los datos de cada vendedor y el importe a cobrar y
la cantidad de ventas realizadas por el mismo.
b. Aplicar todos los conceptos estudiados de POO(abstracción, herencia, polimorfismo,
encapsulamiento)
c. Crear un diagrama de clases indicando relaciones entre las clases.
d. Utilizar variables de clase y variables de instancia