Construtores e Sobrecarga

Construtores e Sobrecarga

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);
 
11- Liste as assinaturas dos construtores e métodos na classe RoboSimples (listagem 4.5 no
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

Vinicius dos Santos

Apenas um apaixonado por Ciência da Computação e forma com que ela pode transformar vidas!

Deixe uma resposta