Jump to content
ricardoneves93

Questão sobre Override

Recommended Posts

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 by ricardoneves93

Share this post


Link to post
Share on other sites
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.


“There are two ways of constructing a software design: One way is to make it so simple that there are obviously no deficiencies, and the other way is to make it so complicated that there are no obvious deficiencies. The first method is far more difficult.”

-- Tony Hoare

Share this post


Link to post
Share on other sites
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

Share this post


Link to post
Share on other sites
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

Share this post


Link to post
Share on other sites
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.


“There are two ways of constructing a software design: One way is to make it so simple that there are obviously no deficiencies, and the other way is to make it so complicated that there are no obvious deficiencies. The first method is far more difficult.”

-- Tony Hoare

Share this post


Link to post
Share on other sites
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


“There are two ways of constructing a software design: One way is to make it so simple that there are obviously no deficiencies, and the other way is to make it so complicated that there are no obvious deficiencies. The first method is far more difficult.”

-- Tony Hoare

Share this post


Link to post
Share on other sites
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.


“There are two ways of constructing a software design: One way is to make it so simple that there are obviously no deficiencies, and the other way is to make it so complicated that there are no obvious deficiencies. The first method is far more difficult.”

-- Tony Hoare

Share this post


Link to post
Share on other sites

Create an account or sign in to comment

You need to be a member in order to leave a comment

Create an account

Sign up for a new account in our community. It's easy!

Register a new account

Sign in

Already have an account? Sign in here.

Sign In Now

×
×
  • Create New...

Important Information

By using this site you accept our Terms of Use and Privacy Policy. We have placed cookies on your device to help make this website better. You can adjust your cookie settings, otherwise we'll assume you're okay to continue.