Nesse post você encontrará vários exercícios que irão te fazer pensar sobre as vantagens de utilizar construtores e sobrecarga em Programação orientada a objetos. Ao resolvê-los pense sempre na melhor maneira de construir construtores e utilizar a sobrecarga deles ao seu favor.
Quer ler mais sobre o assunto antes? acesse esse artigo
1- Escreva um construtor para a classe Data que receba os valores correspondentes ao dia, mês e ano, e inicialize os campos da classe, verificando antes se a data é válida.
2- Escreva um construtor para a classe Lampada de forma que instâncias desta só possam ser criadas se um estado inicial for passado para o construtor. Esse estado pode ser o valor
booleano que indica se a lâmpada está acesa (true) ou apagada (false).
3- Considere a classe Lampada que também representa o número de watts da lâmpada (veja o exercício 2.9). Escreva dois construtores para a classe: um que recebe como argumentos o número de watts da lâmpada, e outro, sem argumentos, que considera que a lâmpada tem 60 watts por default.
4- Escreva dois construtores para a classe Contador (exercício 2.23), um que não receba argumentos e considere que o contador começa a contar a partir do zero, e outro que aceita um valor inicial para contagem.
5- Identifique e explique o(s) erro(s) na classe abaixo.
public class Data{
private byte dia,mês;
private short ano;
private Data(byte dd,byte mm,short aa){
dia = dd; mês = mm; ano = aa;
}
}
6- Identifique e explique o(s) erro(s) na classe abaixo.
public class Ponto2D {
private double x, y;
public Ponto2D(double _x, double _y) {
x = _x;
y = _y;
}
public Ponto2D(double coord1, double coord2) {
x = coord1;
y = coord2;
}
}
7- Identifique e explique o(s) erro(s) na classe abaixo.
public class DemoConstrutor {
private int a, b;
public DemoConstrutor() {
System.out.println("No construtor sem argumentos...");
DemoConstrutor(0, 0);
}
public DemoConstrutor(int xa, int xb) {
System.out.println("No construtor com argumentos...");
a = xa;
b = xb;
}
}
8- Escreva um construtor para a classe PoligonoRegular (exercício 2.25), que receba um
valor inteiro correspondente ao número de lados do polígono
9- Identifique e explique o(s) erro(s) na classe abaixo.
public class Media {
public int Media(int a, int b) {
return (a + b) / 2;
}
public double Media(int a, int b) {
return (a + b) / 2;
}
}
10- Considerando a classe RoboSimples (listagem 4.5 no livro), quais das chamadas ao método move abaixo podem ser usadas? Explique.
move();
move(1);
move(’A’);
move("A");
move(1/3);
move(2,3,5);
move(9,false);
move("17");
move((long)3);
move((char)65);
livro).
12- Escreva outro construtor para a classe Data que receba uma instância da própria classe Data e use os dados desta para inicializar os campos. Veja também o exercício 4.1.
13- Escreva três construtores para a classe NumeroComplexo (exercício 2.34). Um construtor deverá receber os dois valores (real e imaginário) como argumentos, o outro somente o valor real, considerando o imaginário como sendo zero, e o terceiro construtor não recebe argumentos, considerando as partes real e imaginária do número complexo como sendo iguais a zero.
14- Considerando as classes abaixo, para cada chamada ao método doisValores() identifique que forma do método será chamada.
public class Soma {
public int doisValores(int a, int b) // soma dois inteiros
{
return a + b;
}
public double doisValores(double a, int b) // soma um double e um inteiro
{
return a + b;
}
public double doisValores(double a, double b) // soma dois doubles
{
return a + b;
}
}
public class TesteSoma {
public static void main(String[] args) {
Soma soma = new Soma(); // cria instância da classe Soma
// Declara várias variáveis
byte b = 20;
short s = 99;
int i = 1000;
long l = 1234 L;
float f = 3.1416 f;
double d = 2000;
// Chama vários métodos da classe Soma
System.out.println(soma.doisValores(b, s));
System.out.println(soma.doisValores(i, s));
System.out.println(soma.doisValores(i, i));
System.out.println(soma.doisValores(l, b));
System.out.println(soma.doisValores(f, s));
System.out.println(soma.doisValores(d, b));
System.out.println(soma.doisValores(b, d));
System.out.println(soma.doisValores(i, l));
System.out.println(soma.doisValores(l, l));
System.out.println(soma.doisValores(d, f));
}
}
15- Escreva dois construtores para a classe Ponto2D (listagem 3.2 no livro): um sem argumentos que considere que o ponto está na origem, ou seja, com coordenadas (0; 0), e um que receba dois argumentos do tipo double e que os use para inicializar os campos da classe.
16- O que aconteceria se no construtor da classe EventoAcademico as instâncias internas
da classe Data fossem simplesmente igualadas às instâncias passadas como argumentos
(por exemplo, se escrevêssemos inícioDoEvento = i; fimDoEvento = f; em vez o trecho entre as linhas 37 e 40 da listagem 4.3 no livro)? Explique, usando a aplicação na listagem 4.4 como exemplo.
17- Escreva dois construtores para a classe ContaBancariaSimplificada (exercício 2.29), um que inicialize todos os campos da classe e outro que considere que o saldo inicial será zero e a conta não será especial.
18- Suponha que os robôs modelados pela classe RoboSimples (listagem 4.5 no livro) possam se movimentar para a frente e para trás. Escreva na classe dois métodos moveParaTrás, um que mova os robôs uma unidade e outro que aceite um valor como argumento (número de unidades a mover). Dica: Mover um robô n unidades para trás é a mesma coisa que movê-lo unidades para a frente, então podemos chamar o método move de dentro do método moveParaTrás, trocando o sinal do valor do movimento.
19- Escreva quatro construtores para a classe Linha (exercício 2.26): um sem argumentos que considere que a linha comece e termine no ponto (0; 0); um que receba um argumento do tipo Ponto2D e que considere que a linha comece na origem e termine no ponto passado
como argumento; um que receba duas instâncias da classe Ponto2D como argumentos e um
que receba quatro valores de ponto flutuante, correspondentes às duas coordenadas.
20- Escreva quatro construtores para a classe Retangulo (exercício 2.27): um sem argumentos que considere que os dois pontos extremos do retângulo tenham coordenadas iguais a (0; 0); um que receba um argumento do tipo Ponto2D e que considere que um dos pontos extremos do retângulo está na origem do sistema de coordenadas e que o outro seja o ponto passado como argumento; um que receba duas instâncias da classe Ponto2D como argumentos e as considere como pontos extremos do retângulo; e um que receba quatro valores de ponto flutuante, correspondentes às duas coordenadas dos pontos extremos.
21 – Descreva as principais vantagens de usar construtores e sobrecarga no contexto de Programação Orientada a Objetos
