Definitivamente anahí tiene una metodologia de enseñanza excelente sus clases se hacen 100% comprensibles
Entender la Programación orientada a objetos
Programación orientada a objetos en Java
¿Qué es un Objeto?
Abstracción: ¿Qué es una Clase?
Modularidad
Definir Clases y sus componentes
Creando nuestra primera Clase
Método constructor
Static: Variables y Métodos Estáticos
Creando elementos estáticos
Final: Variables Constantes
Sobrecarga de métodos y constructores
¡Reto!
Encapsulamiento: Modificadores de acceso
Getters y Setters
Variable vs. Objeto
Variable vs. Objeto: Un vistazo a la memoria
Clases Anidadas
Clases Internas y Locales a un método
Enumerations
Reutilizar Código
¿Qué es la Herencia? Don't repeat Yourself
Super y This
Polimorfismo: Sobreescritura de Métodos
Polimorfismo: Sobreescribiendo el método toString
Interfaces
Creando una interfaz para definir si una fecha es agendable
Collections
Aplicar Abstracción
Clases Abstractas
Miembros abstractos
Clases Anónimas
Diferencias entre las Interfaces y las Clases Abstractas
Interfaces en Java 8 y 9
Herencia en interfaces
Ensamblando Objetos el proyecto
Simulando autenticación de usuarios
Modularizando la UI de Doctores
Definiendo las citas disponibles
Modularizando la UI de Pacientes
Recorriendo estructuras de árbol en Java
Agendando Citas
Cierre del curso: Continúa con Programación Funcional en Java
No tienes acceso a esta clase
¡Continúa aprendiendo! Únete y comienza a potenciar tu carrera
Si ya tienes una cuenta,
Sobrecarga de métodos y constructores
10/38Recursos
A veces necesitamos que dos o más métodos de una misma clase tengan el mismo nombre, pero con diferentes argumentos o distintos tipos de argumentos/valores de retorno.
Afortunadamente, Java nos permite ejecutar código y métodos diferentes dependiendo de los argumentos que reciba nuestra clase.
public class Calculadora {
// Los dos parámetros y el valor de retorno son de tipo int
public int suma(int a, int b) {
return a + b;
}
// Los dos parámetros y el valor de retorno son de tipo float
public float suma(float a, float b) {
return a + b;
}
// Un parámetro es de tipo int, mientras que el otro parámetro
// y el valor de retorno son de tipo float
public float suma(int a, float b) {
return a + b;
}
}
El uso más común de la sobrecarga de métodos es la sobrecarga de constructores para instanciar objetos de formas distintas dependiendo de la cantidad de argumentos que enviamos.
public class Doctor {
static int id = 0;
String name;
String speciality;
public Doctor() {
this.name = "Nombre por defecto";
this.speciality = "Especialidad por defecto";
}
public Doctor(String name, String speciality) {
this.name = name;
this.speciality = speciality;
}
}
Aportes 83
Preguntas 9
Ordenar por:
En la universidad le cogí fastidio a Java, me incliné por otros lenguajes, ahora por necesidad debido a un nuevo empleo, debo aprender Java, gracias a la profe le estoy cogiendo cariño a este lenguaje, ojala en la universidad enseñaran asi.
La sobrecarga de métodos consiste en crear diferentes funciones que, en realidad, hacen lo mismo, pero soportan diferentes tipos y cantidades de argumentos.
La sobrecarga de constructores es lo mismo, pero con constructores. 😅
La sobrecarga de métodos consiste en utilizar el mismo nombre en varios métodos, cada uno con distintos argumentos.
La palabra reservada this, hace referencia a todos los elementos que componen esa clase.
Parámetros: Datos que se le pasaran a una función y se indican al momento de la construcción de la misma
Argumentos: Datos que se ponen al momento de invocar a la función y son los que procesara la función
Excelente clase de sobrecarga y constructores, aquí en Java no existen los parámetros opcionales, por ende se usa la sobrecarga
Anahi vuelve!
Importante aclaración del this Por si acaso hay alguien que no lo entiende del todo.
NO hace referencia a la clase, sino al objeto.
Recuerden que las clases son moldes, las clases no se ejecutan no “viven” en tiempo de ejecución. Los objetos sí.
En este ejemplo, this sirve para señalarse a si mismo e indicar que el valor del atributo del objeto instanciado, será igual a los parámetros recibidos por el constructor.
llevo varios años programando en java, se me hacen entretenidos los videos de la profe, quizá un poco basicos pero son buenos.
Me encanta como explica!
Creo que falta recortar este vídeo 😕
La sobrecarga de métodos y constructores en Java permite tener un identificador con diferentes variables o con mas variables.
public class Greeting {
// Greet a person
public static void greeting(String name){
System.out.println("Hello " + name);
}
// Greet two people
public static void greeting(String name, String nameTwo){
System.out.println("Hello " + name + " and " + nameTwo);
}
public static void main(String[] args) {
greeting("David");
greeting("Jonathan", "David");
}
}
🤔 Utilizamos la sobrecarga de constructores para tener opciones al momento de instanciar un objeto.
muy bien explicado el tema de sobrecarga
La sobrecarga es: la capacidad de una clase de tener múltiples métodos con el mismo nombre, pero con diferentes parámetros.
Aveces necesitamos que dos o mas metodos tengan el mismo nombre pero con diferentes argumentos o los tipos de argumentos o el valor de retorno.
Definitivamente, una clase que quita todas las dudas acerca de este tema.
La sobrecarga es los que se conoce como polimorfismo.
- SOBRECARGA DE CONSTRUCTORES
La sobre carga de constructores se usa para inicializar objetos.
Muy buenas clases con Anahí!
This, se refiere al objeto que acabas de crear.
la manera de enseñar es muy buena, me ha ayudado a entender de una mejor manera los conceptos y los ejemplos.
La sobrecarga funciona para tener diferentes comportamientos con el mismo nombre del método.
tengo la duda , el id que se incrementa con el metodo Doctor(), no se asigna a nigun objeto en si , puede que se este incrementando con cada objeto que se crea , pero no pertenece a ninguno , como se agrega para que haga parte del objeto al ser static el id?
bueno vamos al grano
uso de sobrecargas de metodo por que y para que ahora solo imagina que tenes una clase y un metodo pero necesitas adaptar este metodo para multiples cosas o respuestas del usuario digamos que si el usuario anda un string o un double o int o byte podemos hacerlo
para cada respuesta y manejar expeciones de este usuario y eso gracias los métodos de sobrecarga que nos permiten crear varios metodos con el mismo pero con distintos comportamientos para que puedan manejar varias cosas y este no nos limita a usar solo lo que tiene el metodo original sino que nos da libertad
# **Method and Constructor Overloading**
## **Method Overloading:**
Method overloading allows us to define multiple methods with the same name but different parameters. This flexibility makes it easier to work with different data types or varying numbers of parameters. Let's explore some examples:
public class Calculator {
// Overloaded method 1
public int sum(int a, int b) {
return a + b;
}
// Overloaded method 2
public float sum(float a, float b) {
return a + b;
}
// Overloaded method 3
public float sum(float a, int b) {
return a + b;
}
}
In this example, the `sum` method is overloaded three times, each with a different set of parameters. Overloading can vary based on parameter types or their quantity.
public class Calculator {
// Overloaded method 1
public int sum(int a, int b) {
return a + b;
}
// Overloaded method 2
public float sum(int a, int b, int c) {
return a + b + c;
}
}
## **Constructor Overloading:**
Constructor overloading is applied to initialize objects. It allows the creation of objects with different sets of parameters, providing flexibility based on the information available.
public class Doctor {
static int id; // Autoincrement
String name, specialty;
// Constructor Method 1
public Doctor(String name, String specialty) {
this.name = name;
this.specialty = specialty;
++id;
}
// Constructor Method 2
public Doctor(String name, String specialty, int id) {
this.name = name;
this.specialty = specialty;
this.id = id;
}
}
Constructor overloading is especially useful when there is a need for mandatory parameters to create an instance of the class. It allows for the creation of objects with minimum information using one constructor and additional parameters using another.
This flexibility in both method and constructor overloading enhances the adaptability and usability of classes in Java.
Si borran el metodo Doctor() que tenemos sin parametros nos ayudará a que dé un error cada que se quiera instanciar la clase sin ningún parámetro. De lo contrario podremos seguir instanciando la clase sin parametros(que no creo que sea lo que queremos).
Como amo la manera de explicar de anahí es genial! Lastima que ya no esté en platzi :(
Una buena práctica, si se quiere, al utilizar sobrecarga de métodos, es la de evitar repetir código, haciendo que los métodos con menos parámetros llamen a los otros métodos pasando ciertos parámetros con valores por defecto, por ejemplo:
```js
public int sum(int num1, int num2, int num3){
return num1 + num2 + num3;
}
public int sum(int num1, int num2){
return num1 + num2;
}
```ahi vemos que ambos métodos hacen prácticamente lo mismo, pero uno suma un numero más, por lo podríamos mejorarlo:```js
public int sum(int num1, int num2, int num3){
return num1 + num2 + num3;
}
public int sum(int num1, int num2){
return sum(num1, num2, 0);
}
```de esta manera, el sum() de 3 parametros es el que tiene la lógica que hace todo el trabajo, el sum() de 2 parametros lo unico que hace es llamar al otro sum, con los mismos parámetros que recibió, pero pasando como 3er parametro un 0, que no alteraría la suma.
Les dejo mis apuntes.
Explicación:
Código.
```java
public class Calculadora {
// Sobrecarga de método
public int sumar(int a, int b) {
return a + b;
}
public double sumar(double a, double b) {
return a + b;
}
}
``````js
public class Persona {
String nombre;
int edad;
public Persona(String nombre) {
this.nombre = nombre;
}
public Persona(String nombre, int edad) {
this.nombre = nombre;
this.edad = edad;
}
}
``````js
public class Main {
public static void main(String[] args) {
// Sobrecarga de metodo
Calculadora calculator = new Calculadora();
System.out.println("Suma de enteros: " + calculator.sumar(2, 8));
System.out.println("Suma con decimales: " + calculator.sumar(16.2, 3.8));
// Sobrecarga de constructor
Persona person = new Persona("Carlos");
System.out.println("Nombre: " + person.nombre);
Persona secondPerson = new Persona("José", 25);
System.out.println("Nombre: " + secondPerson.nombre);
System.out.println("Edad: " + secondPerson.edad);
}
}
```
En el ejemplo de la calculadora, hay dos métodos llamados `sumar`, uno para enteros y otro para decimales. En el ejemplo de la persona, hay dos constructores llamados `Persona`, uno con solo el nombre y otro con nombre y edad. La elección del método o constructor adecuado se realiza automáticamente según los argumentos proporcionados al llamar a la función.
//main
System.out.println("ID: " + Doctor.id + "\nName: " + myDoctor.name + "\nEspecialidad: " + myDoctor.speciallity);
//Doctor
Doctor(String name, String speciallity){
this.name = name;
this.speciallity = speciallity;
id ++;
}
public static int suma(int a, int b){
return a+ b;
}
public static float suma(float a, float b){
return a+ b;
}
public static float suma(int a, float b){
return a+ b;
}
Method Overloading
Overloading refers to making a method perform different operations based on the nature of its arguments.
Methods can be overloaded in Java.
We could redefine a method several times and give it different arguments and method types. When the method is called, the appropiate definition will be selected by the compiler.
class Calculator{
public double product(double x, double y){
return x*y;
}
//Overloading the function to handle three arguments
public double product(double x, double y, double z){
return x*y*z;
}
//Overloading the function to handle int
public int product(int x, int y){
return x*y;
}
}
class Demo{
public static void main(String[] args){
Calculator cal = new Calculator();
double x = 10;
double y = 20;
double z = 5;
int a = 12;
int b = 4;
System.out.prinln(cal.product(x,y));
System.out.prinln(cal.product(x,y,z));
System.out.prinln(cal.product(a,b));
}
}
Genial!
Uff que forma de explicar! que excelente profe tenemos.
Muy interesante y claro!
Si a la gente le mostraran Java y POO de esta forma, no habrían tantos Java haters en la U.
Me saca de onda que Anahí tenga imprecisiones que se supone que un senior debe dominar. Justamente el no ser preciso es lo que acarrea errores con el paso del tiempo. 😕
“Los objetos no solamente son entidades elementales como son las variables…”
Los objetos también son variables. 😕
La clase utilitaria Objects tiene un método estático que obliga a que un objeto que se pase como parámetro no sea nulo.
Por ejemplo:
this.name = Objects.requireNonNull(name, "name can not be null");
La línea anterior lanza un NullPointerException customizado con el mensaje que se recibe como segundo argumento.
La palabra this sirve para referirse al atributo o método del objeto instanciado. Llamar this.name invocará el atributo name del objeto, que será diferente para cada objeto. Dicho de otra forma, this es un apuntador al objeto, sirve para diferenciarlo de los demás objetos de la clase y no llamar atributos o métodos de otros objetos.
Un objeto puede llamar sus propios atributos o métodos (usando this) of también puede llamar los atributos o métodos de la clase en caso que éstos sean estáticos. Además, se pueden llamar los atributos y métodos de Otras clases siempre que sean públicas, además de estáticas, en cualquier parte del código.
_this_
Sin importar lo que hagan cada uno de los métodos o constructores sobrecargados con sus diferentes argumentos de entrada, todos deben hacer lo mismo y entregar la misma salida o return. La sobrecarga se hace para aumentar la flexibilidad.
- Este es un concepto que tiene que ver también con métodos, y que se llama sobrecarga.
- Sobrecarga
A veces necesitamos que dos o más métodos tengan el mismo nombre pero con diferentes argumentos.
Gracias Anahi ❤️
Es increíble como un buen profesor/a te puede hacer amar o al menos tener una afición hacia una tecnología o lenguaje. Mientras que un mal Profesor/a te puede hacer odiar de por vida un lenguaje o tecnología.
Super comprensible
Me di cuenta que si en mi clase Doctor no tengo declarado mi método constructor de manera explícita (sin poner argumentos), en la clase Main surge un error si al instanciar un nuevo objeto de tipo Doctor no agrego los parámetros en el constructor. Sólo me da la opción de intanciar mi objeto agregando los parámetros.
Se debe de sobrecargar el método constructor, declarado con arguemntos y sin arguemntos para que nos dé la opción de instanciar el objeto con o sin argumentos.
Me encanta tu metodología para enseñar Anahí
Mil graciassssssssss! ❤️
super buena explicación
Excelente clase, muy bien explicada
Les comparto mis apuntes de la clase, para tener nociendo de lo que se ve en la clase en un solo vistaso
Excelente explicación Anahi
entendí que esta metodología o herramienta es muy útil para cuando necesitemos crear un objeto nuevo (con el construcotr), podamos crearlo usando diferentes parámetros.
Excelente clase 😃
Creando método sobrecargado
Instanciando Doctor
Resultado:
Llevé esta clase el periodo pasado en mi universidad y no entendí bien muchos conceptos, gracias a ella tengo mas claro todo y sigo aprendiendo. Muchas gracias Anahí. 😃
El resultado es el mismo si coloco
----Patient(String name){
System.out.println(name);
----}
y
----Patient(String name){
this.name = name;
System.out.println(name);
----}
Entonces cual es la diferencia, tengo esa duda pueden ayudarme, gracias.
excelente explicación
Sobrecarga es la capacidad de un lenguaje de programación, que permite nombrar con el mismo identificador diferentes variables u operaciones. La sobrecarga de constructores se usa para inicializar objetos.
Esta clase no la editaron, please
En la sobrecarga de métodos a veces se le dice que “cambia la firma” a pesar de ser el mismo nombre, puede ser que el tipo de retorno o parametros que recibe sean distintos, es por eso que el compilador los ve como métodos distintos
Java diferencia los métodos sobrecargados con base en el número y tipo de parámetros que tiene el método y no por el tipo que devuelve.
Entonces:
int suma(int a, int b, int c) {
...
}
int suma(int x, int y, int z) {
...
}
No es una sobrecarga válida, puesto que para Java, es el mismo método y dará un error de compilación.
excelente 😃
Estupenda clase acerca del termino sobrecarga instructora Anahí, la desventaja de usarlo es que debemos ser muy organizados para evitar las confusiones que generan su uso masivo, pero puede ser bastante útil al ayudarnos a abarcar la mayoría de soluciones en un problema.
:0 Sin saberlo le atiene jaja, precisamente lo que dije en el ejercicio anterior es exactamente lo que explican en esta clase :0
La verdad no lo tenia muy claro, pero ya con esta clase todo cambio. Genial.
mi reto anterior está malo :’( . Esto es trampa
Super claro gracias 😃
La sobrecarga es muy util para definir comportamientos en nuestro proyecto. Y tener un minimo de informacion para realizar ciertos comportamientos de nuestras clases.
En base de datos esta técnica es muy util.
Esto podría ser el mismo concepto del pilar de la programación OOP, el polimorfismo.
Muy buenas las clases, pero por qué tienen que explicar las cosas dos veces? Vuelve a explicar muchisimos detales que ya fueron vistos en POO y el curso introductorio a Java SE
En IntelliJ al pulsar "alt + ins" puedes insertar el constructor, entre otro códigos predefinidos, seleccionando los atributos que queremos dar como parámetros para el constructor.
buena explicación anahi
<h2>Sobrecarga</h2>
Es cuando tenemos dos o más métodos con el mismo nombre pero con estas diferencias:
- El número de parámetros es diferente
- El tipo de los parámetros es diferente
- El tipo de retorno es diferente
Clase 12: Sobrecarga de métodos y constructores
Para los que les apetezca tomar la clase en Eclipse iré subiendo mi código; hay pequeñas diferencias con Intellij, por no decir ninguna, pero con Eclipse se puede trabajar igual de bien. NOTA: Solo subiré la jerarquía y lo que haya sido modificado, tendrán los archivos no modificados en las clases anteriores.
Jerarquía del proyecto
Archivo: Doctor.java; Constructor: Doctor(String, String)
public Doctor(String name, String specialty) {
System.out.println("El nombre del Doctor asignado es: " + name);
id++;
this.name = name;
this.specialty = specialty;
}
Archivo: Main.java
package mymedicalappointment;
import static ui.UIMenu.*;
public class Main {
public static void main(String[] args) {
Doctor myDoctor = new Doctor("Anahí Salgado", "Pediatría");
System.out.println(myDoctor.name);
System.out.println(myDoctor.specialty);
}
}
La sobrecarga es nombre a diferentes métodos con el mismo nombre pero con argumentos diferentes.
public class Patient {
String name;
String email;
String address;
String phoneNumber;
String birthday;
double weight;
double height;
String blood;
public Patient(String name, String email){
this.name = name;
this.email = email;
}
}```
Sobrecarga de métodos y constructores
Hasta ahora se han visto dos formas de llamar métodos, la forma común mediante un objeto y la otra utilizando static.
<h4>Sobrecarga</h4>A veces necesitamos que dos o más métodos tengan el mismo nombre per con diferentes argumentos. Los argumentos pueden ser diferentes e incluso el valor que retornan.
Ejemplo:
En esta clase calculadora existen 3 métodos llamados suma, pero cada método recibe y retorna un tipo de dato diferente.
La sobrecarga de constructores se usa para inicializar objetos.
Con el siguiente constructor:
public class Doctor{
String name, specialty;
public Doctor(){
}
}
Los valores toman ese valor inicial por defecto , o sea que todas las variables de la clase Doctor están vacías.
Pero si añadimos parámetros al constructor, como name y specialty, nos aseguramos de que todas las instancias que se creen tendrán esos atributos con un valor. Esto es la sobrecarga de constructor.
public class Doctor{
String name, specialty;
public Doctor(String name, String specialty){
this.name = name;
this.specialty = specialty;
}
}
This hace referencia a todos los elementos que componen esa clase, al usar this name hace referencia al name de la clase Doctor y le da el valor de la variable name que recibió como parámetro el constructor. Esto es para que la variable no se inicialice en null.
Para los que esten confundidos con a cual varaible se está haciendo referencia con “this.<var>”:
¿Quieres ver más aportes, preguntas y respuestas de la comunidad?