Método constructor

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.

👇 APUNTES DE LA CLASE

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.

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

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

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

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

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.

• Una variable declarada dentro de un método solo puede ser accedida oh usada por el mismo.

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

Clase 6: Método Constructor

Para los que les apetezca tomar la clase en Eclipse iré subiendo mi código, hay pequeños detalles que Intellij deja atrás, pero con Eclipse se puede trabajar igual de bien.

Jerarquía del Proyecto

Clase Main.java

package mymedicalappointment;

import objetos.Doctor;

public class Main {

	public static void main(String[] args) {
		Doctor myDoctor = new Doctor("Anahí Salgado");
		myDoctor.name = "Alejandro Rodríguez";
		myDoctor.showName();
	}
}

Clase Doctor.java

package objetos;

public class Doctor {
//	Estado/Atributos
	public int id;
	public String name;
	public String specialty;
	
	public Doctor() {
		System.out.println("Construyendo el Objeto Doctor");
	}
	
	public Doctor(String name) {
		System.out.println("El nombre del Doctor asignado es: " + name);
	}
	
//	Comportamiento
	public void showName() {
		System.out.println(name);
	}
}

Respondiendo a la pregunta de la profesora (minuto 6:30):

• La variable name declarada como atributo de la clase es la propiedad para el objeto que esté siendo creado de esa clase.

• Por otra parte, la variable name que se declara como argumento del método constructor solo tiene el valor de ese argumento al momento de estar ejecutándose ese método, más no aloja el valor del atributo de la clase con ese mismo nombre.

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 🤔??

Una clase no es un objeto
Cuando se llama a los metodos se usan los parentesis ()
siempre va estar definido despues del new

METODO CONSTRUCTOR

• Nos ayuda a construir nuecas instancias
• Tiene el mismo nombre de la clase
• Siempre se usa new para inicializar
• Usa cero o mas argumentos

NUNCA REGRESA UN VALOR

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.

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.

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, 😅

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.

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.

el metodo constructor nos ayuda a crear nuevas instancias de una clase.
una pista para saber que es un constructor es que tiene el mismo mombre que la clase que inicializa

Una de las utilidades que veo de este uso es que no se graba el valor del atributo en el código y más adelante podemos usar en el método “main” una entrada de datos y guardar un nombre para cada instancia y no para todas las instancias.

La elección entre estos dos enfoques depende de la lógica y el diseño de tu programa. Usar el constructor para pasar valores iniciales es útil cuando deseas que los atributos estén disponibles inmediatamente después de crear un objeto. Y por otro lado, asignar directamente los atributos después de la creación es útil cuando necesitas cambiar o actualizar los valores de los atributos en momentos diferentes durante la vida del objeto

La variable name que se el metodo constructor sobrecargado recibe, es un parametro que existe solo dentro de ese metodo, su scope es local a ese metodo constructor.
Mienstras que la variable que esta con el mismo nombre, declarada mas arriba, es una variable de scope global.
Teniendo esto en cuenta, al referirse a esta variable dentro del metodo, se hara referencia a la que esta dentro del scope de ese metodo. Una tecnica para poder referirnos a la que esta fuera del scope de nuestro metodo constructor, es mediante el uso de la palabra reservada “this”, la cual nos ayudara a hacer referencia al “objeto actual” o “clase actual”.
Por ejemplo, si desearamos obtener el nombre, mediante el metodo constructor, y pasarlo a la variable global, para su uso posterior:
“thisname = name”; donde asignariamos a la variable global, aquel argumento que se haya pasado al momento de llamar el metodo constructor.
{ojo alli va un punto pero, no me permitio platzi, pulicar, tuve que quitarlo seria this punto name"

La diferencia:
Constructor con argumentos: recibe parámetros para inicializar la instancia
Constructor sin argumentos: no recibe argumentos, está listo para setear o asignar los datos

pero en el constructor nunca asignaste el valor a la variable name, simplemente pasaste un valor por parametro y lo imprimiste nada más, asignaste valor solo cuando desde el main llamaste a la propiedad name y luego se vio con el metodo show

Muy buena clase

La diferencia de asinacion es que cuando lo asignas en la clase, es de forma estitica o final, lo cual no se podria modificar a la hora de llamar la clase, respuesta al constructor con parametros, y por otra parte puedes cambiar el valor de memoria al nombre siempre que quiera usar el constructor mediante parametros.

La diferencia entre las dos asignaciones es que la primera línea, String name;, declara una variable de tipo String llamada name, pero no le asigna ningún valor. Esta línea solo declara la existencia de la variable, pero no le asigna un valor inicial. Si intentas acceder a name antes de asignarle un valor, obtendrás un error.

En el método constructor debería utilizarse

this.name

para que el nombre sea asignado realmente a la variable, de lo contrario en la versión de método constructor propuesta lo único que se hará es mostrar el nombre pasado como argumento al momento de la creación pero no será asignado.

La diferencia es que al declarar el constructor Doctor(String name) con un parámetro name, estamos indicando que este constructor recibe un argumento de tipo String llamado name. Al hacer esto, podemos asignar un valor inicial al atributo name del objeto que se está creando al llamar al constructor. Por ejemplo, al hacer Doctor myDoctor = new Doctor(“David Marquez”);, estamos creando un objeto de la clase Doctor con el nombre “David Marquez” y asignando ese valor al atributo name del objeto.

En cambio, si declaramos un constructor sin parámetros como Doctor(), no podemos inicializar el valor de name al crear un objeto utilizando ese constructor. En este caso, el valor inicial de name sería null.

Si al momento de declarar la variable name te da un error en el código solo tienes que declarar un variable tipo String asiganado name, y en la función utilizar un operador de asignación =.

Ejemplo:

import java.util.jar.Attributes.Name;

public class Main {
	public static void main(String[] args) {
		
		// Declarar el objeto ---- Instanciar el objeto
		String name;
		Doctor myDoctor = new Doctor(name = "Anahi Salgado"); 
		myDoctor.name = "Edwin Rodríguez";
		myDoctor.showName();
	}

}

Cuando utilizamos el Constructor con parámetros no se lo asignamos a ningún atributo del objeto así que nuestro objeto no lo guardará como un atributo. Ahora si el valor es asignado por referencia entonces cuando se cambie ese valor también la hará en nuestro objeto

Las clases no son objetos, aunque hay objetos instancias de Class, por lo que técnicamente si hay objetos que son clases.

El constructor , se pueden encapsular las variables de la clase donde se hace el constructor y esto ayuda ver mejor nuestro código además de ser una buena practica.

cual es la diferencia entre asignar el nombre en el constructor a asignarlo en los atributos?

Si asignamos el nombre en el constructor este seguirá las instrucciones del método ( asignar e imprimir variables o textos). Si asignamos en los atributos la variable simplemente quedara almacenada (si es que no se imprime o actualiza)

La diferencia radica que:

1. Declarar el “name” desde los atributos de la clase:
   • Permite asignarle el valor con el punto (.) desde la clase main.
2. Declarar el “name” como parámetro del objeto instanciado:
   • Permite asignar name pasando el valor por parametro desde la clase main.

La diferencia es que si asignamos datos al método constructor, éstos se van a mostrar siempre que se utilice el objeto, en cambio si se asigna un valor a la variable, estos se imprimirán siempre que se utilice la variable

en respuesta a lo solicitado al final de la clase: La diferencia entre pasar el nombre en el constructor y asiganarlo posterior a la inicializacion del objeto es que en el primer caso sino se asigna el valor pasado en el construtor no tendra efecto en la variable global name, pudiendo ser usado tan solo localmente dentro de cuerpo del constructor

La diferencia es que el primer nombre es un atributo de la clase,
y el segundo nombre es especifico del metodo.

La diferencia entre asignarle el nombre en la declaración de la propiedad y asignárselo en el método constructor pasando previamente el valor como argumento o parámetro, es que podés reutiliza la clase tantas veces quieras, ya que el nombre del doctor se definirá mientras instanciamos la clase Doctor.

• MÉTODO CONSTRUCTOR

1. Usa cero o más argumentos contenidos dentro de los paréntesis que siguen al nombre.
2. No regresa un valor.

• 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.
• De hecho de ahí viene la palabra constructor porque construye un objeto.
• MÉTODO 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.

No sabia eso del método constructor

ya muchos hablaron al respecto pero igual pongo mi aporte.
El metodo contructor creado, solo contruye la variable del tipo Doctor pero no le asigna un valor en la parte donde se le envia NAME sino que ese valor se utiliza solo para ser impreso. puede generarse un metodo contructor que si le de un valor NAME a la variable, pero la forma de escribir ese metodo contructor seria otra.

Creo que la diferencia es que si pasa mediante el método constructor, solamente dentro de este será el alcance de la variable, mientras que si lo hacemos de la otra forma el alcance de la variable es en toda la clase.

La diferencia es que al momento de instanciar el objeto Doctor podemos directamente desde el metodo añadir datos o valores, ya que este metodo recibe un atributo o parametro
y desde los metodos como comportamientos podemos hacer uso de estos al momento de instanciar con el punto ejmeplo:

Creo que el primero imprime el string con el nombre y el segundo le asigna un nuevo valor al atributo name.

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

Lenguajes como Dart ya no utilizan new para crear objetos. Me gustaria que algun dia JAVA siga esos pasos…

Cuidado chicos no se confundan el metodo de nuestra clase que enlaza con el metodo constructor de nuestro Objeto main, !no se crea solo. despues de definir los atributos en la clase debemos crear el metodo constructor de nuestra clase donde debe llevar el nombre de nuestra clase y asi instanciar sus atributos en el constructor de nuestro objeto.

Vengo de JavaScript pero como JavaScript es basado en prototipos quise aprender Java para comprender aun más POO y que mejor que con Java. 😄

¿Qué es un constructor?

Ayuda crear nuevas instancias ya que construye un objeto, tiene como característica también que tiene el mismo nombre de la clase que lo inicializa y usa la palabra new para invocarlos como se ve a continuación:

myDoctor = new Doctor()

El elemento subrayado se convierte en el método constructor que se muestra en la estancias.

Puede tener 0 o más argumentos, en el anterior no hay ningún parámetro ya que no esta declarado y es el uso por defecto.

Los métodos constructores nunca regresan un valor.

Como parámetro dentro del constructor solo es usado para referencia no como valor asignado ya que si imprimimos o llamamos al atributo de la clase no esta asignado el valor, pero, cuando lo asignamos en el .name, el valor si queda registrado dentro del atributo de la clase.

        Doctor myDoctorName = new Doctor("Jairo E.");
        myDoctorName.showName(); // aquí imprime null
        myDoctorName.name = "Jairo E." //Aquí si se asigno el valor de Jairo E. a la ** class Doctor - Atributo name **
        myDoctorName.showName(); // aquí imprime Jairo E.

la diferencia entre este:

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

y este:

Doctor(String name){
        System.out.println("El nombre del Doctor asignado es: "+ name);
    }

es que el primero requiere que la variable este definida y toca ingresarla, mientras que en la segunda nosotros podemos ingresar de golpe el nombre por parametro del llamado, haciendo que reduzcamos un poco mas nuestro cod en el main

Hola si alguno le pasó lo mismo que a mi, si solo colocas " " entonces automaticamente se genera name:
No hay que escribirlo y me tomo mucho darme cuenta jaja

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.