Curso de Java SE Orientado a Objetos

Curso de Java SE Orientado a Objetos

Anahí Salgado Díaz de la Vega

Anahí Salgado Díaz de la Vega

Método constructor

6/38
Recursos
Transcripción

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 = new Doctor();

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.

public class Doctor {
  // 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.

Aportes 178

Preguntas 12

Ordenar por:

¿Quieres ver más aportes, preguntas y respuestas de la comunidad? Crea una cuenta o inicia sesión.

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.

Cuando es por valor, la información de la variable se almacenan en una dirección de memoria diferente al recibirla en la función, por lo tanto si el valor de esa variable cambia !no!! afecta la variable original, solo se modifica dentro del contexto de la función.

Cuando es por referencia, la variable que se recibe como parámetro en la función apunta exactamente a la misma dirección de memoria que la variable original por lo que si dentro de la función se modifica su valor también se modifica la variable original.

Fuente

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).

Para evitar tener varios constructores podríamos utilizar el patrón Builder.

Curso de patrones de diseño !!! XD

👇 APUNTES DE LA CLASE

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();```





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.

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.

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.

Cuando lo pasa por el constructor simplemente lo imprime en pantalla pero no lo asigna como nombre al objeto doctor.

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.

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);

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

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

La razón por la que se salta el mensaje del primer constructor es por que cada clase solo puede tener un método constructor 🤔??

El contructor nos ayuda a inicializar atributos de una clase, nos ayuda a hacer instancias y tiene el mismo nombre que clase.

☕ Un método constructor en Java tiene el mismo nombre de la clase. Además siempre tendremos un constructor por defecto.

Desde mi punto de vista si ponemos el metodo constructor y le pasamos como argumento el name cada vez q se instancie el objeto de la clase de manera estricta debemos pasarle el nombre para poder instanciar el objeto.
En cambio si no le pasamos argumentos al metodo constructor sera una decision autonoma si deseamos hacer o no uso del atributo name.

Para generar el constructor automáticamente se oprime Alt+Insert y se selecciona constructor.

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

Metodo Constructor

Doctor myDoctor = new Doctor();

Cuando se crea un objeto ocurren 3 cosas:

Se asigna memoria para el objeto
Se inicializan los atributos de ese objeto.
Se invoca al constructor de la clase que puede ser uno entre varios

Los parentesis dan a entender que es un metodo. Cuando no tenemos el metodo constructor declarado, se utiliza el metodo constructor que por defecto el compilador genera. Este metodo ayudara a inicializar los atributos de esa clase.

El metodo constructor siempre va a estar definido despues de la palabra “new”. Este metodo crea nuevas instancias de una clase. Tiene el mismo nombre que la clase que inicializa. Usa la palabra reservada new para invocarlo. Usa cero o mas argumentos contenidos dentro del parentesis que siguen al nombre. No regresa un valor. Debe declararse como publico. El metodo constructor es el único metodo que no se le debe poner el tipo de valor de retorno. El constructor se ejecuta de manera automática y muestra lo que se ha ejecutado dentro del mismo.

Buena pregunta jeje yo diría que el name como parámetro tiene un alcance local dentro del método constructor mientras en el atributo tiene un alcance más grande dentro de la clase.

La principal diferencia para asignar el valor de la variable name por el constructor ó mediante la variable name es el acceso.

para mi podes hacer los constructores que quieras, igualmente al objeto se le asigna valor cuando haces myDoctor.name antes no, muestra el mensaje pq vamos al consturctor correspondiente y dicho constructor muestra un mensaje pero el objeto no tiene ese valor asignado hasta que se hace el .name.

Al pasarle al método parámetros desde la clase, podemos incorporar nuevos objetos y por ende, darle otro comportamiento a nuestro código, en cambio de la manera por defecto(desde la clase principal y sin parámetros) todo será muy básico.

Ya me quedo más claro el concepto de método constructor y respecto a la diferencia principal de las dos maneras de usar el método, es que el uso de parámetros permite ahorrar unas cuantas líneas de código al no tener asignar valor a cada variable repitiendo nuevamente el nombre del objeto.

En el constructor le estamos asignando un valor predeterminado, cada vez que se instancie el constructor, asignará este valor.
En el caso de la propiedad, se esta asignando un nuevo valor, reemplazando el ya asignado en la instanciacion de la clase

se diferencian en el ambito de la variable, la primera es declara para la clase doctor la segunda es declarada en el metodo constructor.

La diferencia es que el método constructor solicita un parámetro, con esto podríamos asignar diferentes nombres desde cualquier clase y de la otra manera, simplemente estamos asignando un nombre especifico al atributo. Nos sirve mejor de la primera manera para optimizar el código.

en la primera tu ingresas directamente el dato en el contructor, en el segundo tu usas las caracteristicas de la clase modularmente.

    //Metodo constructor
    public Doctor(int id, String name, String speciality){
        this.id=id;
        this.name=name;
        this.speciality=speciality;

La diferencia es el scope, el párametro nombre, asignado en el constructor Doctor, sólo vive en ese método. y el otro name tiene un alcance global.

Cuando se envía desde el constructor normalmente se usa para inicializar los atributos de la clase, y cuando lo enviamos desde el método puede llegar a verse como set, aunque para este caso nunca de inicializa el valor del atributo desde el método showName, una mejora para este seria encapsular los atributos.

Diferencias de asignar una propiedad por constructor o asignar por propiedad de la clase ✍️

  • Diferencias de asignar una propiedad por constructor: Cuando se usa así quiere decir que todos los objetos(instancias) tendrán esas propiedades por defecto, por lo tanto siempre se tendrán que especificar dichas propiedades en la creación del objeto o instancia.
  • Asignar por propiedad de la clase: Cuando lo usas así quiere decir que tu objeto no requiere esas propiedades para ser inicial izado, por lo tanto no lo estarás pasando como parámetro al crear la instancia. Así que en este caso tu defines que propiedades contendrá cada objeto.

La diferencia entre estar asignando los datos dentro de los corchetes es que si o si los datos serán solicitados, en cambio si nosotros lo hacemos por medio del atributo name, esa instancia no es requerida a menos que nosotros lo pongamos.

Al definir un nombre en el atributo este queda fijado y se replica al momento de imprimirlo. al colocarlo mediante el metodo constructor este solamente seria un parametro y se podria cambiar cada vez que se llame el objeto.

Es mas seguro pasar el valor de un atributo a través de un método que si lo pasaramos usando objeto.atributo. De ahí surge el encapsulamiento.

Los metodos constructores si no estan declarados en la clase, el compilador nos provee uno, ya si queremos colocarlo y añadir un comportamiento lo podemos añadir.
Estos constructores no ayudan a crear nuevas instancias.
NUnca regresaran un valor.

Método por constructor sin parámetros (new Doctor());

1 - Se crea una instancia u objeto en la memoria por el constructor sin parametros (o sin nada entre los parentesis),
new Doctor()
como no asignamos valores de sus atributos quedan de esta forma

Doctor{id=0, name='null', speciality='null'}

2 - Posterior a esto nosotros le vamos a asignar el nombre EJ:

	  doc.name = "Juanin Juan Jarry";

al no ser un método privado, encontrarse en el mismo paquete el obj nos permite hacer el cambio.

Doctor{id=0, name='Juanin Juan Jarry', speciality='null'}

Método por constructor sin parámetros (new Doctor());

1 - Se crea una instancia u objeto en la memoria con nuestro constructor que recibe el parámetro name
Doctor(String name)

Ejemplo : Doctor doc2 = new Doctor(“Anahí”);
Quedan de esta forma

Doctor{id=0, name='Anahí', speciality='null'}

doc2.showName(); // deberia imprimir el nombre

// ::::::::::::::::::::::::::::::::::::: DOCTOR :::::::::::::::::::::::::::::::

public class Doctor {

    //Atributos
    int id;
    String name;
    String speciality;

    Doctor(){
        System.out.println("contruyendo el objeto doctor");
    }

    Doctor(String name){
        System.out.println("El nombre del doctor asignado es: "+name);
    }
    //Comportamientos
    public void showName()
    {
        System.out.println(name);
    }

}

:::::::::::::::::::::::::::::::::::::::MAIN:::::::::::::::::::::::::::::::::::::::
public class Main {
    public static void main(String[] args) {
        Doctor myDoctor = new Doctor("Silvia Mayorga");
        myDoctor.name="Diego Hernandez";
        myDoctor.showName();
    }
}


Si le asignamos desde el atributo

String name = "name";

vamos a estar asignandolo en todo el programa y va a ser como una constante.

En cambio si le asignamos desde el constructor

Doctor(String name){

}

Vamos a poder asignarle varias veces cualquier nombre y se guardaran como variables diferentes en memoria

La diferencia entre asignar el valor directo desde la variable y declararlo desde el método constructor de la clase es que asignarlo desde el método constructor ayuda a inicializar el valor o valores que queramos mostrar al ejecutar el programa y cuando asignamos el valor desde la variable, le declaramos un valor en especifico que queramos cambiar.

Doctor myDoctor = new Doctor("Pablo Ramírez");
myDoctor.name = "Alberto Pérez";
myDoctor.showName();

Atributos accesibles como mala practica

Mediante la abstraccion podemos ocultar los atributos, para que estos no tengan un acceso libre en otras partes del programa si no que tengamos que usar metodos.

Similar al state en react donde no se debe modificar el state directamente si no con una funcion.

Para poder modificar de manera eficiente o inicializar un atributo de nuestro objeto requerimos del puntero This que le permite a un objeto referirse a si mismo e identificar variables

Manteniedo los atributos inmutables desde la clase main a menos que los alteremos por un metodo de una manera mucho mas consiente

No se aconseja que se tenga acceso a los atributos de un objeto de manera directa, si bien el resultado se logra en el ejemplo como asignar un nombre, conforme crece el proyecto se vuelve complicado llevar un orden. Para eso tenemos los metodos getters y setters.

Les dejo mis apuntes

A como tenemos el método constructor en la clase Doctor actualmente, si lo pasamos como parámetro no se guardará en la propiedad name.

Realmente vale lapena repetir este video , pues la chica tiene buen conocimiento de Java y explica muy bien.

Hola este es el método constructor de mi código. 😃

La diferencia sería que, cuando declaramos un atributo de la clase tenemos la libertad de usarlo o no.
En cambio cuando es declarado en el constructor, cada que instanciemos un obj debemos pasarle los argumentos.

Muchas dudas resueltas

El constructor nos permite poner valores iniciales para los objetos que se creara de dicha clase

hasta donde entendía en la entidades o POJOS iban los atributos y constructores, porque declarar los comportamientos ahi mismo y no en un service o alguna otra capa?

El parámetro name en el constructor sobrecargado no asigna un valor al atributo name de la clase, solo lo imprime en pantalla dentro del método constructor.
En cambio en la clase Main si se asigna el valor al atributo de la clase.

Creo que la diferencias entre asignar un valor en los paréntesis del método constructor y asignar este dato directamente en los atributos es que, en la primera forma no se define el valor en los atributos de la clase directamente es decir en este momento los atributos no tendrían ningun valor, este valor se encuentra dentro del scope del método constructor.

Instancia del objeto Doctor

Doctor myDoctor = new Doctor("David Tabares");
myDoctor.name = "Christian Vargas";
myDoctor.showName();

output

El nombre del Doctor es: David Tabares
Christian Vargas

Considero que tiene que ver con el Scope de la variable que se le asigna en el constructor.

Porque cuando se instancia la clase y pasas el nombre por el constructor, en primer momento name es guardado en la variable interna del método pero la variable no se asigna a la variable global del objeto.

Doctor myDoctor = new Doctor("David Tabares");

Output

El nombre del Doctor es: David Tabares

por eso que al asignarle otro valor a name usando el atributo del objeto, ese valor de la variable se vuelve global para el objeto.

myDoctor.name = "Christian Vargas";
myDoctor.showName();

Output

Christian Vargas

Si estoy mal, por favor me pueden corregir 😁

Con los constructores podemos crear objetos con sus propiedades inicializadas 😃

Doctor myDoctor = new Doctor("Anahí Salgado"); // Estas usando el constructor con el parámetro name que le has indicado al segundo constructor.
myDoctor.name="Alejandro Rodríguez"; // Aquí estas teniendo acceso al atributo name de acceso public y se esta modificando el valor de ese atributo. Para evitar eso hubiera sido correcto declarar private el atributo o en este caso todos los atributos de la clase Doctor.
myDoctor.showName(); // por eso cuando se ejecuta la linea con el método showName() se muestra el valor nuevo del atributo name.

Al construir el objeto Doctor dicha instancia no se esta asignando ningún valor a los atributos.

Segun yo, no es que pase algo o que una forma de asignar el nombre sea buena y la otra mala, sino que son diferentes, al pasarlo por el constructos, recien se crea el objeto este ya cuenta con ese atributo, pero si lo creas y luego lo asigna pues es un equivalente, pero con pasos extra.

La variable que recibe el constructor solamente tendra un scope local a menos de que se asigne al atributo de la clase

El constructor con parámetro no asigna valor a la variable del objeto

En java existe una excepción con el llamado del constructor, si existe el static block este se llamará primeramente y luego el contructor

Para asignar los valores, se usa el metodo this, que se refiere a la clase misma

es como un self.

 Ingeniero(){
        System.out.println("Haz creado un ingeniero");
    }

    Ingeniero(String name){
        this.name = name;
        System.out.println("Ingeniero "+ name);
    }

Declarando un objeto
el nombre del objeto debe ser en loweCamelCase y el de la clase UpperCamelCase
lo que esta despues de new (Doctor()) es el metodo Constructor
El metodo constructor:
1.- crea nuevas instancias de una clase
2.- tiene el mismo nombre que la clase que inicializa
3.- usa la palabra reservada new para invocarlo
4.- el metodo constructor puede tener cero o mas argumentos contenidos dentro del parentesis
5.- El metodo constructor no regresa un valor

En el caso de asignar el nombre directamente a la propiedad de la clase significa modificarlo directamente desde ella misma. En el caso del constructor, este va a “construir” el estado inicial del objeto llenando todas las propiedades que se le pasan como parámetros al método constructor.

al asignar en nombre en el constructor es una variable local lo que significa que el valor va a ser mutable por lo que siempre traerá el nombre que le asignes.

en el caso de la variable name al principio es una variable global por lo que puede ejecutarse en cualquiera de las funciones de la clase

Un constructor puede contener 0 o mas argumentos dentro de sus parentesis
El método constructor crea nuevas instancias de una clase
Un método constructor lleva el mismo nombre que la clase que incializa.
La palabra reservada “new” siempre antecede al método constructor.
El método constructor no devuelve un valor.

El método constructor con parámetro, no asigna el valor en espacio de memoria, nos devuelve null (si mandamos a imprimir el objeto, con su propiedad, nos damos cuenta), solo imprime la cadena de texto.

public class Main {
    public static void main(String[] args) {
        Doctor myDoctor = new Doctor();
        myDoctor.name = "Beto Pérez";
        myDoctor.showName();

        Doctor myDoctor2 = new Doctor("Fernando Pereyra");
        myDoctor2.showName();

    }
}```

Construyendo el objeto Doctor
Beto Pérez
El nombre del Doctor es:Fernando Pereyra
null

Process finished with exit code 0

Esto es muy diferente en comparacion a la universidad jaja

Una clase NO es un objeto.

En el primer ejemplo, lo que hace es crear un objeto con los atributos de la clase Doctor y le aplica el comportamiento definido para ese objeto, en el segundo caso, lo que se imprime es una variable, pero no se construye un objeto.

la diferencia en pasar argumentos a Doctor(){} dentro de la clase, es que, al parecer, se ve a ejecutar lo que sea que contrnga la “funcion”,
pero,
no afecta a la propiedad del nuevo elemento que se creo = myDoctor

La diferencia es que al instanciar el objeto tenemos que pasarle un string como parámetro, si no no podemos instanciarlo

public class Doctor {
int id;
String name;
String speciality;

    public void showName()
    {
        System.out.println(name);
    }
    public void speciality()
    {
        System.out.println(speciality);
    }  

}

public class Main {

public static void main (String []args){
    
    
    Doctor myDoctor = new Doctor();
    myDoctor.name = "Ramon";
    
    myDoctor.showName();
    myDoctor.speciality ="Patologia";
    myDoctor.speciality();
    
    
    
}

}

ni idea la diferencia 😦

Cuando se pasa el valor por parámetro, automáticamente asigna al objeto el nombre, en cambio de la otra manera tenemos que volver a llamar al atributo name y pasarle un valor…

el parámetro que se imprime en el constructor Doctor(String name), no se esta almacenando en el atributo name, por lo cual la diferencia es que en el método showName se esta imprimiendo el valor del atributo name y en el constructor el valor del argumento name.

Espero que haberme hecho entender, 😅

Java nos proporciona el método constructor por defecto

Con el constructor Doctor(String name), este name no se esta guardando en la variable global ya que solo estamos imprimiendo algo con esa variable, en cambio en la clase Main si se le asigna a la variable global.

El constructor es el primer método que se ejecuta en una clase, además que solo lo hace una únca vez. 😉

Cuando no se inicializan los valores en los atributos (o que no se les asigne un valor a estos atributos en los métodos) y se despliegan por ejemplo miObjeto.showAtributo() desplegaría los valores iniciales dependiendo del tipo del atributo.

  • 0 si son números enteros o reales.
    
  • '\u0000' si son caracteres.
    
  • false si son datos lógicos.
    
  • null si son objetos.
    
Si creas el objeto con el método sin parámetros, efectivamente ejecuta el contenido dentro del mismo; en ese caso un mensaje en pantalla. En caso contrario, estás pasando un parámetro de tipo String a lo cual "obliga" a poner el nombre del médico

Desde mi punto de vista la diferencia está en que la segunda le asgnamos el name a la funcion como parametro y la primera es atributo de nuestro objeto

La diferencia es que tal como esta la lógica en el vídeo: en el constructor no se le esta asignando el nombre al objeto mientras que en el main si se le asigna el nombre al objeto.

El método constructor en JavaScript se llama exactamente así:

constructor() { ... }

😅

Son dos formas distintas de construir el objeto myDoctor. En una es obligatorio pasarle el nombre por parámetro cuando se construye, en la otra se puede construir el objeto y luego darle el nombre. Eso de acuerdo a la lógica del programa que hagamos puede ser de mucha utilidad.

El método constructor tiene el mismo nombre de la clase y es el único que rompe el estilo de escritura lower camel case. Ademas no tiene un valor de retorno. Si no existe un método constructor declarado en tu clase, Java creará uno automáticamente.

Método constructor
• Crear nuevas instancias de una clase.
• Tiene el mismo nombre de la clase que inicializa.
• Usa la palabra reservada new para invocarlo.
• Usa cero o más argumentos contenidos dentro del paréntesis que siguen al nombre.
• Nunca regresan un valor.

la diferencia de utilizar o pasar valores a través del método constructor es para iniciar ó construir un objeto a un valor predeterminado, y en el ejemplo el argumento name (variable) del constructor es local a ese método…
myDoctor.name se refiere a la propiedad name de la clase Doctor que se le asigna “Alejandro Rodríguez”

Son variables distintas con el mismo nombre , una de las variables name viene desde el objeto hacia el método constructor a través de argumentos

En cuanto al ejemplo del video. El valor asignado mediante el parametro de entrada del constructor no modifica el valor de la variable del objeto. Aunque tienen el mismo nombre no representan el mismo valor.
El alcance de la variable name termina al finalizar el contructor, sin alterarse el valor del atributo name del objeto; a diferencia de llamar el campo name directamente desde el objeto, de esta forma si se esta modificando el campo del objeto.

Cuando asignas el nombre de la variable en la clase queda como un valor estático que solo cambia cuando lo cambias en la clase, en el main podría cambiar haciendo más modular el código

Método constructor -crea nuevas instancias -tiene el mismo nombre que la clase que lo inicializa -usa la palabra new para invocarlo -es el primero en ser ejecutado -si no se crea uno , el sistema lo crea por defecto -el metodo constructor puede tener cero o mas argumentos

El pasarlo desde el constructor, o cargar una variable directamente…no hay diferencia. Aunque prefiero el cargar por constructor, para ahorrar lineas de codigo.

Ën los desarrollos, se saben establecer las dos formas, pasar los valores mediante constructor o la asignaciones de las propiedades, dependerá del uso que se le quiera dar.

Utilizar el atributo name desde el metodo constructor nos permite encapsular los atributos,protegiéndolos de accesos no autorizados.