Pablo Rodrguez

Sobrecarga (Overloading)

Varios mtodos se llaman de la misma

manera pero se comportan de manera
diferente.
En lenguaje hablado existe un concepto
parecido en el que una misma frase puede
tener diferentes significados de acuerdo al
contexto.
El contexto de los mtodos se mide por los
argumentos. Es decir cada mtodo se
diferencia por su nombre y los de nombre
igual por sus argumentos

Firma del mtodo

La firma de un mtodo es su nombre
seguido de una lista de argumentos.
Una clase no puede tener 2 mtodos
con la misma firma

Como se distinguen los mtodos

sobrecargados?
Cada mtodo sobrecargado debe tener
una lista nica de argumentos
Inclusive la diferencia en el orden es
suficiente para distinguir un mtodo de
otro

Distincin entre mtodos sobrecargados

int calcular();
int calcular(int a);
int calcular(int a,int b);
int calcular(int a,double c);
int calcular(String b);

Nombres iguales pero diferentes firmas

Sobrecarga en los valores de

retorno

Se podra pensar que es fcil distinguir

entre 2 mtodos int f() y void f()

Muchas veces un mtodo se llama sin

guardar su valor de retorno. Como el
compilador sabra a cual estamos
llamando??

Ejemplos
abstract class Auto
{
public abstract void frenar();
public abstract void frenar(int velocidadFinal);

}
En el ejemplo de arriba el mismo mtodo frenar se
comporta de manera diferente de acuerdo al contexto
(argumentos). El primero puede frenar del todo y el
segundo hasta una velocidad determinada

Ejemplo Bicicleta
public class Bicicleta {
private int velocidad;
public void acelerar(){
velocidad++;
}
Mtodos que se podran sobrecargar
public void frenarGolpe(){
velocidad=0;
}
public void frenar(int vel){
if(vel>=velocidad){
velocidad=0;
}
else{
velocidad=velocidad-vel;
}
}
public int getVelocidad(){
return velocidad;
}
}

Ejemplo Bicicleta
public class Bicicleta {
private int velocidad;
public void acelerar(){
velocidad++;
}
public void frenar(){
velocidad=0;
}
public void frenar(int vel){
if(vel>=velocidad){
velocidad=0;
}
else{
velocidad=velocidad-vel;
}
}
public int getVelocidad(){
return velocidad;
}
}

Mtodos sobrecargados

Constructor
Es un mtodo especial que es llamado
cuando el objeto es creado.
Java automticamente llama a este
mtodo y con esto se garantiza la
inicializacin, ya que el cdigo del
constructor se ejecuta antes de poder
mandarle algn mensaje al objeto

El nombre del Constructor

Se debe llamar igual que la Clase
Ventajas:

No ocasionar conflictos con el nombre de

algn mtodo
Con esto Java sabe como llamar al mtodo

Ejemplo
class Moto{
Moto() {
// El Costructor
System.out.println(Construyendo la Moto");
}
}

Tipo de Retorno
Los constructores no tienen valores de
retorno.
No se especifica con void

Argumentos

Los constructores reciben argumentos como

cualquier otro mtodo

class Moto{
public Moto(String s) {
// El Costructor
System.out.println("Creando una moto con chapa: "+s);
}
}

Ejemplo Bicicleta
public class Bicicleta {
private int velocidad;
private int cantCambios;
public Bicicleta(int vel,int cambios){
velocidad=vel;
cantCambios=cambios;
}
public void acelerar(){
velocidad++;
}
public void frenar(){
velocidad=0;
}
public int getVelocidad(){
return velocidad;
}
public int getCantCambios() {
return cantCambios;
}
}

Ejemplo Bicicleta
public static void main(String[] args) {
Bicicleta bici=new Bicicleta(100,18);
int cambios=bici.getCantCambios();
int vel=bici.getVelocidad();
System.out.println("Cambios: "+cambios);
System.out.println("Velocidad: "+vel);
}

Funcin del Constructor

Asignar datos iniciales a los

atributos de una clase

Constructores sobrecargados
Permiten construir un objeto de diferentes formas
class Moto
{
int velocidad;
Moto()
{
velocidad=10;
}
Moto(int vel)
{
velocidad=vel;
Podra construir:
}

new Moto();
new Moto(60);

Constructor por defecto

Si no especificamos ningn constructor, entonces el

constructor de nuestra clase es un constructor que no
recibe argumentos.
class Moto
{
public void frenar();
}

Para construir un objeto moto se utiliza

new Moto();
El compilador asigna (construye) un constructor si no
especificamos uno

Constructor por defecto

Si escribimos por lo menos un constructor el

compilador no crear uno para nuestra clase

class Moto
{
int velocidad;
Moto(int vel)
{
velocidad=vel;
}
}
No es valido construir un objeto con
new Moto();
Si es valido hacerlo con
new Moto(100);

Mensajes a objetos
Dada la siguiente clase
class Moto
{
String chapa;
Moto(String ch)
{
chapa=ch;
}
public void multar()
{
System.out.println(Se le multa a: +chapa);
}
}

Mensajes a objetos
Podemos construir 2 objetos Moto.
Moto m0=new Moto(500AAB);
Moto m1=new Moto(189ACX);
m0.multar();
m1.multar();
Esto producira el sgte. output:

Se le multa a: 500AAB
Se le multa a: 189ACX

Composicin
Es la utilizacin de una clase como
atributo de otra.
Ejemplo.

Las Personas tienen ojos

Las Personas tienen piernas

public class Ojo {

//Atributos de clase
public static final int AZUL=0;
public static final int VERDE=1;
public static final int NEGRO=2;
public static final int MARRON=3;
//Atributos de instancia
private int colorOjo;
private int tamanho;
private int gradosMiopia;
//Constructores
public Ojo(int color){
colorOjo=color;
}
public Ojo(int color,int miopia){
colorOjo=color;
gradosMiopia=miopia;
}
//Mtodos
public int getColorOjo() {
return colorOjo;
}
public int getTamanho() {
return tamanho;
}
public void setTamanho(int tamanho) {
this.tamanho = tamanho;
}
public int getGradosMiopia() {
return gradosMiopia;
}
}

Ejemplo Composicin
El humano tiene un Ojo izquierdo
El humando tiene un Ojo derecho

public class Humano {

private Ojo ojoIzq;
private Ojo ojoDer;
public Humano(Ojo ojo1,Ojo ojo2){
ojoIzq=ojo1;
ojoDer=ojo2;
}
public Ojo getOjoIzquierdo(){
return ojoIzq;
}
public Ojo getOjoDerecho(){
return ojoDer;
}
public static void main(String[] args) {
Ojo ojoIzquierdo=new Ojo(Ojo.MARRON);
Ojo ojoDerecho=new Ojo(Ojo.AZUL,3);
Humano humano=new Humano(ojoIzquierdo,ojoDerecho);
}
}

Ejercicio
Modelar la estructura de una sala de
estudios genrica e instanciar una sala
con la informacin de esta.
Se deben introducir los conceptos de
encapsulamiento, sobrecarga,
constructores y paquetes