1. Crear un objeto

Bueno, hemos llegado a la creación de objetos. Ya te encontraste con esto antes, pero ahora analizaremos este tema con más detalle. En realidad, es muy fácil crear objetos.

Para crear un objeto, debe utilizar el operador new . La creación de un objeto se ve aproximadamente así:

new Class(arguments)

Después de crear un objeto, la mayoría de las veces guardamos inmediatamente una referencia a él en una variable, que muy a menudo comparte el mismo tipo que el objeto creado. Eso significa que al crear un objeto, generalmente verá un código como este:

Class name = new Class(arguments)

Donde es la creación de una nueva variable, y el código a la derecha del signo igual es la creación de un nuevo objeto cuyo tipo es .Class nameClass

Ejemplos:

Código Nota
Object o = new Object();
Crear un Objectobjeto
Cat pet = new Cat();
Crear un Catobjeto
Scanner console = new Scanner(System.in)
Crear un Scannerobjeto

Los programadores a menudo nombran las variables según sus clases, pero con una letra minúscula. Para un programador novato, dicho código puede resultar confuso:

Código
BufferedReader bufferedReader = new BufferedReader( reader );
Cat cat = new Cat();
PersonInfo personInfo = new PersonInfo()

No hay nada de malo con este código: este es el código más común, en el que se crea una variable y luego se inicializa inmediatamente por un objeto de su mismo tipo.

A la izquierda del signo igual tenemos la creación de una variable. A la derecha, la creación de un objeto. Eso es todo.

2. Constructor

Probablemente haya visto que algunos argumentos se pasan con frecuencia al crear un objeto. Además, se pasan argumentos para algunos objetos, pero no para otros. ¿Cómo funciona todo este mecanismo con argumentos?

Todo es simple aquí también: cada clase tiene un método especial (o métodos) que son responsables de manejar los argumentos pasados ​​al crear un objeto. Estos métodos se llaman constructores . O cuando hablamos de uno solo: el constructor .

Distinguir un método constructor de un método regular es fácil. Este método tiene dos características distintivas:

  • el nombre de un constructor es el mismo que el nombre de su clase (y comienza con una letra mayúscula)
  • un constructor no tiene tipo de retorno.

En general, así es como suele verse:

modifiers Class(arguments)
{
   Code
}

Ejemplo:

Código Nota
public class Point
{
   public int x;
   public int y;

   Point(int x, int y)
   {
      this.x = x;
      this.y = y;
   }
}
Point




Pointconstructor de clase
public class Solution
{
   public static void main(String[] args)
   {
      Point point = new Point(5, 10);
   }
}




Crea un objeto de la Pointclase. Se llamará al constructor de la clase.

Observe cómo se ve el constructor: no tiene tipo de devolución y su nombre es el mismo que el nombre de la clase.

Y una cosa más: echa un vistazo al código dentro del constructor. Los parámetros del constructor tienen los mismos nombres que los campos de la clase: x e y. Es una práctica estándar evitar inventar nuevos nombres de parámetros. Los nombres son los mismos que los de los campos de la clase. El conflicto de nombres se resuelve con la palabra clave this.

3. Llamar a un constructor

Cuando usa el operador new y un comando como "nueva clase ( argumentos )" para crear un nuevo objeto, suceden dos cosas:

  • La máquina Java crea un objeto cuyo tipo es Clase
  • La máquina Java llama al constructor del objeto y pasa sus argumentos

Como programador, puede decidir qué constructores debe tener su clase y qué parámetros deben tener estos constructores.

Suponga que decide crear una clase para realizar un seguimiento de los gatos en un refugio de animales. Entonces tu Catclase podría verse así:

class Cat
{
   public String name;
   public int age;

   public Cat(String name, int age)
   {
      this.name = name;
      this.age = age;
   }
}
Cat cat = new Cat("Whiskers", 2);
esto está permitido
Cat cat = new Cat("Whiskers");
Pero esto no está permitido. Este código no se compilará.
Cat cat = new Cat();
Y esto no está permitido. Este código no se compilará.

La Catclase tiene solo un constructor con parámetros de nombre y edad. Debido a que no hay otros constructores, debe pasar el nombre del gato ( name) y la edad ( age) como argumentos al crear un objeto. Pasar argumentos al constructor no es opcional .

4. Múltiples constructores

Pero si lo necesita, puede agregar varios constructores a la clase. No hay límite en el número de constructores o sus parámetros. Cuando crea un objeto, el compilador selecciona automáticamente el constructor que coincide con los parámetros

Código Nota
class Cat
{
   public static final int UNKNOWN = -1;
   public String name;
   public int age;

   public Cat(String name, int age)
   {
      this.name = name;
      this.age = age;
   }
   public Cat(String name)
   {
      this.name = name;
      this.age = UNKNOWN; // Unknown
   }
}
Cat cat = new Cat("Whiskers", 2);
Esto está permitido: se llamará al primer constructor
Cat cat = new Cat("Whiskers");
Esto está permitido: se llamará al segundo constructor
Cat cat = new Cat();
Pero esto no está permitido. Este código no se compilará.

Decidimos tener en cuenta el hecho de que es posible que no se conozca la edad de un gato. Para manejar este caso, agregamos la constante especial UNKNOWNjunto con un constructor que tiene solo un parámetro: el nombre del gato.

Tenga en cuenta que todavía inicializamos ambas variables dentro de ambos constructores. Reemplazamos los parámetros desconocidos/faltantes con la constante UNKNOWN.

Si no se asigna ningún valor a la variable de edad, tendrá el valor predeterminado de 0. Después de todo, un gatito encontrado en la calle bien puede tener 0 años completos. Eso significa que un cero en la variable edad no significa necesariamente "edad desconocida".

5. Constructor por defecto

Si desea que se creen instancias de sus objetos sin ningún parámetro, su clase debe declarar un constructor sin argumentos.

Un constructor sin parámetros no es necesariamente un constructor sin código. Tal constructor puede contener código que inicializa variables con valores iniciales:

Código Nota
class Cat
{
   public static final int UNKNOWN = -1;
   public String name;
   public int age;

   public Cat(String name, int age)
   {
      this.name = name;
      this.age = age;
   }

   public Cat()
   {
      this.name = "Nameless";
      this.age = UNKNOWN; // Unknown
   }
}
Cat cat = new Cat("Whiskers", 2);
Esto está permitido: se llamará al primer constructor
Cat cat = new Cat();
Esto está permitido: se llamará al segundo constructor

Constructor predeterminado

Hay un punto muy importante que debes saber y recordar.

Si su clase no declara un constructor , el compilador agregará un constructor predeterminado, que es un constructor sin argumentos con el modificador público.

Pero si su clase declara incluso un constructor , entonces no se agregará ningún constructor predeterminado y deberá agregarlo usted mismo si lo desea.

Código Nota
class Cat
{
   public String name;
   public int age;
}
Cat cat = new Cat();
Esto está permitido: se llamará al constructor predeterminado

8
Tarea
Módulo 1. Java Syntax,  nivel 16lección 0
Bloqueada
Autoboxing
task1201
8
Tarea
Módulo 1. Java Syntax,  nivel 16lección 0
Bloqueada
Desempaquetado
task1202
8
Tarea
Módulo 1. Java Syntax,  nivel 16lección 0
Bloqueada
Comparando números
task1203