poo - 18 - sobrecarga e sobreposição de métodos

Sobrecarga e Sobreposição

de Métodos

Programação Orientada a Objetos

Ludimila Monjardim Casagrande 2012

Sobrecarga de Métodos

A sobrecarga de métodos, também conhecida

como overloading, ocorre quando criamos dois

ou mais métodos com o mesmo nome mas com

uma lista de argumentos diferente.

A sobrecarga está sendo aplicada, por exemplo,

quando são declarados dois construtores para

uma mesma classe, sendo um sem parâmetros

e outro com parâmetros.

Sobrecarga e Sobreposição ©2012 Ludimila Monjardim Casagrande 2

Exemplo de Sobrecarga de Construtor


public class Conta {

private double saldo;

public Conta () {

}

public Conta (double saldo) {

this.saldo = saldo;

}

}

Podemos, então, criar objetos dessa classe de dois modos:

Conta c = new Conta(); ou

Conta c = new Conta(100); inicializando o saldo com algum valor


A sobrecarga também é aplicada para os outros

métodos que não sejam construtores.

Em algumas situações, é útil poder executar um

método em uma classe passando mais ou

menos argumentos, conforme a necessidade.

Também pode ser necessário fazer a

sobrecarga de um mesmo método, com o

mesmo número de argumentos, porém variando

os tipos desses argumentos.


Exemplo de Sobrecarga de Método


public class Conta {

private double saldo;

public String toString() {

return " saldo = " + this.saldo;

}

public String toString(String prefixo) {

return prefixo + ": " + toString();

}

}

Exemplo de uso:

Conta c = new Conta(100);

c.toString(); ou

c.toString(“Conta número X”);



Para que seja permitida a sobrecarga, os nomes

dos métodos devem ser iguais mas as

assinaturas devem ser diferentes.

Duas assinaturas idênticas não são permitidas.

A assinatura de um método é composta por seu

nome e pelo número e tipos de argumentos que

são passados para esse método,

independentemente dos nomes das variáveis

usadas na declaração do método.


Exemplo

public class Data {

private int dia;

private int mes;

private int ano;

public Data(int dia, int mes, int ano) {

this.dia = dia;

this.mes = mes;

this.ano = ano;

}

public Data(int mes, int dia, int ano) {

this.dia = dia;

this.mes = mes;

this.ano = ano;

}

}

Como todos os argumentos são do

mesmo tipo, somente a inversão do

nome das variáveis não é suficiente

para que esses dois construtores

sejam considerados diferentes.

Esse código, portanto, geraria um

erro de compilação “método

duplicado na classe Data”.


O tipo de retorno do método não é considerado

parte da assinatura.

Sendo assim, não podemos ter dois métodos

com o mesmo nome e com o mesmo número e

tipos de argumentos, mas apenas com o tipo de

retorno diferente.


Exemplo

Na classe Data declarada anteriormente não seria

possível a declaração dos dois métodos abaixo, pois

suas assinaturas são idênticas, eles só diferem quanto

ao tipo de retorno, que não é considerado parte da

assinatura do método:


public String getData( ) {

return toString( );

}

public Date getData( ) {

Date d = new Date( );

d.setDate(dia);

d.setMonth(mes);

d.setYear(ano);

return d;

}


A decisão sobre qual método será chamado quando

existirem dois ou mais métodos com o mesmo nome

será feita pelo compilador, que verificará se os tipos

passados como argumentos casam com alguma das

assinaturas daquele método.

Supondo que os argumentos sejam de tipos diferentes,

a ordem em que aparecem também é relevante, isto é:

public Data(int dia, String mes, long ano)

public Data(String mes, int dia, long ano)



Exemplo

public class Data{

private int dia;

private String mes;

private long ano;

public Data(int dia, String mes, long ano){

this.dia = dia;

this.mes = mes;

this.ano = ano;

}

public Data(String mes, int dia, long ano){

this.dia = dia;

this.mes = mes;

this.ano = ano;

}

public String toString(){

return dia + " de " + mes + " de " + ano;

}

public static void main(String[] args){

Data d1 = new Data(1, “maio", 2004);

Data d2 = new Data(“maio", 1, 2004);

System.out.println(d1);

System.out.println(d2);

}

}

Exemplo de sobrecarga válida.


Ao verificar se há casamento entre os

argumentos passados e as assinaturas dos

métodos, o compilador considera todas as

possibilidades de conversões implícitas.

Sendo assim, se o valor do argumento passado

for, por exemplo, do tipo char e o argumento

declarado na assinatura do método é do tipo int,

então, esse valor passado será aceito, pois é

possível fazer uma conversão implícita de char

para int.



Conversões Implícitas Válidas

As conversões implícitas válidas entre os tipos

primitivos do Java são:

byte short

char

long int float double

Os elementos á direita da seta recebem os elementos à esquerda.


Outras Conversões Implícitas Válidas

Conversões implícitas válidas entre classes,

subclasses, interfaces e sub-interfaces

TipoRecebido é uma

classe

TipoRecebido é uma

interface

TipoReceptor é uma

classe

TipoRecebido deve ser

uma subclasse de

TipoReceptor

TipoReceptor deve ser

Object

TipoReceptor é uma

interface

TipoRecebido deve

implementar a

interface TipoReceptor

TipoRecebido deve ser

uma sub-interface de

TipoReceptor


Tipos para o Exemplo

public interface Figura {

public double calcularArea( ) ;

}

public class Quadrado extends Object implements Figura {

double lado;

public Quadrado(double lado) {

this.lado = lado;

}

public double calcularArea( ) {

double area = 0;

area = lado * lado;

return area;

}

}


Exemplo de Conversões Implícitas

public class Principal {

public static void main(String[ ] args) {

/* A variável o do tipo Object recebe qualquer objeto

* que seja de um tipo que estenda Object */

Object o = new Quadrado(4);

/* A variável f do tipo Figura (que é uma interface)

* recebe qualquer objeto que seja de um tipo que

* implemente Figura */

Figura f = new Quadrado(2);

/* Uma variável do tipo Object recebe qualquer

* variável cujo tipo seja uma interface */

Object o1 = f;

}

}

Sobreposição de Métodos

A sobreposição de métodos (ou overriding)

ocorre quando há polimorfismo:


Figura

Quadrado

Círculo

calcularArea()

calcularArea() calcularArea()

A implementação do método

calcularArea() das subclasses

sobrepõe a implementação

do mesmo método na

superclasse.


Exemplo de Polimorfismo

public class Figura {


return 0;

}

}

public class Quadrado extends Figura {

double lado;

public Quadrado(double lado) {

this.lado = lado;

}


double area = 0;

area = lado * lado;

return area;

}

}



public class Circulo extends Figura {

double raio;

public Circulo (double raio) {

this.raio = raio;

}


double area = 0;

area = 3.14 * raio * raio;

return area;

}

}



public class Main {

public static void main(String[] args) {

Figura f1 = new Quadrado(4);

Figura f2 = new Circulo(2);

System.out.println("Área da Figura 1 é: "

+ f1.calcularArea( ) + "\n“

+ "Área da Figura 2 é: "

+ f2.calcularArea( ));

}

}



Existem algumas regras que devem ser

respeitadas para que a sobreposição seja válida.

Por exemplo, o método que sobrepõe não deve

restringir o grau de acessibilidade do método

sobreposto.

private default protected public

um método private pode ser sobreposto por um default

e assim sucessivamente



Para que haja sobreposição, as assinaturas dos

métodos devem ser idênticas.

Como o valor de retorno não é considerado parte da

assinatura, ele pode variar desde que sejam respeitadas

as regras de conversão entre tipos.

Exemplo: O método (1) pode sobrescrever o método (2),

mas o contrário não é verdade:

public ArrayList teste(ArrayList l) (1)

public List teste(ArrayList l) (2)


Exercícios de Revisão

1. Para que serve uma interface?

2. O que é uma classe abstrata?

3. O que é um método abstrato?

4. Qual é a diferença entre classes abstratas e

interfaces?

5. O que é polimorfismo?

6. Todos os métodos de uma classe abstrata

podem ser não abstratos?


7. O que significa implementar uma interface? Em

outras palavras, o que é necessário fazer

quando uma classe concreta implementa uma

interface?

8. Quando uma classe concreta estende uma

classe abstrata que não contém nenhum

método abstrato, ela é obrigada a implementar

algum método? Justifique.

9. É possível instanciar uma interface? E uma

classe abstrata?




10. Quando uma subclasse implementa um

método herdado da superclasse, o que está

acontecendo: overloading ou overriding?

11. É correto afirmar que uma classe pode

estender uma interface?

12. Um interface pode estender outra interface?

Isto é, há herança entre interfaces?

13. Há herança múltipla em Java?

Bibliografia Sugerida

Java: Como programar

Autores: H. M. Deitel e P. J. Deitel

Editora: Pearson – 6ª Edição

Complete Java 2 Certification

Study Guide

Sybex


poo - 18 - sobrecarga e sobreposição de métodos

Technology