Métodos Constructores en Java: Creación y Uso Efectivo
Contenido del curso
Israel Yance
Usuario anónimo
User
Jhan Leonardo García Marroquín
Magali Maribel García
Andrés Felipe Lopez gomez
Magali Maribel García
Gerson Alexander Aley Aley
Alan Díaz Díaz
Alejandro Ching
Mònica Mateu
Diego Frank Lipa Choque
Alejandro Ching
Robinson Ganchala
Miguel Angel Junior Rodriguez Valda
Robinson Ganchala
Henrry Coca Campero
Lisney Isabel Rosales Céspedes
ZR Axell
Alberto Gobbi
Shelley Valdés Herrera
Andrés Felipe Lopez gomez
Hugo Andres Benjumea Alvear
Ivan Farid Espadas Escalante
David Carrillo Castillo
Franco Pignanelli
Camilo Ramirez Castillo
Fabio Tovio
Carlos Alfredo Soria Añez
Juan Daniel Martínez Navarro
Carlos Alfredo Soria Añez
Daniel Alejandro López Linares
Alejandro Sebastian Dubon Estrada
Gerald Zamora
edgar limones lozano
Juan Esteban Jandres Rivera
En el constructor con parámetro solo imprime el string con el parámetro, no asigna el valor al atributo.
Ejem:
Doctor myDoctor = new Doctor("Samuel"); myDoctor.showName(); myDoctor.name = "Israel Yance"; myDoctor.showName();
Output:
El nombre del Doctor asignado es: Samuel null Israel Yance
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).
public class Main { public static void main(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 = new Doctor("Diego Lipa"); //instanciando la clase DOCTOR //CONSTRUCTOR = nos ayuda a crear una instancia myDoctor.name="Diego Lipa"; myDoctor.showName(); } }
public class Doctor { //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*/ public void showName(){ 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 = new Doctor("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:
public class Gato { //atributos String nombre; boolean seDejaAgarrar; int patas = 4; boolean cola = true; int orejas = 2; int ojos = 2; String colorPelo; //Método constructor Gato(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) public void hacerMiau(){ System.out.println("Este gato intenta manipularte. "); System.out.println(this.nombre + ": Miau"); } public void dejarseAgarrar(){ if (seDejaAgarrar){ System.out.println(this.nombre + " se deja agarrar."); }else{ System.out.println(this.nombre + " sale corriendo."); } } } Gato spock2 = new Gato("Spock II", true); Gato gatosfera = new Gato("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
Les comparto este video donde se ve en profundidad el método constructor, tanto por defecto como parametrizado https://www.youtube.com/watch?v=btMiDw8pLe0&list=PLhU2otMFcLuCQPcEcRQfi3UQQ-ms5YH0L&index=12
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.
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 = new Doctor("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.
Fuente: https://es.stackoverflow.com/questions/26296/constructores-en-java
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