[Exercícios] Construtores e Sobrecarga #1



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
do 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 􀀀n 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.


[Exercícios] Construtores e Sobrecarga #1 [Exercícios]  Construtores e Sobrecarga #1 Reviewed by Vinicius dos Santos on 09:39:00 Rating: 5

Nenhum comentário

Escreve ai sua opinião!