1. Objetos

Todo en Java es un objeto.

Más exactamente, hay muy pocas cosas en Java que no sean objetos. Por ejemplo, tipos primitivos. Pero esta es una excepción bastante rara a la regla.

Entonces, ¿qué es un objeto?

Un objeto es una entidad que agrupa datos junto con métodos que procesan los datos . Cuando decimos "datos", nos referimos a variables, por supuesto.

Las variables de un objeto se denominan "datos" o "estado".

Se dice que los métodos de un objeto son su "comportamiento". Es costumbre cambiar el estado de un objeto (variables) solo usando los métodos de ese objeto. Cambiar las variables de un objeto directamente (sin usar sus métodos) se considera de mala educación.

Cada objeto , así como cada variable, tiene un tipo . Este tipo se determina una vez cuando se crea el objeto y no se puede cambiar en el futuro. El tipo de un objeto es su clase.

Cada objeto tiene su propia copia de variables de instancia (campos). Si se declara una variable int a no estática en una clase y su programa crea 10 objetos de esa clase, entonces cada objeto tendrá su propia variable int a.

Interactuando con un objeto

La forma más conveniente de trabajar con un objeto es almacenar una referencia a él en una variable y luego llamar a métodos en esa variable. Esto te resultará familiar:

variable.method()

Where variablees una variable que almacena una referencia a un objeto y methodes un método de esa clase.

Si desea hacer referencia a un campo (variable) de un objeto, también debe usar el operador de punto :

variable.field

Donde variablees una variable que almacena una referencia a un objeto y fieldes una variable de instancia (campo).


2. newoperador

Para crear un objeto de cierta clase, debe usar el newoperador. En general, esto es lo que parece crear un objeto:

Class variable = new Class(arguments);

Donde Classestá el nombre de la clase de la variablevariable así como el nombre de la clase del objeto a crear. Y variable es una variable que almacena una referencia al objeto creado. Y argumentses un marcador de posición para una lista de argumentos separados por comas pasados ​​al constructor.

La lista específica de argumentos que se pueden pasar la deciden los programadores que escriben la clase.

Ha creado objetos antes e incluso ha utilizado esta construcción en particular. No lo has olvidado, espero.

Scanner console = new Scanner(System.in);
int x = console.nextInt();

Scanner console— esto crea una consolevariable cuyo tipo es Scanner. — esto crea un nuevo objeto. Y el operador de asignación establece la variable igual a una referencia al objeto recién creado.new Scanner(System.in)Scannerconsole

En la segunda línea, llamamos al nextInt()método en el Scannerobjeto, utilizando la consolevariable, que almacena una referencia al Scannerobjeto.

Ejemplos de creación de objetos:

Código Descripción
String s = new String("Hello");
Crear un Stringobjeto
Scanner console = new Scanner("");
Crear un Scannerobjeto
int[] data = new int[10];
Crear un int[]: un contenedor de 10 intelementos

Los objetos creados se denominan objetos de la clase o instancias de la clase , mientras que la clase se denomina clase del objeto . Por ejemplo, la svariable almacena una referencia a una instancia de la Stringclase.



3. Introducción a las clases

Creo que ya has visto lo conveniente que es usar clases escritas por otros programadores. Pero, ¿qué hay de escribir tus propias clases?

¿Cómo sabes cuándo y dónde necesitas tu propia clase y cómo hacer una?

Los programadores suelen crear sus propias clases cuando quieren incorporar una nueva entidad al programa. ¿Suena confuso? Luego trataré de explicar, pero voy a empezar desde muy lejos.

grupo de datos

Simplificando un poco, podemos decir que un objeto en Java es un bloque de memoria que contiene las variables declaradas en una clase (campos de instancia). O, en otras palabras, variables combinadas en un grupo.

Digamos que su programa necesita almacenar las coordenadas de 100los puntos y necesita un método para mostrarlos en la pantalla. Esto se puede hacer usando arreglos. Por ejemplo, así:

class Solution
{
   public static void printPoints(int[] x, int[] y, int[] color)
   {
     for (int i = 0; i < x.length; i++)
       System.out.println("Color of (" + x[i] + ", " + y[i] + ") = " + color[i]);
   }

   public static void main(String[] args)
   {
     int[] x = new int[100];
     int[] y = new int[100];
     int[] color = new int[100];
     printPoints(x, y, color);
   }
}

Sería mucho más conveniente si tuviéramos un solo tipo para almacenar toda la información sobre un punto: x, y, color. Si tal tipo no existe en Java, puede crearlo usted mismo.

Para hacer esto, escribiremos código para una Pointclase:

public class Point
{
   public int x;
   public int y;
   public int color;
}

Ahora el código anterior se puede reescribir como:

class Solution
{
   public static void printPoints(Point[] points)
   {
     for (int i = 0; i < points.length; i++)
       System.out.println("Color of (" + points[i].x + ", " + point[i].y + ") = " + points[i].color);
   }

   public static void main(String[] args)
   {
     Point[] data = new Point[100];
     for (int i = 0; i < data.length; i++)
       data[i] = new Point();
     printPoints(data);
   }
}

Ahora agreguemos un método a la Pointclase que mostrará información sobre el objeto:

public class Point
{
   public int x;
   public int y;
   public int color;
   public void print()
   {
     System.out.println("Color of (" + x + ", " + y + ") = " + color);
   }
}

Ahora la Solutionclase se ve así:

class Solution
{
   public static void printPoints(Point[] points)
   {
     for (int i = 0; i < points.length; i++)
       points[i].print();
   }

   public static void main(String[] args)
   {
     Point[] data = new Point[100];
     for (int i = 0; i < data.length; i++)
       data[i] = new Point();
     printPoints(data);
   }
}

Ocultamos hábilmente las coordenadas del punto y la información de color dentro de la Pointclase junto con el método que muestra el estado del punto.

Las clases son una forma de gestionar la complejidad del programa. Un programa grande se vuelve menos complejo cuando se divide en muchas clases pequeñas.


4. Objetos mutables vs inmutables

Érase una vez, estudiamos constantes en Java y llegamos a una conclusión que no es muy reconfortante. Las constantes le permiten proteger las variables para que no se cambien, pero no pueden evitar cambios en los objetos a los que se refieren.

Para resolver este problema, a Java se le ocurrieron objetos constantes. O, como se les llama con más frecuencia, objetos inmutables.

Por cierto, ya conoces esa clase, cuyos objetos no se pueden cambiar: String. Un Stringobjeto permanece para siempre sin cambios después de que se crea. ¿Y cómo lograron esto los creadores de Java?

Primero, todas las variables de la Stringclase están ocultas, es decir, declaradas private.

En segundo lugar, no puede heredar la Stringclase: su declaración de clase incluye el finalmodificador.

En tercer lugar, y lo más interesante, todos los métodos de la Stringclase, que, en teoría, esperaría cambiar el objeto existente, en realidad no lo cambian, sino que devuelven uno nuevo.

Por ejemplo, el toUpperCase()método convierte todas las letras de la cadena en mayúsculas. Pero en lugar de cambiar el objeto sobre el que se llama al método, devuelve un nuevo Stringobjeto que consta de letras mayúsculas:

String text = "This is a very important message";
String message = text.toUpperCase();

Esto es lo que quedará en la memoria después de ejecutar este código:

Objetos mutables vs inmutables

Así que siéntete libre de pasar tus cadenas a cualquier método: nadie las cambiará.