08 Sobrecarga em JAVA

Prévia do material em texto

Sobrecarga em JAVA
Apresentação
Java é uma linguagem de programação orientada a objetos, o que significa que ela trabalha com 
objetos que são atributos (dados) e objetos que são métodos (procedimentos sobre os dados).
Em orientação a objetos, sobrecarga de método é quando existem dois métodos com o mesmo 
nome, mas com assinaturas diferentes, isto é, dois métodos podem ter o mesmo nome se tiverem 
diferentes números e tipos de parâmetros. Já polimorfismo significa executar de diversas formas 
uma chamada de método. Sobrecarga e polimorfismo facilitam o reúso de código, reduzindo o 
trabalho do desenvolvedor.
Nesta Unidade de Aprendizagem, você vai aprender os conceitos de sobrecarga e polimorfismo e 
terá acesso a exemplos práticos sobre como implementá-los em seus programas.
Bons estudos.
Ao final desta Unidade de Aprendizagem, você deve apresentar os seguintes aprendizados:
Definir sobrecarga.•
Identificar polimorfismo.•
Construir uma aplicação de sobrecarga.•
Desafio
Trabalhar com sobrecarga de métodos em orientação a objetos pode trazer muitas vantagens, 
como melhor organização do código. Entretanto, é importante ter bom conhecimento sobre o 
assunto para aplicá-lo da melhor forma em seus projetos.
Você trabalha como analista/programador em uma fábrica de software e foi encarregado de atender 
uma empresa de construção civil. O cliente precisa realizar o cálculo para obter a área exata de 
cômodos do projeto arquitetônico para elaborar o orçamento. Seus projetos são baseados em três 
figuras geométricas: retângulo, quadrado e trapézio. Sabe-se que as fórmulas para o cálculo das 
áreas são as seguintes: quadrado {lado × lado}, retângulo {base × altura} e trapézio {(base maior + 
base menor) × altura)/2}.
Assim, utilize uma linguagem de programação orientada a objetos para executar a tarefa. Crie uma 
classe chamada "Area", que contenha os métodos, e outra de controle; na classe de controle, 
instancie a classe "Area". Chame os métodos das respectivas figuras por meio de uma variável de 
referência e insira alguns valores para teste. Após, exporte o projeto em um arquivo zip e o envie 
como anexo.
Infográfico
A assinatura do método é um conceito muito relevante no entendimento de sobrecarga e 
polimorfismo. No entanto, para entender a fundo os conceitos, é interessante usar algum tipo de 
visualização que faça a correlação entre as expressões.
O Infográfico a seguir apresenta os conceitos de sobrecarga, com os respectivos exemplos. 
Aponte a câmera para o 
código e acesse o link do 
conteúdo ou clique no 
código para acessar.
https://statics-marketplace.plataforma.grupoa.education/sagah/1de89228-2e24-4c02-906d-0f6150a1873c/bb6e2b8f-1a63-434b-b6d4-53d46f209dc5.png
Conteúdo do Livro
Leia o capitulo sobrecarga de métodos da obra Java para Iniciantes, base teórica desta unidade.
Boa leitura.
Atualizado para JAVA SE 8 (JDK 8)
Java
para iniciantes
Crie, compile e execute programas Java rapidamente
Herbert Schildt
Schildt
J
a
v
a
 p
a
ra
 in
ic
ia
n
te
s
 
Java
para iniciantes
Herbert Schildt
Conhecimento essencial – rápido e fácil!
• Principais habilidades e conceitos: 
cada capítulo inicia com uma lista das 
habilidades que serão abordadas.
• Pergunte ao especialista: seções 
de perguntas e respostas com 
informações adicionais e dicas úteis.
• Tente isto: exercícios que mostram 
como aplicar suas habilidades.
• Testes: perguntas ao fi nal dos 
capítulos testam o conhecimento 
adquirido.
• Sintaxe comentada: códigos com 
comentários que descrevem as 
técnicas de programação discutidas.
Feito para aprendizagem rápida:
TECNOLOGIA DA INFORMAÇÃO – PROGRAMAÇÃO
AGUILAR, L.
Programação em C++, 2.ed.
ARNOLD, K.; GOSLING, J.; HOLMES, D.
A Linguagem de Programação Java, 4.ed.
DEITEL, P.; DEITEL, H.; DEITEL, A.
*Android para Programadores, 2.ed.
*Android: Como Programar, 2.ed.
FLANAGAN, D.
JavaScript – O Guia Definitivo, 6.ed.
GALUPPO, F.; MATHEUS, V.; SANTOS, W.
Desenvolvendo com C#
GOODRICH, M.T.; TAMASSIA, R.
Estruturas de Dados e Algoritmos em Java, 5.ed.
HORSTMANN, C.
Conceitos de Computação com o Essencial de C++, 3.ed.
Conceitos de Computação com o Essencial de Java, 3.ed.
Conceitos de Computação com Java, 5.ed.
KOCHAN, S.
Programação com Objective-C, 5.ed.
LIPPMAN, S.B.
C# - Um guia prático
MEYERS, S.
C++ Eficaz, 3.ed.
PINHEIRO, F.A.C.
Elementos de Programação em C
SCHILDT, H.
Java para Iniciantes, 6.ed.
Programação com Java
SEBESTA, R.W.
Conceitos de Linguagens de Programação, 9.ed.
STROUSTRUP, B.
Princípios e Práticas de Programação com C++
TUCKER, A.B.; NOONAN, R.E.
Linguagens de Programação – Princípios e Paradigmas
* Livros em produção no momento de publicação desta obra, mas que muito 
em breve estarão disponíveis em língua portuguesa.
PROGRAMAÇÃO
www.grupoa.com.br
J
a
v
a
p
a
ra
 in
ic
ia
n
te
s
Schildt
A Bookman Editora é um dos selos edi-
toriais do Grupo A Educação, empresa 
que oferece soluções em conteúdo, 
tecnologia e serviços para a educação 
acadêmica e profissional. 
www.grupoa.com.br
0800 703 3444
Aprenda rapidamente os fundamentos da programação Java com 
Herbert Schildt, autor best-seller de publicações sobre programação. 
Totalmente atualizado para Java Platform, Standard Edition 8 (Java 
SE 8), Java para iniciantes, 6ª edição apresenta os aspectos básicos
da linguagem – como criar, compilar e executar um programa Java – 
e discute as palavras-chave, a sintaxe e as estruturas que formam a 
base da linguagem. Também aborda recursos mais avançados, incluindo 
programação com várias threads, tipos genéricos e Swing, além de 
descrever alguns dos novos recursos de JAVA SE 8, como expressões 
lambda e métodos de interface padrão. Uma introdução a JavaFX, a 
mais nova GUI de Java, conclui este livro.
Acesse o nosso site, www.grupoa.com.br, cadastre-se gratuitamente, encontre a 
página do livro por meio do campo de busca e clique no link Conteúdo Online para 
fazer download dos códigos utilizados neste livro.
Catalogação na publicação: Poliana Sanchez de Araujo – CRB 10/2094
S334j Schildt, Herbert.
Java para iniciantes : crie, compile e execute programas 
Java rapidamente [recurso eletrônico] / Herbert Schildt ; 
tradução: Aldir José Coelho Corrêa da Silva ; revisão 
técnica: Maria Lúcia Blanck Lisbôa. – 6. ed. – Porto Alegre : 
Bookman, 2015.
Editado como livro impresso em 2015.
 ISBN 978-85-8260-337-6
1. Linguagem de programação - Java. I. Título.
CDU 004.438Java
O autor
O autor de best-sellers Herbert Schildt escreve incansavelmente sobre programação 
há quase três décadas e é uma das principais autoridades na linguagem Java. Seus 
livros de programação venderam milhões de cópias no mundo inteiro e foram tra-
duzidos para diversos idiomas. É autor de vários livros sobre Java, incluindo Java: 
The Complete Reference, Herb Schildt’s Java Programming Cookbook e Swing: A 
Beginner’s Guide. Ele também escreveu sobre C, C++ e C#. Embora tenha interesse 
em todas as áreas da computação, seu foco principal são as linguagens de progra-
mação, incluindo compiladores, interpretadores e linguagens de controle robótico. 
Também tem grande interesse na padronização de linguagens. Schildt tem gradua-
ção e pós-graduação pela Universidade de Illinois. Seu site é www.HerbSchildt.com.
O editor técnico
Dr. Danny Coward trabalhou em todas as edições da plataforma Java. Ele conduziu 
a definição dos Java Servlets para a primeira versão da plataforma Java EE e para 
além dela, os serviços web para a plataforma Java ME, e a estratégia e planejamento 
de Java SE 7. Fundou a tecnologia JavaFX e, mais recentemente, projetou o maior 
acréscimo feito ao padrão Java EE 7, a API Java WebSocket. Da codificação em Java 
ao projeto de APIs com especialistas da indústria e ao trabalho por vários anos como 
executivo do Java Community Process, ele adquiriu uma perspectiva singularmente 
ampla de vários aspectos da tecnologia Java. Além disso, é autor de JavaWebSo-
cket Programming e de um livro ainda a ser publicado sobreJava EE. Dr. Coward 
tem graduação, mestrado e doutorado em Matemática pela Universidade de Oxford.
Schildt_Iniciais_6ed_Eletronico.indd iiSchildt_Iniciais_6ed_Eletronico.indd ii 23/03/15 16:1023/03/15 16:10
188 Java para Iniciantes
 e = err.getErrorInfo(19);
 System.out.println(e.msg + " severity: " + e.severity);
 }
}
Aqui está a saída:
Disk Full severity: 2
Invalid Error Code severity: 0
Sempre que getErrorInfo( ) é chamado, um novo objeto Err é criado e uma refe-
rência a ele é retornada para a rotina chamadora. Esse objeto é então usado dentro de 
main( ) para exibir a mensagem de erro e o código de gravidade.
Quando um objeto é retornado por um método, ele continua existindo até não 
ser mais referenciado. Nesse momento, é alvo da coleta de lixo. Logo, um objeto não 
será destruído só porque o método que o criou foi encerrado.
Sobrecarga de métodos
Nesta seção, você conhecerá um dos mais fascinantes recursos Java: a sobrecarga 
de métodos. Em Java, dois ou mais métodos da mesma classe podem compartilhar o 
mesmo nome, contanto que suas declarações de parâmetros sejam diferentes. Quan-
do é esse o caso, diz-se que os métodos são sobrecarregados e o processo é chamado 
de sobrecarga de método. A sobrecarga de métodos é uma das maneiras pelas quais 
Java implementa o polimorfismo.
Em geral, para sobrecarregar um método, só temos que declarar versões di-
ferentes dele. O compilador se incumbe do resto. Porém, é preciso prestar atenção 
em uma restrição importante: o tipo e/ou a quantidade dos parâmetros de cada 
método sobrecarregado devem diferir. Não é o bastante dois métodos diferirem 
apenas em seus tipos de retorno. (Os tipos de retorno não fornecem informações 
suficientes em todos os casos para Java decidir que método usar.) Mas os métodos 
sobrecarregados também podem diferir em seus tipos de retorno. Quando um mé-
todo sobrecarregado é chamado, sua versão cujos parâmetros coincidem com os 
argumentos é executada.
Aqui está um exemplo simples que ilustra a sobrecarga de métodos:
// Demonstra a sobrecarga de métodos.
class Overload {
 void ovlDemo() {
 System.out.println("No parameters");
 }
 // Sobrecarrega ovlDemo para um parâmetro inteiro.
 void ovlDemo(int a) {
 System.out.println("One parameter: " + a);
 }
 // Sobrecarrega ovlDemo para dois parâmetros inteiros.
Primeira versão
Segunda versão
Schildt_06.indd 188Schildt_06.indd 188 24/02/15 09:1024/02/15 09:10
Capítulo 6 Verificação minuciosa dos métodos e classes 189
 int ovlDemo(int a, int b) {
 System.out.println("Two parameters: " + a + " " + b);
 return a + b;
 }
 // Sobrecarrega ovlDemo para dois parâmetros double.
 double ovlDemo(double a, double b) {
 System.out.println("Two double parameters: " +
 a + " " + b);
 return a + b;
 }
}
class OverloadDemo {
 public static void main(String args[]) {
 Overload ob = new Overload();
 int resI;
 double resD;
 // chama todas as versões de ovlDemo()
 ob.ovlDemo();
 System.out.println();
 ob.ovlDemo(2);
 System.out.println();
 resI = ob.ovlDemo(4, 6);
 System.out.println("Result of ob.ovlDemo(4, 6): " +
 resI);
 System.out.println();
 resD = ob.ovlDemo(1.1, 2.32);
 System.out.println("Result of ob.ovlDemo(1.1, 2.32): " +
 resD);
 }
}
Esse programa gera a saída a seguir:
No parameters
One parameter: 2
Two parameters: 4 6
Result of ob.ovlDemo(4, 6): 10
Two double parameters: 1.1 2.32
Result of ob.ovlDemo(1.1, 2.32): 3.42
Como ficou claro, ovlDemo( ) é sobrecarregado quatro vezes. A primeira ver-
são não usa parâmetros, a segunda recebe um parâmetro inteiro, a terceira recebe 
Terceira versão
Quarta versão
Schildt_06.indd 189Schildt_06.indd 189 24/02/15 09:1024/02/15 09:10
190 Java para Iniciantes
dois parâmetros inteiros e a quarta usa dois parâmetros double. Observe que as duas 
primeiras versões de ovlDemo( ) retornam void e as outras duas retornam um valor. 
Isso é perfeitamente válido, mas, como explicado, a sobrecarga não é afetada pelo 
tipo de retorno de um método. Logo, a tentativa de usar as duas versões a seguir de 
ovlDemo( ) causará erro.
// É correto usar um método ovlDemo(int).
void ovlDemo(int a) {
 System.out.println("One parameter: " + a);
}
/* Erro! Não é correto usar dois métodos ovlDemo(int) 
 mesmo que os tipos de retorno sejam diferentes.
*/
int ovlDemo(int a) {
 System.out.println("One parameter: " + a);
 return a * a;
}
Como os comentários sugerem, a diferença nos tipos de retorno é insuficiente no 
caso da sobrecarga.
Pelo que vimos no Capítulo 2, Java fornece algumas conversões de tipo auto-
máticas. Essas conversões também são aplicáveis a parâmetros de métodos sobrecar-
regados. Por exemplo, considere o seguinte:
/* Conversões de tipo automáticas podem afetar
 a definição do método sobrecarregado.
*/
class Overload2 {
 void f(int x) {
 System.out.println("Inside f(int): " + x);
 }
 void f(double x) {
 System.out.println("Inside f(double): " + x);
 }
}
class TypeConv {
 public static void main(String args[]) {
 Overload2 ob = new Overload2();
 int i = 10;
 double d = 10.1;
 byte b = 99;
 short s = 10;
 float f = 11.5F;
 ob.f(i); // chama ob.f(int)
 ob.f(d); // chama ob.f(double)
Os tipos de retorno não 
podem ser usados para 
diferenciar métodos 
sobrecarregados.
Schildt_06.indd 190Schildt_06.indd 190 24/02/15 09:1024/02/15 09:10
Capítulo 6 Verificação minuciosa dos métodos e classes 191
 ob.f(b); // chama ob.f(int) - conversão de tipo
 ob.f(s); // chama ob.f(int) - conversão de tipo
 ob.f(f); // chama ob.f(double) – conversão de tipo
 }
}
A saída do programa é mostrada aqui:
Inside f(int): 10
Inside f(double): 10.1
Inside f(int): 99
Inside f(int): 10
Inside f(double): 11.5
Nesse exemplo, só duas versões de f( ) são definidas: uma com parâmetro int e outra 
com parâmetro double. No entanto, é possível passar para f( ) um valor byte, short 
ou float. No caso de byte e short, Java os converte automaticamente em int. Logo, 
f(int) é chamado. No caso de float, o valor é convertido para double e f(double) é 
chamado.
Porém, é importante entender que as conversões automáticas só são aplicá-
veis quando não há correspondência direta entre um parâmetro e um argumento. 
Por exemplo, este é o programa anterior com a inclusão de uma versão de f( ) que 
especifica um parâmetro byte:
// Adiciona f(byte).
class Overload2 {
 void f(byte x) {
 System.out.println("Inside f(byte): " + x);
 }
 void f(int x) {
 System.out.println("Inside f(int): " + x);
 }
 void f(double x) {
 System.out.println("Inside f(double): " + x);
 }
}
class TypeConv {
 public static void main(String args[]) {
 Overload2 ob = new Overload2();
 int i = 10;
 double d = 10.1;
 byte b = 99;
 short s = 10;
 float f = 11.5F;
 ob.f(i); // chama ob.f(int)
Esta versão especifica 
um parâmetro byte.
Schildt_06.indd 191Schildt_06.indd 191 24/02/15 09:1024/02/15 09:10
192 Java para Iniciantes
 ob.f(d); // chama ob.f(double)
 ob.f(b); // chama ob.f(byte) – agora, sem conversão de tipo
 ob.f(s); // chama ob.f(int) - conversão de tipo
 ob.f(f); // chama ob.f(double) – conversão de tipo
 }
}
Agora, quando o programa é executado, a saída a seguir é produzida:
Inside f(int): 10
Inside f(double): 10.1
Inside f(byte): 99
Inside f(int): 10
Inside f(double): 11.5
Nessa versão, já que há uma variante de f( ) que recebe um argumento byte, quando 
f( ) é chamado com esse argumento, f(byte) é chamado e não ocorre a conversão 
automática para int.
A sobrecarga de métodos dá suporte ao polimorfismo, porque é uma maneira 
de o Java implementar o paradigma “uma interface, vários métodos”. Para entender 
como, considere o seguinte: Em linguagens que não dão suporte à sobrecarga de 
métodos,cada método deve receber um nome exclusivo. No entanto, é frequente 
querermos implementar o mesmo método para tipos de dados diferentes. Considere 
a função do valor absoluto. Em linguagens que não dão suporte à sobrecarga, ge-
ralmente há três ou mais versões dessa função, cada uma com um nome um pouco 
diferente. Por exemplo, em C, a função abs( ) retorna o valor absoluto de um inteiro, 
labs( ) retorna o valor absoluto de um inteiro longo e fabs( ) retorna o valor absoluto 
de um valor de ponto flutuante. Já que C não dá suporte à sobrecarga, cada função 
precisa ter seu próprio nome, ainda que as três façam essencialmente a mesma coisa. 
Conceitualmente, isso torna a situação mais complicada do que já é. Embora o con-
ceito subjacente a todas as funções seja igual, temos três nomes para lembrar. Essa 
situação não ocorre em Java, porque todos os métodos do valor absoluto podem usar 
o mesmo nome. Na verdade, a biblioteca padrão de classes Java inclui um método 
do valor absoluto, chamado abs( ). Esse método é sobrecarregado pela classe Java 
Math para tratar todos os tipos numéricos. Java determina que versão de abs( ) será 
chamada com base no tipo de argumento.
A vantagem da sobrecarga é ela permitir que métodos relacionados sejam aces-
sados com o uso de um nome comum. Portanto, o nome abs representa a ação geral 
que está sendo executada. A seleção da versão correta específica para uma determi-
nada circunstância é deixada para o compilador. Você, o programador, só tem que 
lembrar a operação geral que está sendo executada. Com a aplicação do polimor-
fismo, vários nomes foram reduzidos para um. Embora esse exemplo seja muito 
simples, se você expandir o conceito, verá como a sobrecarga ajuda a gerenciar uma 
complexidade ainda maior.
Quando você sobrecarregar um método, cada versão dele poderá executar qual-
quer atividade desejada. Não há uma regra declarando que os métodos sobrecar-
regados devem estar relacionados. No entanto, de um ponto de vista estilístico, a 
Schildt_06.indd 192Schildt_06.indd 192 24/02/15 09:1024/02/15 09:10
Capítulo 6 Verificação minuciosa dos métodos e classes 193
sobrecarga de método implica um relacionamento. Logo, embora você possa usar o 
mesmo nome para sobrepor métodos não relacionados, não deve fazê-lo. Por exem-
plo, você poderia usar o nome sqr para criar métodos que retornassem o quadrado 
de um inteiro e a raiz quadrada de um valor de ponto flutuante. Mas essas duas 
operações são basicamente diferentes. A aplicação da sobrecarga de métodos dessa 
forma frustra seu objetivo original. Na prática, você só deve sobrepor operações in-
timamente relacionadas.
Sobrecarregando construtores
Como os métodos, os construtores também podem ser sobrecarregados. Isso permite 
a construção de objetos de várias maneiras. Por exemplo, considere o programa a 
seguir:
// Demonstra um construtor sobrecarregado.
class MyClass {
 int x;
 MyClass() {
 System.out.println("Inside MyClass().");
 x = 0;
 }
 MyClass(int i) {
 System.out.println("Inside MyClass(int).");
 x = i;
 }
 MyClass(double d) {
 System.out.println("Inside MyClass(double).");
 x = (int) d;
 }
 MyClass(int i, int j) {
 System.out.println("Inside MyClass(int, int).");
 x = i * j;
 }
}
class OverloadConsDemo {
Constrói objetos de várias maneiras
P: Já ouvi programadores de Java usarem o termo assinatura. Do que se trata?
R: No contexto Java, uma assinatura é o nome de um método mais sua lista de parâme-
tros. Logo, para fins de sobrecarga, dois métodos da mesma classe não podem ter a 
mesma assinatura. É bom ressaltar que uma assinatura não inclui o tipo de retorno, já 
que ele não é usado por Java para a definição da sobrecarga.
Pergunte ao especialista
Schildt_06.indd 193Schildt_06.indd 193 24/02/15 09:1024/02/15 09:10
194 Java para Iniciantes
 public static void main(String args[]) {
 MyClass t1 = new MyClass();
 MyClass t2 = new MyClass(88);
 MyClass t3 = new MyClass(17.23);
 MyClass t4 = new MyClass(2, 4);
 System.out.println("t1.x: " + t1.x);
 System.out.println("t2.x: " + t2.x);
 System.out.println("t3.x: " + t3.x);
 System.out.println("t4.x: " + t4.x);
 }
}
A saída do programa é mostrada aqui:
Inside MyClass().
Inside MyClass(int).
Inside MyClass(double).
Inside MyClass(int, int).
t1.x: 0
t2.x: 88
t3.x: 17
t4.x: 8
MyClass( ) é sobrecarregado de quatro maneiras, cada uma construindo um objeto 
diferentemente. O construtor apropriado é chamado de acordo com os parâmetros es-
pecificados quando a instrução new é executada. Ao sobrecarregar o construtor, da-
mos ao usuário da classe flexibilidade na maneira como os objetos são construídos.
Uma das razões mais comuns para a sobrecarga de construtores é um obje-
to poder inicializar outro. Por exemplo, considere um programa que usa a classe 
Summation para calcular a soma de um valor inteiro:
// Inicializa um objeto com outro.
class Summation {
 int sum;
 // Constrói a partir de um int.
 Summation(int num) {
 sum = 0;
 for(int i=1; ia câmera para o código e acesse o link do conteúdo ou clique no código para acessar.
https://fast.player.liquidplatform.com/pApiv2/embed/cee29914fad5b594d8f5918df1e801fd/186ded93d2c891b0ecce6f607ed67f68
Exercícios
1) Um dos principais paradigmas de programação determina que os programadores decidam o 
melhor caminho e sejam capazes de solucionar problemas de alta complexidade. Para isso, 
diferentes métodos, funções e recursos são aplicados ao código. Sobrecarga e polimorfismo 
são conceitos úteis na programação orientada a objetos.
Quando ocorre a sobrecarga de métodos?
A) Quando um método é declarado com void. 
B) Quando não se declara void, mas um tipo de dado nos métodos. 
C) Quando o método é declarado com a palavra abstract. 
D) Quando um ou mais métodos têm a mesma assinatura, mas implementações específicas de 
acordo com a classe a que pertencem.
E) Quando um ou mais métodos têm o mesmo nome, mas conjuntos de parâmetros diferentes.
2) Na programação orientada a objetos, assinatura é a identificação única de um método. É 
comum, ao trabalhar com métodos, utilizar a expressão "assinatura do método".
Marque a alternativa que melhor explica do que se trata essa expressão.
A) Assinatura do método é quando a palavra-chave public é colocada no início da declaração do 
método. 
B) Assinatura do método é quando se declara variáveis e tipos no argumento do método. 
C) Assinatura do método consiste em toda a declaração do método, menos o seu corpo.
D) A assinatura do método é composta por seu nome e parâmetros.
E) Assinatura do método refere-se ao conjunto de parâmetros desse método.
No contexto de programação orientada a objetos, um programador pode definir o que está 
sendo implementado, ao analisar o código, identificando de que forma os objetos trocam 
3) 
mensagens entre si; o mesmo ocorre com a sobreposição e a sobrecarga. Para saber se um 
programa em Java apresenta sobrecarga, é preciso analisar o código-fonte.
Analise os códigos a seguir e informe em qual deles existe sobrecarga de métodos.
A) public abstract class Area { public abstract void calcular(); }
B) public class Pessoa { private String nome; public String getNome() { return nome; } public void 
setNome(String nome) { this.nome = nome; } }
C) public class Colaborador { String nome; String endereco; public Colaborador(String nome, 
String endereco){ this.nome = nome; this.endereco = endereco; } }
D) public class Colaborador { String nome; String endereco; public Colaborador(){ } public 
Colaborador(String nome){ this.nome = nome; } public Colaborador(String nome, String 
endereco){ this.nome = nome; this.endereco = endereco; } }
E) public class Colaborador { private String nome; private String endereco; public Colaborador(){ 
} public String getNome() { return nome; } public void setNome(String nome) { this.nome = 
nome; } public String getEndereco() { return endereco; } public void setEndereco(String 
endereco) { this.endereco = endereco; } }
4) Sobrecarga de método (sobrecarga) é um conceito de polimorfismo, que basicamente 
envolve a criação de variantes do mesmo método, ou seja, a criação de dois ou mais 
métodos com o mesmo nome em uma classe. Por esse motivo, é possível tratar a sobrecarga 
de métodos como um tipo de polimorfismo.
Marque a alternativa que melhor explica o polimorfismo.
A) Trata-se de uma técnica na qual subclasses herdam membros da superclasse.
B) É quando uma classe implementa uma interface.
C) É quando o mesmo método é utilizado de maneiras diferentes de acordo com a necessidade 
de cada classe.
D) É quando se utiliza o método com o mesmo nome, mas alterando seu conjunto de 
parâmetros, sejam números, ordem dos parâmetros ou tipos diferentes.
E) Polimorfismo é quando uma classe tem métodos set e get.
Sobrecarga e polimorfismo são muito úteis em Java para facilitar o reúso de código já criado.5) 
Em relação à sobrecarga e ao polimorfismo, é correto afirmar que:
A) quando os métodos de uma mesma classe têm a mesma assinatura, tem-se a ocorrência de 
sobrecarga.
B) há sobrecarga de métodos quando, em classes diferentes, há métodos com mesmo nome e 
conjunto de parâmetros diferentes. 
C) na sobrecarga, o tipo e/ou a quantidade dos parâmetros de cada método sobrecarregado 
devem diferir. 
D) quando uma interface é implementada e seus métodos são usados de forma específica em 
cada classe, caracteriza-se a sobrecarga. 
E) na sobrecarga, os métodos têm implementações sempre idênticas.
Na prática
A sobrecarga de métodos pode ser utilizada em diferentes situações; ela consiste na reutilização do 
nome em mais de um método. No entanto, para haver sobrecarga, a assinatura do método deve 
mudar, ou seja, precisa haver diferença nos parâmetros.
Veja, Na Prática, como usar a sobrecarga em dois métodos de soma, em que um método recebe 
dois valores como input e outro recebe três valores. 
Aponte a câmera para o 
código e acesse o link do 
conteúdo ou clique no 
código para acessar.
https://statics-marketplace.plataforma.grupoa.education/sagah/af9bc0a0-dbf8-4f9a-a736-d99e8a9d9e6a/82e2c298-42de-4769-819b-7251cb1a0dcc.png
Saiba mais
Para ampliar o seu conhecimento a respeito desse assunto, veja abaixo as sugestões do professor:
Polimorfismo em Java
Neste vídeo, aprofunde seu conhecimento prático sobre como funciona o polimorfismo em Java.
Aponte a câmera para o código e acesse o link do conteúdo ou clique no código para acessar.
Padrões e projetos orientados a objetos
No livro Padrões e projetos orientados a objetos, de Cay Horstmann, aprenda sobre sobrecarga de 
operadores. Disponível em:
Conteúdo interativo disponível na plataforma de ensino!
https://www.youtube.com/embed/NctjqlfKC0U