mylab

Java, exercício de análise

assunto: interfaces, classes, heranças, métodos, classes concretas, classes abstractas

pergunta: qual o output do seguinte:

package recursopa2;

interface IA {
    String getA();
}

interface IB extends IA {
    //extends, deriva de IA
    int getB();
}

interface IC {
    int getC();
}

class D implements IB, IC {
    //implements. tem que ter todos os métodos
    //mas sendo abstract não precisa
    private String a;
    private int b, c;

    public D(String a, int b, int c) {
        this.a = a;
        this.b = b;
        this.c = c;
    }

    public String getA() {
        return a;
    }

    public int getB() {
        return b;
    }

    public int getC() {
        return c;
    }

    public void setA(String a) {
        this.a = a;
    }

    public void setB(int b) {
        this.b = b;
    }

    public void setC(int c) {
        this.c = c;
    }

    public boolean equals(Object o) {
        if (o == null || !(o instanceof D)) {
            //se a referência for nula ou se não for instanceof
            return false;
        }
        //return a.equalsIgnoreCase(o.getA());
        //o o não sabe da referencia do getA()
        //resolução do erro:
        //return a.equalsIgnoreCase(((D)o).getA());
        //resolução:
        return a.equalsIgnoreCase(((D) o).getA());
    }
}

class E extends D {
    //extends, deriva de D

    public E(String a, int b, int c) {
        //1º vai ser chamado o construtor da base
        //mas o construtor da base não tem valores por omissão

        //setA(a);
        //setB(b);
        //setC(c);
        //resolução:
        super(a, b, c);
    }
}

class F extends E {
    //extends, deriva de E
    private double d;

    public F(String a, int b, int c, double d) {
        //setA(a);
        //setB(b);
        //setC(c);
        //resolução:
        super(a, b, c);
        this.d = d;
    }

    public double getD() {
        return d;
    }

    public boolean equals(Object o) {
        if (o == null || !(o instanceof F)) {
            return false;
        }
        //return a.equalsIgnoreCase(o.getA()) && b == o.getB() && c == o.getC();
        //porque o é object, não conhece o getA, getB, getC, e o a é privado da base
        //e não temos qualquer acesso
        //resolução:
        return getA().equalsIgnoreCase(((F)o).getA()) 
                && getB() == ((F)o).getB() 
                && getC() == ((F)o).getC();
    }
} 

class main {

    public static void main(String args[]) {
        IB a = new E("abc", 1, 1);
        //classe E dreviva de D
        //D implementa IB e IC
        //assim a classe E está na linha de herança de IB
        //classe E está na descendencia de IB
        //uma referencia para o IB pode referir um objecto E
        
        D b = new F("abc", 1, 1, 2.2);
        //classe F deriva de E
        //e E deriva de B
        //F está na linha de descendencia de D
        //pode então referir um objecto de F
        
        
        IA c = new E("abc", 3, 3);
        //classe E deriva de D
        //D implementa IB, 
        //IB que deriva de IA
        //logo E está na descendencia de IA
        
        //IB d = new IB();
        //dá erro
        //criar um objeto de uma interface
        //com funções abstractas 
        //não é possivel
        
        IC e = new F("ddd", 4, 4, 4.4);
        //F deriva de E
        //E deriva de D
        //D implementa IC
        //F está na descendencia de IC
        //F é uma classe concreta

        IA r1[] = new D[5];
        //criar um array de referências new D[5];
        //D é uma classe abstracta  
        //não se pode criar objetos da classe D
        //mas podemos criar arrays de referências para D
        //mas que depois se refere a objectos de classes
        //derivadas de D mas que são concretas
        //assim, podemos criar arrays de referências para
        //classes abstractas
        //e IA está na herança da linha para cima 
        
        IA r2[] = new IB[5];
        //tambem se pode criar arrays para referências
        //de interfaces, porque se trata de arrays 
        //de referências, e essas referências 
        //vão ser objectos de classes concretas
        //e que implementam directa ou indirectamente
        //este interface 
        //e IA está na linha de herança de IB
        
        
        //IB r3[] = new IA[5];
        //dá erro
        //porque estamos a observar a herança ao contrário
        //o IA é que é a base de IB
        //a derivada a receber a base não
        
        IC r4[] = new IC[5];
        //um array para referêncas para interfaces new IC[5]
        //e é uma classe concreta

        System.out.println(a);
        System.out.println(b);
        
        System.out.println(a.equals(b));
        //a é um objecto da classe E
        //o a chama o equals, 
        //o a é da classe E
        //a classe E não tem o equals
        //mas a classe E deriva de D que tem
        //vai ter a versão herdada
        //e também
        //b é um objecto da classe F
        //f é instanciaof de D (é derivada da derivada de D)
        //e na comparação interessa o getA que é a string "abc"
        //resultado: true
        
        System.out.println(b.equals(a));
        //b é uma objecto   da classe F
        //vai ser chamado o equals da classe F
        //membroA e membroB e membroC sejam iguais
        //o a é um objecto de E
        //E é instanceof D
        //e por esse motivo não faz mais nada
        //resultado: false
        
        //o (o instanceof F)
        //não garante uma simetria de igualdade
          
        System.out.println(c.equals(b));
        //c é uma objecto da classe E
        //E, em um equals que exige  
        //que o argumento seja (o instanceof D)
        //e D tem que getA, string, seja igual
        //resultado: true
        
        System.out.println(c.getA());
        //resultado: abc
        
        //System.out.println(e.getA());
        //tem erro 
        //o e é uma referencia para IC
        //o IC só tem o método getC
        //quem tem o getA é o interface IA
    }
}