¿Propósito de un constructor en Java?

¿Cuál es el propósito de un constructor? He estado aprendiendo Java en la escuela y me parece que un constructor es en gran medida redundante en las cosas que hemos hecho hasta ahora. Queda por ver si se produce un propósito, pero hasta ahora no parece tener sentido para mí. Por ejemplo, ¿cuál es la diferencia entre los siguientes dos fragmentos de código?

public class Program { public constructor () { function(); } private void function () { //do stuff } public static void main(String[] args) { constructor a = new constructor(); } } 

Así es como nos enseñaron a hacer cosas para las tareas, pero ¿no harían los de abajo lo mismo?

 public class Program { public static void main(String[] args) { function(); } private void function() { //do stuff } } 

El propósito de un constructor se me escapa, pero, de nuevo, todo lo que hemos hecho hasta ahora ha sido extremadamente rudimentario.

Los constructores se utilizan para inicializar las instancias de sus clases. Utiliza un constructor para crear nuevos objetos a menudo con parámetros que especifican el estado inicial u otra información importante sobre el objeto

Desde el tutorial oficial de Java :

Una clase contiene constructores que se invocan para crear objetos a partir del plano de la clase. Las declaraciones de constructor parecen declaraciones de método, excepto que usan el nombre de la clase y no tienen tipo de devolución. Por ejemplo, Bicycle tiene un constructor:

 public Bicycle(int startCadence, int startSpeed, int startGear) { gear = startGear; cadence = startCadence; speed = startSpeed; } 

Para crear un nuevo objeto Bicycle llamado myBike , el nuevo operador llama a un constructor:

Bicicleta myBike = bicicleta nueva (30, 0, 8);

new Bicycle(30, 0, 8) crea espacio en la memoria para el objeto e inicializa sus campos.

Aunque Bicycle solo tiene un constructor, podría tener otros, incluido un constructor sin argumentos:

bicicleta pública () {engranaje = 1; cadencia = 10; velocidad = 0; }

Bicycle yourBike = new Bicycle(); invoca el constructor sin argumentos para crear un nuevo objeto Bicycle llamado yourBike.

Un constructor es básicamente un método que puede usar para garantizar que los objetos de su clase nazcan válidos . Esta es la principal motivación para un constructor.

Digamos que desea que su clase tenga un único campo entero que siempre debe ser mayor que cero. ¿Cómo lo haces de una manera confiable?

 public class C { private int number; public C(int number) { setNumber(number); } public void setNumber(int number) { if (number < 1) { throws IllegalArgumentException("C cannot store anything smaller than 1"); } this.number = number; } } 

En el código anterior, puede parecer que estás haciendo algo redundante, pero de hecho te estás asegurando de que el número sea siempre válido sin importar qué.

"inicializar las instancias de una clase" es lo que hace un constructor, pero no la razón por la que tenemos constructores. La pregunta es sobre el propósito de un constructor. También puede inicializar instancias de una clase externamente, utilizando c.setNumber(10) en el ejemplo anterior. Entonces, un constructor no es la única forma de inicializar instancias.

El constructor hace eso pero de una manera segura . En otras palabras, una clase sola resuelve todo el problema de garantizar que sus objetos estén siempre en estados válidos. No usar un constructor dejará tal validación al mundo exterior, que es un mal diseño.

Aquí hay otro ejemplo:

 public class Interval { private long start; private long end; public Interval(long start, long end) { changeInterval(start, end); } public void changeInterval(long start, long end) { if (start >= end) { throw new IllegalArgumentException("Invalid interval."); } this.start = start; this.end = end; } public long duration() { return end - start; } } 

La clase Interval representa un intervalo de tiempo. El tiempo se almacena usando mucho tiempo. No tiene sentido tener un intervalo que finalice antes de que comience. Al usar un constructor como el anterior, es imposible tener una instancia de Intervalo en cualquier momento dado en cualquier parte del sistema que almacene un intervalo que no tenga sentido.

Como se menciona en la respuesta de LotusUNSW, los constructores se utilizan para inicializar las instancias de una clase.

Ejemplo:

Digamos que tiene una clase de Animal algo así como

 class Animal{ private String name; private String type; } 

Veamos qué sucede cuando intentas crear una instancia de la clase Animal, por ejemplo, un Dog llamado Puppy . Ahora tiene que inicializar name = Puppy y type = Dog . Entonces, ¿cómo puedes hacer eso? Una forma de hacerlo es tener un constructor como

  Animal(String nameProvided, String typeProvided){ this.name = nameProvided; this.type = typeProvided; } 

Ahora cuando creas un objeto de la clase Animal , algo así como Animal dog = new Animal("Puppy", "Dog"); se llama a su constructor e inicializa el nombre y el tipo de los valores que proporcionó, es decir, Puppy y Dog, respectivamente.

Ahora podría preguntar qué pasaría si no le di un argumento a mi constructor algo así como

 Animal xyz = new Animal(); 

Este es un default Constructor que inicializa el objeto con los valores por defecto, es decir, en nuestro name clase Animal y los valores de type correspondientes al objeto xyz serían name = null y type = null

Un constructor inicializa un objeto cuando se crea. Tiene el mismo nombre que su clase y es sintácticamente similar a un método, pero el constructor no tiene un tipo de retorno expicit. Típicamente, usamos el constructor para dar un valor inicial a las variables de instancia definidas por la clase, o para realizar cualquier otro procedimiento de inicio requerido para hacer un objeto completamente formado.

Aquí hay un ejemplo de constructor:

 class queen(){ int beauty; queen(){ beauty = 98; } } class constructor demo{ public static void main(String[] args){ queen arth = new queen(); queen y = new queen(); System.out.println(arth.beauty+" "+y.beauty); } } 

salida es:

 98 98 

Aquí el constructor es:

 queen(){ beauty =98; } 

Ahora el giro del constructor parametrizado.

  class queen(){ int beauty; queen(int x){ beauty = x; } } class constructor demo{ public static void main(String[] args){ queen arth = new queen(100); queen y = new queen(98); System.out.println(arth.beauty+" "+y.beauty); } } 

salida es:

 100 98 
  • A través de un constructor (con parámetros), puede ‘pedir’ al usuario de esa clase las dependencias requeridas.
  • Se usa para inicializar variables de instancia
  • y pasar argumentos al constructor de una súper clase ( super(...) ), que básicamente hace lo mismo
  • Puede inicializar variables de instancia (finales) con código, que puede arrojar Excepciones, a diferencia de los scopes del inicializador de instancias
  • Uno no debe llamar ciegamente a los métodos desde dentro del constructor, porque la inicialización puede no estar terminada / suficiente en la clase local o derivada.

Se usa para configurar los contenidos y el estado de tu clase. Si bien es cierto que puedes hacer un ejemplo más simple con el método principal, solo tienes 1 método principal por aplicación, por lo que no es un enfoque sensato.

Considere el método principal para simplemente iniciar su progtwig y no debe saber más que cómo hacerlo. También tenga en cuenta que main () es estático por lo que no puede llamar a funciones que requieren una instancia de clase y el estado asociado. El método principal debe llamar al nuevo Progtwig (). Function () y el constructor del Progtwig no debe llamar a la función () a menos que sea necesario para la configuración de la clase.

La definición de clase define la API para su clase. En otras palabras, es un proyecto que define el contrato que existe entre la clase y sus clientes, el otro código que usa esta clase. El contrato indica qué métodos están disponibles, cómo llamarlos y qué esperar a cambio.

Pero la definición de clase es una especificación. Hasta que tenga un objeto real de esta clase, el contrato es solo “una hoja de papel”. Aquí es donde entra el constructor

Un constructor es el medio para crear una instancia de su clase creando un objeto en la memoria y devolviéndole una referencia. Algo que debería suceder en el constructor es que el objeto está en un estado inicial adecuado para que las operaciones posteriores en el objeto tengan sentido.

Este objeto devuelto por el constructor ahora respetará el contrato especificado en la definición de clase, y puede usar este objeto para hacer un trabajo real.

Piénsalo de esta manera. Si alguna vez observas el sitio web de Porsche, verás lo que puede hacer: la potencia, el par motor, etc. Pero no es divertido hasta que tienes un Porsche real para conducir.

Espero que ayude.

Constructor se usa básicamente para inicializar las variables en el momento de la creación del objeto

Un constructor de Java tiene el mismo nombre que el nombre de la clase a la que pertenece.

La syntax de Constructor no incluye un tipo de devolución, ya que los constructores nunca devuelven un valor.

Siempre se llama al constructor cuando se crea un objeto. ejemplo: – Constructor por defecto

 class Student3{ int id; String name; void display(){System.out.println(id+" "+name);} public static void main(String args[]){ Student3 s1=new Student3(); Student3 s2=new Student3(); s1.display(); s2.display(); } } 

Salida:

 0 null 0 null 

Explicación: en la clase anterior, no está creando ningún constructor para que el comstackdor le proporcione un constructor predeterminado. Aquí, el constructor predeterminado proporciona valores nulos y nulos.

Ejemplo de constructor parametrizado

En este ejemplo, hemos creado el constructor de la clase Student que tiene dos parámetros. Podemos tener cualquier cantidad de parámetros en el constructor.

 class Student4{ int id; String name; Student4(int i,String n){ id = i; name = n; } void display(){System.out.println(id+" "+name);} public static void main(String args[]){ Student4 s1 = new Student4(111,"Karan"); Student4 s2 = new Student4(222,"Aryan"); s1.display(); s2.display(); } } 

Salida:

 111 Karan 222 Aryan 

Pensé que un constructor podría funcionar como una base de datos en la que solo define variables y métodos para controlarlos

Luego vi objetos que usan variables y métodos no definidos en su constructor. Entonces la discusión que tiene más sentido para mí es la que prueba los valores de las variables para la validez, pero la clase puede crear variables y métodos que no están definidos en el constructor, menos como una base de datos y más como una válvula de sobrepresión en un vapor locomotora. No controla las ruedas, etc.

Mucho menos de una definición de lo que pensaba.

Constructor será útil para evitar que las instancias obtengan valores irreales. Por ejemplo, establezca una clase Persona con altura, peso. No puede haber una Persona con 0m y 0kg

Bueno, primero voy a decir los errores en dos fragmentos de código.

Primer fragmento de código

 public class Program { public constructor() // Error - Return type for the method is missing { function(); } private void function() { //do stuff } public static void main(String[] args) { constructor a = new constructor(); // Error - constructor cannot be resolved to a type } } 

Como puede ver el código anterior, el nombre del constructor no es el mismo que el nombre de la clase. En el método main() está creando un objeto a partir de un método que no tiene un tipo de devolución.

Segundo fragmento de código

 public class Program { public static void main(String[] args) { function(); // Error - Cannot make a static reference to the non-static method function() from the type Program } private void function() { //do stuff } } 

Ahora, en este fragmento de código, intenta crear una referencia estática a la función de método no estático () del tipo Program , que no es posible.

Entonces la posible solución es esto,

Primer fragmento de código

 public class Program { public Program() { function(); } private void function() { //do stuff } public static void main(String[] args) { Program a = new Program(); a.function(); } } 

Segundo fragmento de código

 public class Program { public static void main(String[] args) { Program a = new Program(); a.function(); } private void function() { //do stuff } } 

Finalmente, la diferencia entre los fragmentos de código es que, en el primer fragmento de código, el nombre de la clase no es el mismo que el nombre de la clase

Mientras que en el segundo fragmento de código no hay un constructor definido.

Mientras tanto, para entender el propósito de los recursos de referencia del constructor a continuación,

https://docs.oracle.com/javase/7/docs/api/java/lang/reflect/Constructor.html

http://www.flowerbrackets.com/learn-constructor-in-java/

http://www.flowerbrackets.com/java-constructor-example/

Consideremos que estamos almacenando los detalles del estudiante de 3 estudiantes. Estos 3 estudiantes tienen diferentes valores para sno, sname y sage, pero los 3 estudiantes pertenecen al mismo departamento CSE. Por lo tanto, es mejor inicializar la variable “departamento” dentro de un constructor para que este valor pueda ser tomado por los 3 objetos estudiantiles.

Para entender claramente, vea el siguiente ejemplo simple:

 class Student { int sno,sage; String sname,dept; Student() { dept="CSE"; } public static void main(String a[]) { Student s1=new Student(); s1.sno=101; s1.sage=33; s1.sname="John"; Student s2=new Student(); s2.sno=102; s2.sage=99; s2.sname="Peter"; Student s3=new Student(); s3.sno=102; s3.sage=99; s3.sname="Peter"; System.out.println("The details of student1 are"); System.out.println("The student no is:"+s1.sno); System.out.println("The student age is:"+s1.sage); System.out.println("The student name is:"+s1.sname); System.out.println("The student dept is:"+s1.dept); System.out.println("The details of student2 are");`enter code here` System.out.println("The student no is:"+s2.sno); System.out.println("The student age is:"+s2.sage); System.out.println("The student name is:"+s2.sname); System.out.println("The student dept is:"+s2.dept); System.out.println("The details of student2 are"); System.out.println("The student no is:"+s3.sno); System.out.println("The student age is:"+s3.sage); System.out.println("The student name is:"+s3.sname); System.out.println("The student dept is:"+s3.dept); } } 

Salida:

Los detalles de student1 son
El estudiante no es: 101
La edad del estudiante es: 33
El nombre del estudiante es: John
El departamento de estudiantes es: CSE
Los detalles de student2 son
El estudiante no es: 102
La edad del alumno es: 99
El nombre del estudiante es: Peter
El departamento de estudiantes es: CSE
Los detalles de student2 son
El estudiante no es: 102
La edad del alumno es: 99
El nombre del estudiante es: Peter
El departamento de estudiantes es: CSE