Questão sobre Override

[ricardoneves93]

Boa noite, estou a programar para android, sei que aqui não é o locar para questionar sobre android, mas a duvida é essencialmente sobre o java. Eu sei o que é o override, por exemplo temos uma super classe Carro que tem um método printPeso(), imaginemos que depois temos uma classe que faz extend à classe Carro chamada Honda( ou seja é uma subclasse), eu posso para esta classe redefinir o método printPeso().

Mas à uns dias deparei-me com um caso destes:

coinS = new Sprite(CAM_WIDTH, CAM_HEIGHT - 100, coinTR, this.mEngine.getVertexBufferObjectManager()) {

@Override
protected void onManagedUpdate(final float pSecondsElapsed) {
if (Sball.collidesWith(this)) {
 setVisible(false);
 // Play pick up sound here
 addToScore();
 setIgnoreUpdate(true);
}
super.onManagedUpdate(pSecondsElapsed);
}
};

Que tipo de override é este? está associado à variável coinS? O que é mais esquisito é que encontro mais tipos de variáveis a fazer override a este mesmo método.

Obrigado pela ajuda

Edited July 19, 2013 at 10:18 PM by ricardoneves93

[KTachyon]

Está associado ao método onManagedUpdate(). Tu estás a criar um novo Sprite ao qual fazes um override a um método. No fundo é como se estivesses a criar uma subclasse do Sprite e a fazer @Override ao método, mas em vez de declarares uma nova subclasse, fazes ali directamente no código.

[Knitter]

Isso é uma forma reduzida de criar uma nova classe, anónima, estendendo de outra classe. É o mesmo que se tivesses criar um ficheiro separado e tivesse nele colocado uma classe a estender Sprite, onde apenas redefinias o método onManageUpdate. Além disso, na mesma linha, estás a instanciar um objecto da classe anónima que acabaste de criar 🙂

É um método muito comum para se passarem callbacks ou se estenderem classes para redefinir apenas um método ou dois e não vais mais precisar de usar a classe nova, já que não lhe estás a dar um nome, ou para se usar em eventos. É uma técnica bastante usada nos exemplos de Android e em toda a plataforma.

Podes ver mais sobre como criar e usar classes anónimas em http://docs.oracle.com/javase/tutorial/java/javaOO/anonymousclasses.html

[ricardoneves93]

Obrigados pelo esclarecimento. Já entendi o que estou a fazer. Mas tenho mais uma pergunta para vocês: Eu estou a instanciar um novo objecto do tipo Sprite e a declarar a classe ao mesmo tempo, isto se entendi correctamente. O que eu quero fazer é criar várias Coins ou seja preciso de um elevado numero de objectos do tipo coinS, sendo assim criar uma classe anónima já não se torna apropriado, pois iria ser necessário criar várias classes em vez de apenas uma. Concordam comigo? Outra questão estive na documentação do andengine à procura de onde vem o método OnManagedUpdate e não encontro em lado nenhum... Pelo que entendi ao criar uma classe anónima desta maneira, estou a criar uma classe que estende Sprite, logo o método ao qual faço override devia estar presente na classe Sprite ou nas suas classes mães.

Cumprimentos, Ricardo

[KTachyon]

Se a pergunta é se deves fazer desta forma se vais espalhar esta classe em vários sítios do teu código, todas com o mesmo método, a resposta é que deves criar um ficheiro onde declaras a subclasse e defines o método.

Por outro lado, se a pergunta é se, para cada instancia que fazes (por exemplo, dentro de um ciclo, ou dentro de uma função que é chamada várias vezes), a resposta é que não tens que te preocupar, porque só vais estar a criar uma única subclasse anónima.

Para te provar isso, aqui vai um exemplo:

class MyClass {
   public static void main(String[] args) {
       Object x[] = new Object[100];

       for (int i = 0; i < 10; i++) {
           x[i] = new Object() {
               @Override
               public String toString() {
                   return "Hello";
               }
           };
       }

       for (int i = 0; i < 10; i++) {
           System.out.println(i + ": " + x[i].getClass().getName());
       }
   }
}

E o output:

0: MyClass$1
1: MyClass$1
2: MyClass$1
3: MyClass$1
4: MyClass$1
5: MyClass$1
6: MyClass$1
7: MyClass$1
8: MyClass$1
9: MyClass$1

Como não podes passar variáveis do scope directamente para dentro de funções de classes anónimas (a não ser que sejam constantes - aka, final), não existem variações. O Java não é uma linguagem muito dinâmica neste aspecto.

[ricardoneves93]

Então usando o ciclo for antes da criação da classe anónima, cria uma classe anónima e com ela vários objectos?

[KTachyon]

Não é por ser num ciclo. É por serem criadas, literalmente, no mesmo sítio. Um exemplo:

class MyClass {
   public static void main(String[] args) {
       Object x[] = new Object[10];
       Object y[] = new Object[10];

       for (int i = 0; i < 10; i++) {
           x[i] = createObject(i);
           y[i] = new Object() {
                       @Override

                       public String toString() {
                           return "Hello";
                       }
                   };
       }

       for (int i = 0; i < 10; i++) {
           System.out.println(i + ": " + x[i].getClass().getName() + " --- " + x[i].toString());
       }

       for (int i = 0; i < 10; i++) {
           System.out.println(i + ": " + y[i].getClass().getName() + " --- " + y[i].toString());
       }
   }

   public static Object createObject(int i) {
       return new Object() {
                       @Override
                       public String toString() {
                           return "Hello";
                       }
                   };
   }
}

E o output:

0: MyClass$2 --- Hello
1: MyClass$2 --- Hello
2: MyClass$2 --- Hello
3: MyClass$2 --- Hello
4: MyClass$2 --- Hello
5: MyClass$2 --- Hello
6: MyClass$2 --- Hello
7: MyClass$2 --- Hello
8: MyClass$2 --- Hello
9: MyClass$2 --- Hello
0: MyClass$1 --- Hello
1: MyClass$1 --- Hello
2: MyClass$1 --- Hello
3: MyClass$1 --- Hello
4: MyClass$1 --- Hello
5: MyClass$1 --- Hello
6: MyClass$1 --- Hello
7: MyClass$1 --- Hello
8: MyClass$1 --- Hello
9: MyClass$1 --- Hello

[ricardoneves93]

Então depende do "local" onde se declaram as classes anónimas e por consequência se criam novos objectos. Acho que entendi!

Obrigado 😉

[KTachyon]

Sim. O compilador vai percorrer o código e criar as subclasses anónimas por ti, por isso, quando encontra uma declaração de uma classe anónima, simplesmente cria a nova classe. Podes ver isso se mandares compilar este código. O compilador vai gerar 3 ficheiros .class:

ktekmbp:testFolder KTachyon$ ls *.class
MyClass$1.class MyClass$2.class MyClass.class

Que correspondem precisamente às 3 classes que existem no código, a MyClass e as duas classes anónimas.

[ricardoneves93]

Está percebido!!

Cumprimentos e Obrigado.