Objeto
En Java, hay dos tipos de tipos: tipos primitivos y tipos de objeto. Los primitivos, como int y boolean, empiezan con minúsculas; los tipos de objeto empiezan con mayúsculas. Esta distinción es útil porque nos recuerda algunas de las diferencias entre ellos:
Cuando declaras una variable primitiva, obtienes un espacio de almacenamiento para un valor primitivo. Cuando declaras una variable de objeto, obtienes un espacio para una referencia a un objeto. Para obtener espacio para el objeto mismo, debes usar el operador new.
Si no inicializas una variable primitiva, se le asigna un valor predeterminado que depende de su tipo. Por ejemplo, 0 para int y false para boolean. El valor predeterminado para los tipos de objeto es null, lo que indica que no hay objeto referenciado por las variables de referencia.
Las variables primitivas están bien aisladas en el sentido de que no hay nada que puedas hacer en un método que afecte a una variable en otro método. Las variables de objeto pueden ser complicadas de trabajar porque no están tan bien aisladas. Si pasas una referencia a un objeto como argumento, el método que invocas puede modificar el objeto, en cuyo caso verás el efecto. Por supuesto, eso puede ser algo bueno, pero debes ser consciente de ello.
Si pasamos variables primitivas a un método (pasando parámetros por valor), en realidad copiamos los valores de los primitivos y los usamos dentro del método. Todas las operaciones dentro del método se realizan sobre las copias; y, fuera del método, los valores de las variables primitivas permanecen sin afectar. Pero, si pasamos objetos no primitivos a un método (pasando parámetros por referencia), pasamos las variables de referencia al método. Todas las operaciones realmente usarán y/o afectarán a los objetos originales.
Ejemplo:
Escribe el siguiente código en el archivo /home/labex/project/objectTest.java:
public class objectTest {
public static void main(String[] args){
// usa new para crear un objeto Array con dos elementos
int[] numbers = new int[2];
// asigna valores al objeto array
numbers[0] = 1;
numbers[1] = 2;
// crea variables primitivas de esta manera
int a = 1, b = 2;
// crea un objeto de prueba
objectTest test = new objectTest();
test.changeInt(a, b);
System.out.println("Now a is " + a + ", b is " + b);
test.changeArray(numbers);
System.out.println("Now numbers contain:");
for(int i : numbers){
System.out.print(i + "\t");
}
}
// define un método de objeto, cambia el valor de int
public void changeInt(int a,int b){
a = 2;
b = 3;
System.out.println("In changeInt method, a is " + a + ", b is " + b);
}
// define un método de objeto, cambia el valor del array
public void changeArray(int[] number){
for(int i = 0;i < number.length;i++){
number[i] = number[i]+1; // cambia el valor del elemento del array aumentándolo en 1
}
System.out.println("In changeArray method, numbers contain:");
for(int i : number){
System.out.print(i + "\t");
}
System.out.println();
}
}
Salida:
Ejecuta el archivo objectTest.java usando el siguiente comando en la terminal:
javac /home/labex/project/objectTest.java
java objectTest
Ver la salida:
In changeInt method, a is 2, b is 3
Now a is 1, b is 2
In changeArray method, numbers contain:
2 3
Now numbers contain:
2 3
Hay otra diferencia entre los primitivos y los tipos de objeto. No puedes agregar nuevos primitivos a Java (a menos que te pongas en el comité de estándares), pero ¡puedes crear nuevos tipos de objeto! Veremos cómo en el próximo capítulo.
