mylab

Java, exercício de análise

assunto: interfaces, funções abstracta, derivadas
e funções default: não sou obrigado a redefinir, não é abstracta, tem uma implementação por omissão
e funções static

pergunta: qual o output do seguinte:

package recursopa2;

interface Pagamento {
    void receber();
    void darTroco();
}

abstract class Parquimetro implements Pagamento {
    private String cidade;

    Parquimetro(String s) {
        cidade = s;
    }

    abstract void calcula();

    void calcula2() {
    }
}

interface RegistaVisita {
    void registaVisita();
}

//ser derivada de Parquimetro e "do tipo" RegistaVisita 
// "do tipo" -> impementa a interface RegistaVisita
// "ser concreta", todos os métodos têm que ser concretizados 
//e o membro cidade ser inicializada com "Coimbra"
//assim,
//se forem default ou static não é preciso/não é obrigatório redefinir 
//se a base, for do extendes, e estiver concretizada, não preciso de a redefinir  void calcula2()
//os métodos das outras classes de que esta deriva ou que desagua 
class ParquimetroCoimbra extends Parquimetro implements RegistaVisita {
    public ParquimetroCoimbra() {
        super("Coimbra");
    }
    void calcula() {
    }
    public void registaVisita() {
    }

    public void receber() {
    }

    public void darTroco() {
    }
}

//public class main
class main {
    public static void main(String[] args) {

    }
}

assunto: equals, arrays
pergunta: qual o output do seguinte:

package recursopa2;

import java.util.ArrayList;
import java.util.List;

class A {
    int n;
    A(int nn) {
        n = nn;
    }
    //não tem uma redefinição do equals
    //tem apenas a do object
}

class B extends A {
    B(int nn) {
        super(nn);
    }
    public boolean equals(B obj) {
        return true;
    }
    //"trocar", e podem coexistir
//    public boolean equals(Object obj) {
//        return true;
//    }
}

class main {

    static public void main(String[] args) {
        A r1 = new A(10);
        A r2 = new A(10);
        A r3 = new B(10);
        A r4 = new B(10);

        System.out.println("r1.equals(r2) " + r1.equals(r2));
        //a classA não tem o seu equals, herda do object
        //assim os objectos estão em diferentes endereços
        //saida: false

        System.out.println("r3.equals(r4) " + r3.equals(r4));
        //a classeB tem um equals
        //r3 equals r4, r3 chama a equals através de uma referência de r3 para A
        //vai chamar a equals que A conhece, e A que a conhece é da object
        //e em A não existe uma redefinição da equals
        //saida: false

        //mas para ser true era "trocar"
        //r3 invoca a função equals que conhece
        //que é o equals da object
        //mas o polimorfismo como aponta para o objecto do tipo B
        //e assim sendo vai buscar a versão da b "trocar"
        
        List<B> list = new ArrayList<B>();
        B b1 = new B(4);
        B b2 = new B(4);
        list.add(b1);
        list.add(b2);
        System.out.println("list contem new B(4)? " + list.contains(new B(4)));
        //o contains no array, vai pegar no objecto e vai fazer o equals 
        //com os que já lá estão, e o array lista usa apenas a equals do object
        //que compara referências, e por esse motivo diz que não está lá
        //saida: false
    }
}

assunto: excepções

pergunta: qual o output do seguinte:

package recursopa2;

class EstaExcepcao extends Exception {
}

class main {
    static void f() throws EstaExcepcao {
        try {
            System.out.println("Ponto 1");
            throw new EstaExcepcao();
            //saida: ponto 1
            
            //System.out.println("AAAAA"); //se existir dá erro
            //depois do lançamento da excepção dá sempre erro 
        } catch (EstaExcepcao e) {
            System.out.println("Ponto 2");
            //saida: ponto 2
            
            throw e;
            //vai ser relançada
        } finally {
            System.out.println("Ponto 3");
            //saida: ponto 3
        }
         //System.out.println("BBBB"); //se existice
         //como houve erro nunca iria ser executada, por exemplo
         //não havendo o throw
    }

    public static void main(String[] args) {
        try {
            f(); 
            // f() sai em erro, vai fazer o catch
            System.out.println("Ponto 4");
        } catch (EstaExcepcao e) {
            System.out.println("Ponto 5");
            //saida: ponto 5
        } catch (Exception e) {
            System.out.println("Ponto 6");
        }
        System.out.println("Ponto 7");
        //saida: ponto 5
    }
}