1. Contenido
• Envío de parámetros por valor
y por referencia
• Constructores
• Sobrecarga
• Comparación de objetos String
con el método equals

2. Parámetros por Valor
• El envío de parámetros por valor, se presenta cuando
se invoca a un método con parámetros de tipo
primitivos.
• Al ejecutarse el método, se crean “copias” de los
parámetros originales, se trabaja con la copia y al
terminar no se afecta el original.

3. Parámetros por Valor
public class Prueba{ double
Public static void main(String[] a){
metodo1( parámetros x, y, …)
}
int
char
fl t
byte
long float h t
boolean
short
public void metodo1(argumentos x’, y’, …){
instrucciones que no alteran los
valores originales
}
} //fin Clase Prueba

4. Parámetros por Referencia
• El envío de parámetros por referencia, se presenta
cuando se invoca a un método con parámetros del
tipo de una clase es decir, con objetos.
• Al invocarse el método, éste recibe la referencia a
memoria del objeto, por lo tanto puede modificar los
atributos de dicho objeto.

5. Parámetros por Referencia
public class Prueba{ String
Public static void main(String[] a){
Nombre_Clase ref = new Nombre_Clase();
metodo1( parámetros ref , …)
Triangulo
Estudiante
Punto
Computador
} Camisa
Empleado
…..
public void metodo1(argumentos ref, ……)){
instrucciones que pueden alterar los
atributos del objeto recibido como parámetro
haciendo ref.atributo = valor ;
}
} // Fin Clase Prueba

6. Parámetros por Valor o Referencia?
public class Estudiante{
String nombre;
int edad;
} fi l E t di t
Estudiante.class
fin clase Estudiante
class Prueba{
public static void main(String[] a) {
Estudiante e = new Estudiante();
e = Prueba.class
e.edad 20;
e.nombre = “www”;
metodo1(e.edad); Valor: al terminar metodo1 e.edad es
20
metodo2(e); f i l i d 2
} //fin main
Referencia: al terminar metodo2
e.edad es 21 y e.nombre es “zzz”
public void metodo1(int edad){
edad = edad +1;
} fin metodo1
public void metodo2(Estudiante e){
e.edad = edad +1;
e.nombre = “zzz”;
}fin metodo 2
} //Fin clase Prueba

7. Constructores
• Son métodos especiales que sirven para proporcionar
diferentes formas de crear un mismo objeto. Se caracterizan
por:
o Se llaman igual que la clase publica
o No especifican tipo de retorno
o Generalmente son públicos
o Si el programador no lo codifica siempre existe uno por
defecto
o Puede estar sobrecargado
o Se invoca con la palabra reservada new

8. Constructores
Constructor por defecto:
public class Estudiante{
St i b
Aquí Java genera un
String nombre;
int edad;
**
constructor por defecto
de esta forma:
public Estudiante(){ } fin clase Estudiante
p (){
}
Este constructor se invoca desde cualquier otra clase
así:
Estudiante yo = new Estudiante();

9. Sobrecarga
Se presenta cuando un método aparece mas de una vez
dentro de una clase. Se tiene que cumplir que:
•• Los métodos tengan exactamente el mismo nombre
• Tengan el mismo tipo de retorno
• Varíe su lista de argumentos ya sea en cantidad y/o
tipo

10. Sobrecarga
En el siguiente código metodo1 esta sobrecargado ya
que en la primera aparición define un argumento de
tipo int y en la segunda un argumento de tipo
Estudiante

11. Sobrecarga de métodos
1. public class Estudiante{
2. String nombre;
3. int edad;
4. } fin clase Estudiante
5. class Prueba{
6. public static void main(String[] a) {
7. Estudiante e = new Estudiante();
8. e.edad = 20;
9. e.nombre = “www”;
10. metodo1(e.edad);
11. metodo2(e);
12. } //fin main
13. public void metodo1(int edad){ //metodo1 spbrecargado
14. edad = edad +1;
15. } fin metodo1
16. public void metodo1(Estudiante e){//metodo1 spbrecargado
17. e.edad = edad +1;
18. e.nombre = “zzz”;
19. }fin metodo1
20. } //Fin clase Prueba

12. Sobrecarga de Constructores
public class Estudiante { //Esta clase tiene 3 constructores sobrecargados
String nombre;
int edad;
public Estudiante(){
nombre = “sin nombre”
edad = 0;
}
public Estudiante(int edad, String nombre){
this.nombre = nombre // Con this podemos diferenciar entre parámetros
this.edad = edad; // y atributos
}
public Estudiante(Estudiante e) {
this.nombre = e.nombre
this.edad = e.edad;
}
} fin clase Estudiante

13. Comparación con equals
• El método equals esta presente en todos los
objetos de java y en los nuestros, ya que esta
definido en la superclase principal llamada Object.
• Toda clase hereda de Object y por lo tanto hereda
al método equals.
• En particular la clase String define el método
equals para comparar si dos cadenas de
caracteres son exactamente iguales en cuanto a
contenido.

14. Comparación con equals
1. String s1 = ““xxx””;
2. String s2 = “xxx”;
En principio parecería que si preguntamos:
s1 == s2
obtendríamos cierto. Sin embargo, s1 y s2 son
variables referencias diferentes, en otras palabras, son
dos objetos String diferentes y por lo tanto:
s1 == s2 Falso

15. Comparación con equals
• La forma correcta de preguntar si dos objetos
String diferentes son iguales en cuanto a su
contenido es:
S1.equals(S2) Verdadero
• En conclusión, usemos el operador == solo para
comparar variables de tipo primitivas y el método
equals para comparar cadena de caracteres.