ejemplo - text box java
Constructor por defecto de Java (11)
Cuando no definimos explícitamente un constructor para una clase, java crea un constructor predeterminado para la clase. Es esencialmente un constructor no parametrizado, es decir, no acepta ningún argumento.
El trabajo del constructor predeterminado es llamar al constructor de la superclase e inicializar todas las variables de instancia. Si el constructor de la superclase no está presente, entonces inicializa automáticamente las variables de instancia a cero. Por lo tanto, eso sirve para usar el constructor, que es para inicializar el estado interno de un objeto para que el código que crea una instancia tenga un objeto totalmente inicializado y utilizable.
Una vez que definimos nuestro propio constructor para la clase, el constructor predeterminado ya no se usa. Entonces, ninguno de ellos es realmente un constructor predeterminado.
¿Qué es exactamente un constructor predeterminado? ¿Puede decirme cuál de los siguientes es un constructor predeterminado y qué lo diferencia de cualquier otro constructor?
public Module() {
this.name = "";
this.credits = 0;
this.hours = 0;
}
public Module(String name, int credits, int hours) {
this.name = name;
this.credits = credits;
this.hours = hours;
}
El compilador genera automáticamente un constructor predeterminado si no define explícitamente al menos un constructor en su clase. Has definido dos, por lo que tu clase no tiene un constructor predeterminado.
Según la tercera edición de la especificación de lenguaje de Java :
8.8.9 Constructor predeterminado
Si una clase no contiene declaraciones de constructor, entonces se proporciona automáticamente un constructor predeterminado que no toma parámetros ...
Espero que tengas tu respuesta con respecto a cuál es el constructor predeterminado. Pero estoy dando declaraciones a continuación para corregir los comentarios dados.
Java no inicializa ninguna variable local a ningún valor predeterminado. Entonces, si está creando un Objeto de una clase, llamará al constructor predeterminado y le proporcionará los valores predeterminados a Objeto.
El constructor predeterminado proporciona los valores predeterminados para el objeto como 0, nulo, etc., según el tipo.
Por favor, consulte el enlace a continuación para obtener más detalles.
Hola. Según mi conocimiento, permítanme aclarar el concepto de constructor predeterminado:
El compilador proporciona automáticamente un constructor predeterminado sin argumentos para cualquier clase sin constructores. Este constructor predeterminado llamará al constructor sin argumentos de la superclase. En esta situación, el compilador se quejará si la superclase no tiene un constructor sin argumentos, por lo que debe verificar que sí lo hace. Si su clase no tiene una superclase explícita, entonces tiene una superclase implícita de Object, que sí tiene un constructor sin argumentos.
Leí esta información de los Tutoriales de Java .
Java proporciona un constructor predeterminado que no toma argumentos y no realiza acciones especiales o inicializaciones, cuando no se proporcionan constructores explícitos.
La única acción que realiza el constructor predeterminado implícito es llamar al constructor de la superclase utilizando la llamada super (). Los argumentos de constructor le proporcionan una forma de proporcionar parámetros para la inicialización de un objeto.
A continuación se muestra un ejemplo de una clase de cubo que contiene 2 constructores. (un constructor predeterminado y uno parametrizado).
public class Cube1 {
int length;
int breadth;
int height;
public int getVolume() {
return (length * breadth * height);
}
Cube1() {
length = 10;
breadth = 10;
height = 10;
}
Cube1(int l, int b, int h) {
length = l;
breadth = b;
height = h;
}
public static void main(String[] args) {
Cube1 cubeObj1, cubeObj2;
cubeObj1 = new Cube1();
cubeObj2 = new Cube1(10, 20, 30);
System.out.println("Volume of Cube1 is : " + cubeObj1.getVolume());
System.out.println("Volume of Cube1 is : " + cubeObj2.getVolume());
}
}
Ninguno de ellos. Si lo defines, no es el predeterminado.
El constructor predeterminado es el constructor sin argumentos generado automáticamente a menos que defina otro constructor. Inicializa cualquier campo no inicializado a sus valores predeterminados. Para su ejemplo, se vería así suponiendo que los tipos son String , int e int :
public Module()
{
super();
this.name = null;
this.credits = 0;
this.hours = 0;
}
Esto es exactamente lo mismo que
public Module()
{}
Y exactamente lo mismo que no tener constructores en absoluto. Sin embargo, si define al menos un constructor, el constructor predeterminado no se genera.
Referencia: Especificación del lenguaje Java
Aclaración
Técnicamente, no es el constructor (predeterminado u otro) el que inicializa los campos por defecto. Sin embargo, estoy dejando esto en la respuesta como
- la pregunta obtuvo los valores predeterminados incorrectos y
- incluyéndolos o no, el constructor tiene exactamente el mismo efecto.
Se crea un constructor predeterminado si no define ningún constructor en su clase. Simplemente es un constructor sin argumentos que no hace nada. Editar: excepto llamada super ()
public Module(){
}
Si una clase no tiene ningún constructor provisto por el programador, entonces el compilador java agregará un constructor predeterminado sin parámetros que llamará al constructor de la clase superior internamente con la llamada super (). Esto se llama como constructor predeterminado.
En su caso, no hay un constructor predeterminado ya que los está agregando programáticamente. Si usted no agrega constructores, entonces el compilador generado por el compilador se verá así.
public Module()
{
super();
}
Nota : En el constructor predeterminado lateral, agregará la llamada super () también, para llamar al constructor de la superclase.
Propósito de agregar constructor predeterminado:
El deber de Constructor es inicializar variables de instancia; si no hay variables de instancia, puede elegir eliminar el constructor de su clase. Pero cuando hereda una clase, es responsabilidad de su clase llamar al constructor de la superclase para asegurarse de que la superclase inicialice correctamente todas sus variables de instancia.
Es por eso que si no hay constructores, el compilador Java agregará un constructor predeterminado y llamará al constructor de la superclase.
Un constructor predeterminado no toma ningún argumento:
public class Student {
// default constructor
public Student() {
}
}
el constructor predeterminado se refiere a un constructor que el compilador genera automáticamente en ausencia de cualquier constructor definido por el programador.
Si el programador no proporciona ningún constructor, el compilador declara implícitamente un constructor predeterminado que llama a super() , no tiene cláusula throws ni parámetros formales.
P.ej
class Klass {
// Default Constructor gets generated
}
new Klass(); // Correct
-------------------------------------
class KlassParameterized {
KlassParameterized ( String str ) { //// Parameterized Constructor
// do Something
}
}
new KlassParameterized(); //// Wrong - you need to explicitly provide no-arg constructor. The compiler now never declares default one.
--------------------------------
class KlassCorrected {
KlassCorrected (){ // No-arg Constructor
/// Safe to Invoke
}
KlassCorrected ( String str ) { //// Parameterized Constructor
// do Something
}
}
new KlassCorrected(); /// RIGHT -- you can instantiate
La terminología general es que si no proporciona ningún constructor en su objeto, se coloca automáticamente un constructor sin argumentos que se llama constructor predeterminado.
Si define un constructor igual al que se colocaría si no proporciona ninguno, generalmente se denomina como no constructor de argumentos. Sin embargo, es una convención, ya que algunos programadores prefieren llamar a este constructor de argumentos no definidos explícitamente como constructor predeterminado. Pero si vamos a nombrar si definimos explícitamente uno, no lo convierte en predeterminado.
Según los documentos
Si una clase no contiene declaraciones de constructor, entonces se declara implícitamente un constructor predeterminado sin parámetros formales y ninguna cláusula throws.
Ejemplo
public class Dog
{
}
se modificará automáticamente (agregando el constructor predeterminado) de la siguiente manera
public class Dog{
public Dog() {
}
}
y cuando creas su objeto
Dog myDog = new Dog();
este constructor predeterminado es invocado.