Modificador static nos metodos, codigo mais rapido ?

Alias.. cade a explicação do Thingol sobre Reflection?

This message was edited 4 times. Last update was at 16/01/2009 12:16:50

Bem, não sei muito sobre como o reflection é implementado, mas sei um pouco. E já que o thingol não compareceu, vou tentar explicar.

O objeto Class contém referências aos objetos Method, Constructor, Field e Annotation, não muito diferente de como você criaria alguma estrutura de dados comum. A classe Class tem alguns métodos que permitem você pesquisar ou iterar estas estruturas de dados. Até aqui, nada além de java normal manipulando estruturas de dados simples.

As classes Class, Method, Constructor e Field também têm algumas estruturas de dados referentes a Annotations, que são instanciadas pela JVM quando a classe é carregada. O reflection para ler estas Annotations pode ser facilmente implementado baseado apenas em java simples (isso fica a critério dos implementadores da JVM).

Estas estruturas de dados são montadas pela JVM quando ela cria o objeto Class (ou dependendo da JVM de forma lazy), inclusive a instanciação das Annotations existentes.

O reflection da classe Field se baseia em uma implementação native. Essa implementação está dentro da JVM, que vai no endereço do atributo e lê ou escreve algum valor naquele endereço.

O reflection da classe Method também se baseia em native. Dentro da JVM, já no lado native, há um ponteiro para função que é invocado e então o método executa. O ponteiro "this" aparece como um parâmetro para este método (tal como empilhado pelo invokevirtual e pelo invokeinterface).

O reflection da classe Constructor funciona de forma semelhante ao de Method.

O Class.newInstance() delega para a classe Constructor.

Resumindo, as estruturas de dados poderiam ser montadas assim:

public class Class {
    private final Method[] methods;
    private final Field[] fields;
    private final Constructor[] constructors;
    private final Class superClass;
    private final Class[] implementedInterfaces;
    private final Class[] innerClasses;
    private final Annotation[] annotations;

// Uma porrada de métodos.
}

public class Constructor {
    private final Class[] parameterTypes;
    private final Annotation[] annotations;
    private final Annotation[][] parametersAnnotations;
    private final Class baseType;

// Uma porrada de métodos, inclusive newInstance().
}

public class Method {
    private final Class[] parameterTypes;
    private final Annotation[] annotations;
    private final Annotation[][] parametersAnnotations;
    private final Class returnType;

// Uma porrada de métodos, inclusive invoke().
}

public class Field {
    private final Annotation[] annotations;
    private final Class fieldType;

// Uma porrada de métodos, inclusive set() e get().
}

Moderador Membro desde: 29/07/2004 16:10:13 Mensagens: 17543 Offline

Obrigado, Victor; a explicação foi melhor que o que eu conseguiria dizer (normalmente eu ponho uma explicação complicada demais e muito bitolada para a implementação Sun da JVM).

This message was edited 1 time. Last update was at 16/01/2009 12:14:17

thingol wrote:Obrigado, Victor; a explicação foi melhor que o que eu conseguiria dizer (normalmente eu ponho uma explicação complicada demais e muito bitolada para a implementação Sun da JVM).

Gostei.

Mas vou procurar para ver como a JVM faz mais internamente.

Mark_Ameba wrote:Gostei.

Mas vou procurar para ver como a JVM faz mais internamente.

Se encontrar, por favor escreva um livro sobre isso, porque o que menos tem é literatura específica do funcionamento da JVM.

Agora eu desesti de procurar. :p

Moderador Membro desde: 29/07/2004 16:10:13 Mensagens: 17543 Offline

O que você pode procurar é o wiki do pessoal do OpenJDK; lá há alguma coisa.

http://wikis.sun.com/display/HotSpotInternals/PerformanceTechniques

Eu procurei no OpenJDK sobre Reflection e não tinha achado... mas valeu vou olhar o link.

Thread.start() Membro desde: 08/01/2009 08:23:56 Mensagens: 40 Offline

Nossa esse post foi demais, o que gerou de debate e polemica...

Isso prova como algo simples pode se tornar complexo, devido a amplitude de recursos de uma boa linguagem de prograçao.

Abraços a todos!

GUJ Master Membro desde: 23/01/2008 11:14:35 Mensagens: 1905 Offline

joaosiqueira wrote:Nossa esse post foi demais, o que gerou de debate e polemica...

Isso prova como algo simples pode se tornar complexo, devido a amplitude de recursos de uma boa linguagem de prograçao.

Abraços a todos!

Para quem quiser melhor informações sobre Reflection

Tutorial Java Reflection

Thread.start() Membro desde: 08/01/2009 08:23:56 Mensagens: 40 Offline

Valeu Marcio Duran,

Esse artigo de Reflections me ajudou bastante.

Obrigado!

Uma parte ali que eu nao conhecia era sobre as Proxys com Reflection.. eu sabia sobre elas mas não sabia que fazia parte.

Thread.start() Membro desde: 08/01/2009 08:23:56 Mensagens: 40 Offline

Marcio Duran,

So trazendo o mundo hacking no GUJ.. eheheh

muito bom!!!

Veja bem, é uma questão de lógica. Uma classe é uma estrutura em que existem metodos e variáveis.

Mas quando um metodo é definido não importa se ele é estático ou dinamico a estrutura dele será a mesma, ou seja, o trecho de código que o método estático ou dinâmico (no compilador) sao quase iguais (semanticamente falando) o que mudam são as posições de memória pois metodos estáticos nao podem referenciar variaveis de uma instância.

O mesmo não é verdade para uma váriavel estática, que está sim economiza espaço de memória.

Veja o código:

Em:

No entanto em:

Notícias, artigos e o maior fórum brasileiro sobre Java