Métodos Constructores en Java: Creación y Uso Efectivo
Resumen
El Método Constructor es el primer método que se ejecuta por defecto cuando creamos una clase, nos permite crear nuevas instancias de una clase. Lo invocamos con la palabra reservada new seguida del nombre con el que inicializamos la clase y paréntesis.
// nombreDeLaInstancia = new MétodoConstructor();myDoctor =newDoctor();
El compilador de Java crea un método constructor en caso de que no definamos uno, pero de todas formas es muy buena idea programarlo nosotros, ya que nos permite definir y/o configurar el comportamiento de nuestros objetos usando argumentos.
publicclassDoctor{// Atributos...// Método Constructor:Doctor(/* parámetros */){// Instrucciones que se ejecutan al crear/instanciar// un nuevo objeto con la clase Doctor...}}
El método constructor no debe regresar ningún valor (no necesitamos un return). Más adelante estudiaremos un poco más a fondo cómo funcionan la sobrecarga de métodos y sobrecarga de constructores.
En el constructor con parámetro solo imprime el string con el parámetro, no asigna el valor al atributo.
Ejem:
Doctor myDoctor =newDoctor("Samuel");myDoctor.showName();myDoctor.name="Israel Yance";myDoctor.showName();
Output:
El nombre del Doctor asignado es:SamuelnullIsraelYance
El null confirma que el valor no fue asignado.
Aunque sea un poco tarde mi aporte... pero espero ayudarte y a otros.
Cuando defines un constructor en una clase, NO es para que pases parámetros, sino asignar los valores a las propiedades para que tú objeto tenga el alcance a cada uno de los métodos definidos en la clase... el constructor, "carga la clase", a partir de ahí, es el objeto quien empieza a determinar su comportamiento.
Fuera de ahí, nunca... pero jamás de los jamaces, puedes modificar los valores de la propiedades de una clase de "forma directa" porque no tienes el alcance, por eso te retorna NULL.
Gracias por tu aporte.
👇 APUNTES DE LA CLASE
Magali me gusta mucho tus apuntes
Gracias Andrés! me alegra que te sean útiles 😊
En el método constructor Doctor(String name), el parámetrro "name" es local, solo es válido para dicho método constructor, mientras que la propiedad "name" de la clase "Doctor" es válido para el alcance de la clase y de las instancias de ésta.
buena explicacion, tome si like buen homnre
Muy buena explicación, gracias
Si le asignas el nombre en los Atributos, queda como nombre por defecto en todos los objetos que se creen en esa Clase.
Si le asignas el nombre a través del constructor, el nombre se lo daremos cada vez que creemos un objeto, y ese nombre será el que le demos en ese momento (no tendrá ningún nombre hasta que se lo demos).
publicclassMain{publicstaticvoidmain(String[] args){//ESTAMOS USANDO MODULARIDAD/*
* Doctor myDoctor = new Doctor();
* new Doctor(); es un metodo CONSTRUCTOR
* nos ayuda a crear una instancia
* puede tener uno a mas arguantos
* los cosntructores no retornan un valor
* */Doctor myDoctor =newDoctor("Diego Lipa");//instanciando la clase DOCTOR //CONSTRUCTOR = nos ayuda a crear una instancia myDoctor.name="Diego Lipa"; myDoctor.showName();}}
publicclassDoctor{//es es una Clase -> la close es diferende a un objeto int id;String name;String speciality;Doctor(String name){System.out.println("Construyendo el Objeto Doctor");System.out.println("El doctor Asignado es: "+ name);}//Comportamientos/* void = ningun valor de retorno*/publicvoidshowName(){System.out.println(name);}}
Muchas gracias!!!
Para evitar tener varios constructores podríamos utilizar el patrón Builder.
Curso de patrones de diseño !!!!!!!! XD
Patrones de Diseño
Una muy buena idea el tener un curso de patrones de diseño que se aplica a cualquier lenguaje de programación orientado a objetos.
Deberían ponerlo. 🤣
La argumento "name" de el segundo constructur solo vive o tiene el alcance dentro de el metodo constructor y fuera de el metodo no existe su valor .
La inicializacion de la variable myDoctor.name = "Alejandro Rodriguez"; tiene un alcance global dentro de la clase Doctor y esta variable podria ser utilizada dentro de cualquier metodo de la clase Doctor.
1-- Se construye un objeto “myDoctor” a partir de un nombre: “Anahí Salgado”. A partir de un nombre porque en la definición del constructor no se setea el atributo nombre, solo se imprime el nombre que se le está pasando como parámetro.
Doctor(String name){System.out.println("El nombre del Doctor asignado es: "+ name);//Utilizar esta linea para representar que un doctor tenga el nombre del atributo name que se especifique. //this.name = name; }
1.1-- Tener en cuenta o probar:
// El sistema imprime: El nombre del Doctor asignado es: Anahí Salgado
Doctor myDoctor =newDoctor("Anahí Salgado");
1.2-- Adicionando esta nueva línea luego de la creación del objeto myDoctor. A este punto el sistema imprime: null porque nunca se seteó el valor del atributo name, que a partir de lo expresado anteriormente se podría hacer en el constructor.
myDoctor.showName();
2-- Se setea/actualiza el nombre del objeto “myDoctor” a "Alejandro Rodríguez"
myDoctor.name="Alejandro Rodríguez";
2.1-- Tener en cuenta que esto es posible porque en la definición de la clase Doctor, en este caso el atributo “name” tiene el
modificador de acceso “default”, por lo que puede ser accesible por cualquier clase que esté dentro del mismo paquete. En este caso la clase Main (que es donde se accede a este atributo) está dentro del mismo paquete que la clase Doctor.
myDoctor.name="Alejandro Rodríguez";
3-- A este punto se muestra el nombre “Alejandro Rodríguez” porque se seteó con la línea de código anterior
myDoctor.showName();```
genial, eso me faltaba a mi, que lo hago en netbeans 12 con java jdk 12
En el caso del segundo constructor, debido a que en ningún momento se realiza una asignación (this.name = name), el nombre asignado al constructor solo sirve para la impresión, mas no remane en el objeto myDoctor.
Así convencí a mi nena de ponernos a ver la clase:
publicclassGato{//atributosString nombre; boolean seDejaAgarrar; int patas =4; boolean cola =true; int orejas =2; int ojos =2;String colorPelo;//Método constructorGato(String nombre, boolean seDejaAgarrar){this.nombre= nombre;this.seDejaAgarrar= seDejaAgarrar;System.out.println("¡Mira, un gato!");this.hacerMiau();this.dejarseAgarrar();System.out.println("");}//comportamientos (métodos)publicvoidhacerMiau(){System.out.println("Este gato intenta manipularte. ");System.out.println(this.nombre+": Miau");}publicvoiddejarseAgarrar(){if(seDejaAgarrar){System.out.println(this.nombre+" se deja agarrar.");}else{System.out.println(this.nombre+" sale corriendo.");}}}Gato spock2 =newGato("Spock II",true);Gato gatosfera =newGato("La Gatósfera",false);
Excelente, esta muy bueno el ejemplo
Cuando lo pasa por el constructor simplemente lo imprime en pantalla pero no lo asigna como nombre al objeto doctor.
¿Por qué no pones public o private antes del nombre del Método Constructor Anahí?
Por defecto se pone default, que es el alcance dentro del paquete, asi que de igual manera funciona
Para generar el constructor automáticamente se oprime Alt+Insert y se selecciona constructor.
La diferencia es que una es respecto al alcance oh nivel de acceso de la variable.
-Una variable declarada como campo de clase puede ser accedida oh usada por todos lo métodos y objetos de la clase.
Una variable declarada dentro de un método solo puede ser accedida oh usada por el mismo.
Que significa "instanciar" ?¿
Toca mucho esa palabra pero no tengo definido a que intenta referirse excatamente.
Se le llama Instanciar a la acción de crear un objeto a partir de una clase. nada que usas la palabra reservada new estás creando una instancia de la clase que especificaste.
Muchas gracias
Dejame ordenar la idea , entonces :
Se llama instanciar a la acción de crear un objeto a partir de una clase , por tanto cuando se usa la palabra reservada "new" , se procede a instanciar un objeto de la clase especificada.
A la hora de escribir el parámetro main, pueden solo escribir las comillas dentro del paréntesis y hará un auto completado.
Doctor myDoctor =newDoctor("daniel");
Los constructores nunca son heredados, ya que no son considerados como miembros de clase. Esto es una diferencia importante con respecto a los métodos ya que estos si podrían ser heredados.
La diferencia es que si lo pones afuera del constructor la variable sera global: visible para toda la clase; si lo declaras dentro del constructor esa variable solo vivirá dentro del constructor.
La segunda opción de constructor Doctor(String name) nos abre la puerta a siempre indicar el nombre del médico cuando se cree el objeto (siempre y cuando se haga el this.name = name dentro del constructor)
El valor del parámetro name que se imprime desde constructor solo vive en ese contexto dentro del método constructor en cambio la variable del atributo name vive como referencia dentro del objeto