MethodHandle Classe
Definição
Importante
Algumas informações se referem a produtos de pré-lançamento que podem ser substancialmente modificados antes do lançamento. A Microsoft não oferece garantias, expressas ou implícitas, das informações aqui fornecidas.
Um identificador de método é uma referência digitada e executável diretamente a um método subjacente, construtor, campo ou operação de baixo nível semelhante, com transformações opcionais de argumentos ou valores retornados.
[Android.Runtime.Register("java/lang/invoke/MethodHandle", ApiSince=26, DoNotGenerateAcw=true)]
public abstract class MethodHandle : Java.Lang.Object[<Android.Runtime.Register("java/lang/invoke/MethodHandle", ApiSince=26, DoNotGenerateAcw=true)>]
type MethodHandle = class
inherit Object- Herança
- Atributos
Comentários
Um identificador de método é uma referência digitada e executável diretamente a um método subjacente, construtor, campo ou operação de baixo nível semelhante, com transformações opcionais de argumentos ou valores retornados. Essas transformações são bastante gerais e incluem padrões como conversão de #asType, inserção #bindTo, exclusão java.lang.invoke.MethodHandles#dropArguments e substituição java.lang.invoke.MethodHandles#filterArguments.
<O método h1>manipula o conteúdo</h1> Os identificadores do método são dinamicamente e fortemente tipados de acordo com seus tipos de parâmetro e retorno. Eles não são distinguidos pelo nome ou pela classe definidora de seus métodos subjacentes. Um identificador de método deve ser invocado usando um descritor de tipo simbólico que corresponda ao próprio descritor de tipo #type do identificador de método.
Cada identificador de método relata seu descritor de tipo por meio do #type type acessador. Esse descritor de tipo é um java.lang.invoke.MethodType MethodType objeto, cuja estrutura é uma série de classes, uma das quais é o tipo de retorno do método (ou void.class se nenhuma).
O tipo de identificador de método controla os tipos de invocações que ele aceita e os tipos de transformações que se aplicam a ele.
Um identificador de método contém um par de métodos especiais de invocador chamados #invokeExact invokeExact e #invoke invoke. Ambos os métodos de invocador fornecem acesso direto ao método subjacente do identificador de método, construtor, campo ou outra operação, conforme modificado por transformações de argumentos e valores retornados. Ambos os invocadores aceitam chamadas que correspondem exatamente ao tipo do próprio identificador de método. O invocador simples e inexact também aceita um intervalo de outros tipos de chamada.
Os identificadores de método são imutáveis e não têm nenhum estado visível. É claro que eles podem ser associados a métodos ou dados subjacentes que exibem o estado. Em relação ao modelo de memória Java, qualquer identificador de método se comportará como se todos os seus campos (internos) forem variáveis finais. Isso significa que qualquer identificador de método visível para o aplicativo sempre será totalmente formado. Isso é verdadeiro mesmo se o identificador do método for publicado por meio de uma variável compartilhada em uma corrida de dados.
Os identificadores de método não podem ser subclasse pelo usuário. As implementações podem (ou não) criar subclasses internas das MethodHandle quais podem estar visíveis por meio da java.lang.Object#getClass Object.getClass operação. O programador não deve tirar conclusões sobre um identificador de método de sua classe específica, pois o método manipula a hierarquia de classe (se houver) pode mudar de tempos em tempos ou entre implementações de diferentes fornecedores.
<h1>Método handle compilation</h1> A Java method call expression naming invokeExact or invoke can invoke a method handle from Java source code. Do ponto de vista do código-fonte, esses métodos podem levar quaisquer argumentos e seu resultado pode ser convertido em qualquer tipo de retorno. Formalmente, isso é feito dando aos métodos Object invocadores tipos de retorno e argumentos de aridade Object variável, mas eles têm uma qualidade adicional chamada <em>polimorfismo< de assinatura/em> que conecta essa liberdade de invocação diretamente à pilha de execução JVM.
Como é de costume com métodos virtuais, chamadas de nível de origem para invokeExact e invoke compilar em uma instrução invokevirtual . Mais incomum, o compilador deve gravar os tipos de argumento reais e pode não executar conversões de invocação de método nos argumentos. Em vez disso, ele deve empurrá-los na pilha de acordo com seus próprios tipos não convertidos. O objeto de identificador de método em si é enviado por push na pilha antes dos argumentos. Em seguida, o compilador chama o identificador do método com um descritor de tipo simbólico que descreve os tipos de argumento e de retorno.
Para emitir um descritor de tipo simbólico completo, o compilador também deve determinar o tipo de retorno. Isso se baseia em uma conversão na expressão de invocação do método, se houver uma ou se Object a invocação for uma expressão ou se void a invocação for uma instrução. A conversão pode ser de um tipo primitivo (mas não void).
Como uma caixa de canto, um argumento não moldado null recebe um descritor de tipo simbólico de java.lang.Void. A ambiguidade com o tipo Void é inofensiva, pois não há referências de tipo Void , exceto a referência nula.
<h1>Manipulação de método invocação</h1> A primeira vez que uma invokevirtual instrução é executada é vinculada, resolvendo simbolicamente os nomes na instrução e verificando se a chamada de método é estaticamente legal. Isso é verdadeiro para chamadas para invokeExact e invoke. Nesse caso, o descritor de tipo simbólico emitido pelo compilador é verificado quanto à sintaxe correta e os nomes que ele contém são resolvidos. Portanto, uma instrução invokevirtual que invoca um identificador de método sempre será vinculada, desde que o descritor de tipo simbólico seja sintaticamente bem formado e os tipos existam.
Quando ele invokevirtual é executado após a vinculação, o tipo do identificador do método de recebimento é verificado pela primeira vez pela JVM para garantir que ele corresponda ao descritor de tipo simbólico. Se a correspondência de tipo falhar, isso significa que o método que o chamador está invocando não está presente no identificador de método individual que está sendo invocado.
No caso de invokeExact, o descritor de tipo da invocação (depois de resolver nomes de tipo simbólicos) deve corresponder exatamente ao tipo de método do identificador do método de recebimento. No caso de simples, inexact invoke, o descritor de tipo resolvido deve ser um argumento válido para o método do #asType asType receptor. Portanto, simples invoke é mais permissivo do que invokeExact.
Após a correspondência de tipo, uma chamada para invokeExact invocar diretamente e imediatamente o método subjacente do identificador de método (ou outro comportamento, como o caso pode ser).
Uma chamada para simples invoke funciona da mesma forma que uma chamada, invokeExactse o descritor de tipo simbólico especificado pelo chamador corresponder exatamente ao tipo do próprio identificador de método. Se houver uma incompatibilidade de tipo, invoke tentará ajustar o tipo do identificador do método de recebimento, como se por uma chamada para #asType asType, para obter um identificador M2de método exatamente invocável. Isso permite uma negociação mais poderosa do tipo de método entre o chamador e o chamador.
(<em>Observação:</em> O identificador M2 de método ajustado não é diretamente observável e, portanto, as implementações não são necessárias para materializá-lo.)
<h1>Verificação de invocação</h1> Em programas típicos, a correspondência de tipos de identificador de método geralmente terá êxito. Mas, se uma correspondência falhar, a JVM lançará um WrongMethodTypeException, diretamente (no caso de invokeExact) ou indiretamente como se fosse por uma chamada asType com falha (no caso de invoke).
Assim, uma incompatibilidade de tipo de método que pode aparecer como um erro de vinculação em um programa tipado estaticamente pode aparecer como uma dinâmica WrongMethodTypeException em um programa que usa identificadores de método.
Como os tipos de método contêm objetos "dinâmicos Class ", a correspondência de tipos de método leva em conta nomes de tipos e carregadores de classe. Portanto, mesmo que um identificador M de método seja criado em um carregador L1 de classe e usado em outro L2, as chamadas de identificador de método são de tipo seguro, porque o descritor de tipo simbólico do chamador, conforme resolvido, L2é correspondido com o descritor de tipo simbólico do método chamado original, conforme resolvido em L1. A resolução L1 ocorre quando M é criada e seu tipo é atribuído, enquanto a resolução L2 ocorre quando a invokevirtual instrução é vinculada.
Além da verificação de descritores de tipo, a capacidade de um identificador de método para chamar seu método subjacente é irrestrita. Se um identificador de método for formado em um método não público por uma classe que tenha acesso a esse método, o identificador resultante poderá ser usado em qualquer lugar por qualquer chamador que receba uma referência a ele.
Ao contrário da API de Reflexão Principal, em que o acesso é verificado sempre que um método reflexivo é invocado, a verificação de acesso do identificador de método é executada quando o identificador do método é criado. No caso de (veja abaixo), a verificação de ldc acesso é executada como parte da vinculação da entrada de pool constante subjacente ao identificador de método constante.
Assim, os identificadores para métodos não públicos ou métodos em classes não públicas geralmente devem ser mantidos em segredo. Eles não devem ser passados para código não confiável, a menos que seu uso do código não confiável seja inofensivo.
<h1>O método manipula a criação</h1> Java código pode criar um identificador de método que acessa diretamente qualquer método, construtor ou campo acessível a esse código. Isso é feito por meio de uma API reflexiva baseada em funcionalidade chamada java.lang.invoke.MethodHandles.Lookup MethodHandles.Lookup Por exemplo, um identificador de método estático pode ser obtido de java.lang.invoke.MethodHandles.Lookup#findStatic Lookup.findStatic. Também há métodos de conversão de objetos da API de Reflexão Central, como java.lang.invoke.MethodHandles.Lookup#unreflect Lookup.unreflect.
Assim como classes e cadeias de caracteres, os identificadores de método que correspondem a campos, métodos e construtores acessíveis também podem ser representados diretamente no pool de constantes de um arquivo de classe como constantes a serem carregadas por ldc códigos de byte. Um novo tipo de entrada de pool constante, CONSTANT_MethodHandlerefere-se diretamente a uma entrada de pool associada CONSTANT_MethodrefCONSTANT_InterfaceMethodrefou CONSTANT_Fieldref constante. (Para obter detalhes completos sobre constantes de identificador de método, consulte as seções 4.4.8 e 5.4.3.5 da especificação da máquina virtual do Java.)
Os identificadores de método produzidos por pesquisas ou cargas constantes de métodos ou construtores com o bit modificador de aridade variável (0x0080) têm uma aridade variável correspondente, como se fossem definidos com a ajuda de #asVarargsCollector asVarargsCollector.
Uma referência de método pode se referir a um método estático ou não estático. No caso não estático, o tipo de identificador de método inclui um argumento de receptor explícito, pré-acrescentado antes de qualquer outro argumento. No tipo do identificador do método, o argumento do receptor inicial é digitado de acordo com a classe sob a qual o método foi inicialmente solicitado. (Por exemplo, se um identificador de método não estático for obtido por meio ldcde , o tipo do receptor será a classe nomeada na entrada de pool constante.)
As constantes de identificador de método estão sujeitas às mesmas verificações de acesso de tempo de link de suas instruções de código de byte correspondentes e a ldc instrução gerará erros de vinculação correspondentes se os comportamentos de código de byte gerarem esses erros.
Como um corolário disso, o acesso a membros protegidos é restrito apenas aos receptores da classe de acesso ou a uma de suas subclasses, e a classe de acesso deve, por sua vez, ser uma subclasse (ou irmão do pacote) da classe de definição do membro protegido. Se uma referência de método se referir a um método não estático protegido ou campo de uma classe fora do pacote atual, o argumento receptor será restringido ao tipo da classe de acesso.
Quando um identificador de método para um método virtual é invocado, o método é sempre pesquisado no receptor (ou seja, o primeiro argumento).
Um identificador de método não virtual para uma implementação de método virtual específico também pode ser criado. Elas não executam pesquisa virtual com base no tipo de receptor. Esse identificador de método simula o efeito de uma instrução invokespecial para o mesmo método.
<h1>Exemplos< de uso/h1> Aqui estão alguns exemplos de uso: <blockquote>
{@code
Object x, y; String s; int i;
MethodType mt; MethodHandle mh;
MethodHandles.Lookup lookup = MethodHandles.lookup();
// mt is (char,char)String
mt = MethodType.methodType(String.class, char.class, char.class);
mh = lookup.findVirtual(String.class, "replace", mt);
s = (String) mh.invokeExact("daddy",'d','n');
// invokeExact(Ljava/lang/String;CC)Ljava/lang/String;
assertEquals(s, "nanny");
// weakly typed invocation (using MHs.invoke)
s = (String) mh.invokeWithArguments("sappy", 'p', 'v');
assertEquals(s, "savvy");
// mt is (Object[])List
mt = MethodType.methodType(java.util.List.class, Object[].class);
mh = lookup.findStatic(java.util.Arrays.class, "asList", mt);
assert(mh.isVarargsCollector());
x = mh.invoke("one", "two");
// invoke(Ljava/lang/String;Ljava/lang/String;)Ljava/lang/Object;
assertEquals(x, java.util.Arrays.asList("one","two"));
// mt is (Object,Object,Object)Object
mt = MethodType.genericMethodType(3);
mh = mh.asType(mt);
x = mh.invokeExact((Object)1, (Object)2, (Object)3);
// invokeExact(Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;
assertEquals(x, java.util.Arrays.asList(1,2,3));
// mt is ()int
mt = MethodType.methodType(int.class);
mh = lookup.findVirtual(java.util.List.class, "size", mt);
i = (int) mh.invokeExact(java.util.Arrays.asList(1,2,3));
// invokeExact(Ljava/util/List;)I
assert(i == 3);
mt = MethodType.methodType(void.class, String.class);
mh = lookup.findVirtual(java.io.PrintStream.class, "println", mt);
mh.invokeExact(System.out, "Hello, world.");
// invokeExact(Ljava/io/PrintStream;Ljava/lang/String;)V
}
</blockquote> Cada uma das chamadas acima para invokeExact ou sem formatação invoke gera uma única instrução invokevirtual com o descritor de tipo simbólico indicado no comentário a seguir. Nesses exemplos, o método assertEquals auxiliar é considerado um método que chama java.util.Objects#equals(Object,Object) Objects.equals seus argumentos e afirma que o resultado é verdadeiro.
<h1>Exceções</h1> Os métodos invokeExact e invoke são declarados para gerar java.lang.Throwable Throwable, ou seja, não há nenhuma restrição estática sobre o que um identificador de método pode gerar. Como a JVM não distingue entre exceções marcadas e desmarcadas (exceto por sua classe, é claro), não há nenhum efeito específico na forma de bytecode de atribuir exceções verificadas ao tratamento de invocações do método. Mas, em Java código-fonte, os métodos que executam chamadas de identificador de método devem gerar Throwableexplicitamente, ou então devem capturar todos os throwables localmente, lançando novamente apenas aqueles que são legais no contexto e encapsulando aqueles que são ilegais.
<h1>"sigpoly">Polimorfismo< de assinatura/h1> O comportamento incomum de compilação e vinculação de invokeExact e sem formatação invoke é referenciado pelo termo <em>polimorfismo</em> assinatura. Conforme definido no Java Language Specification, um método polimórfico de assinatura é aquele que pode operar com qualquer uma de uma ampla gama de assinaturas de chamada e tipos de retorno.
No código-fonte, uma chamada para um método polimórfico de assinatura será compilada, independentemente do descritor de tipo simbólico solicitado. Como de costume, o compilador Java emite uma invokevirtual instrução com o descritor de tipo simbólico fornecido em relação ao método nomeado. A parte incomum é que o descritor de tipo simbólico é derivado do argumento real e dos tipos de retorno, não da declaração do método.
Quando o JVM processa o código de byte que contém chamadas polimórficas de assinatura, ele vinculará com êxito qualquer chamada desse tipo, independentemente de seu descritor de tipo simbólico. (Para manter a segurança do tipo, a JVM protegerá essas chamadas com verificações de tipo dinâmico adequadas, conforme descrito em outro lugar.)
Os geradores de bytecode, incluindo o back-end do compilador, são necessários para emitir descritores de tipo simbólico nãotransformados para esses métodos. As ferramentas que determinam a vinculação simbólica são necessárias para aceitar esses descritores nãotransformados, sem relatar erros de vinculação.
<h1>Interoperação entre identificadores de método e a API< de Reflexão Principal/h1 Usando métodos de> fábrica na java.lang.invoke.MethodHandles.Lookup Lookup API, qualquer membro de classe representado por um objeto da API de Reflexão Principal pode ser convertido em um identificador de método comportamentalmente equivalente. Por exemplo, um reflexivo java.lang.reflect.Method Method pode ser convertido em um identificador de método usando java.lang.invoke.MethodHandles.Lookup#unreflect Lookup.unreflect. Os identificadores de método resultantes geralmente fornecem acesso mais direto e eficiente aos membros da classe subjacentes.
Como um caso especial, quando a API de Reflexão Principal é usada para exibir os métodos invokeExact polimórficos de assinatura ou simples invoke nessa classe, eles aparecem como métodos não polimórficos comuns. Sua aparência reflexiva, como visto por java.lang.Class#getDeclaredMethod Class.getDeclaredMethod, não é afetada pelo status especial nesta API. Por exemplo, java.lang.reflect.Method#getModifiers Method.getModifiers relatará exatamente esses bits modificador necessários para qualquer método declarado da mesma forma, incluindo neste caso native e varargs bits.
Assim como acontece com qualquer método refletido, esses métodos (quando refletidos) podem ser invocados por meio de java.lang.reflect.Method#invoke java.lang.reflect.Method.invoke. No entanto, essas chamadas reflexivas não resultam em invocações de identificador de método. Tal chamada, se aprovada o argumento necessário (um único, do tipo Object[]), ignorará o argumento e lançará um UnsupportedOperationException.
Como invokevirtual as instruções podem invocar nativamente os identificadores de método em qualquer descritor de tipo simbólico, essa exibição reflexiva entra em conflito com a apresentação normal desses métodos por meio de códigos de byte. Assim, esses dois métodos nativos, quando exibidos reflexivamente por Class.getDeclaredMethod, podem ser considerados apenas como espaços reservados.
Para obter um método de invocador para um descritor de tipo específico, use java.lang.invoke.MethodHandles#exactInvoker MethodHandles.exactInvokerou java.lang.invoke.MethodHandles#invoker MethodHandles.invoker. A java.lang.invoke.MethodHandles.Lookup#findVirtual Lookup.findVirtual API também pode retornar um identificador de método para chamar invokeExact ou não invoke, para qualquer descritor de tipo especificado.
<h1>Interoperação entre identificadores de método e Java genéricos</h1> Um identificador de método pode ser obtido em um método, construtor ou campo que é declarado com Java tipos genéricos. Assim como acontece com a API de Reflexão Principal, o tipo do identificador de método será construído a partir da eliminação do tipo de nível de origem. Quando um identificador de método é invocado, os tipos de seus argumentos ou o tipo de conversão de valor retornado podem ser tipos genéricos ou instâncias de tipo. Se isso ocorrer, o compilador substituirá esses tipos por suas eliminações quando construir o descritor de tipo simbólico para a invokevirtual instrução.
Os identificadores de método não representam seus tipos de função em termos de tipos de Java parametrizados (genéricos), pois há três incompatibilidades entre tipos semelhantes a funções e tipos de Java parametrizados. <Os tipos de método ul><li>variam em todas as aridades possíveis, desde nenhum argumento até o número máximo de argumentos permitidos. Genéricos não são variadic e, portanto, não podem representar isso.<Os tipos de método /li><li>podem especificar argumentos de tipos primitivos, que Java tipos genéricos não podem variar.</li li><>Funções de ordem superior sobre identificadores de método (combinadores) geralmente são genéricas em uma ampla gama de tipos de função, incluindo as de várias aridades. É impossível representar essa genericidade com um parâmetro de tipo Java.</li></ul>
<h1>"maxarity">Arity limits</h1> A JVM impõe a todos os métodos e construtores de qualquer tipo um limite absoluto de 255 argumentos empilhados. Esse limite pode parecer mais restritivo em determinados casos: <ul><li>A long ou double contagens de argumentos (para fins de limites de aridade) como dois slots de argumento.
<li>Um método não estático consome um argumento extra para o objeto no qual o método é chamado.
<li>Um construtor consome um argumento extra para o objeto que está sendo construído.
<li>Desde um identificador de método' s invoke method (or other signature-polymorphic method) is non-virtual, it consums an extra argument for the method handle itself, in addition to any non-virtual receiver object.
</ul> Esses limites implicam que determinados identificadores de método não podem ser criados, apenas devido ao limite de JVM em argumentos empilhados. Por exemplo, se um método JVM estático aceitar exatamente 255 argumentos, um identificador de método não poderá ser criado para ele. Tentativas de criar identificadores de método com tipos de método impossíveis levam a um IllegalArgumentException. Em particular, um identificador de método' s type must not have an arity of the exact maximum 255.
Documentação Java para java.lang.invoke.MethodHandle.
Partes desta página são modificações baseadas no trabalho criado e compartilhado pelo Android Open Source Project e usadas de acordo com os termos descritos na Licença de Atribuição Creative Commons 2.5.
Construtores
| Nome | Description |
|---|---|
| MethodHandle(IntPtr, JniHandleOwnership) |
Um identificador de método é uma referência digitada e executável diretamente a um método subjacente, construtor, campo ou operação de baixo nível semelhante, com transformações opcionais de argumentos ou valores retornados. |
Propriedades
| Nome | Description |
|---|---|
| Class |
Retorna a classe de tempo de execução deste |
| Handle |
O identificador para a instância subjacente do Android. (Herdado de Object) |
| IsVarargsCollector |
Determina se esse identificador de método dá suporte #asVarargsCollector chamadas de aridade variável. |
| JniIdentityHashCode |
Obtém o código de hash de identidade atribuído a esse par Java pelo runtime de interoperabilidade. (Herdado de Object) |
| JniManagedPeerState |
Um identificador de método é uma referência digitada e executável diretamente a um método subjacente, construtor, campo ou operação de baixo nível semelhante, com transformações opcionais de argumentos ou valores retornados. (Herdado de JavaObject) |
| JniPeerMembers |
Um identificador de método é uma referência digitada e executável diretamente a um método subjacente, construtor, campo ou operação de baixo nível semelhante, com transformações opcionais de argumentos ou valores retornados. |
| PeerReference |
Obtém a referência de objeto JNI para este par Java. (Herdado de Object) |
| ThresholdClass |
Um identificador de método é uma referência digitada e executável diretamente a um método subjacente, construtor, campo ou operação de baixo nível semelhante, com transformações opcionais de argumentos ou valores retornados. |
| ThresholdType |
Um identificador de método é uma referência digitada e executável diretamente a um método subjacente, construtor, campo ou operação de baixo nível semelhante, com transformações opcionais de argumentos ou valores retornados. |
Métodos
| Nome | Description |
|---|---|
| AsCollector(Class, Int32) |
Faz um <>identificador de método em array-collect</em>, que aceita um determinado número de argumentos posicionais à direita e os coleta em um argumento de matriz. |
| AsCollector(Int32, Class, Int32) |
Faz um <>identificador de método em array-collect</em>, que aceita um determinado número de argumentos posicionais começando em uma determinada posição e os coleta em um argumento de matriz. |
| AsFixedArity() |
Torna um <>identificador de método arity</em> fixo que, de outra forma, é equivalente ao identificador do método atual. |
| AsSpreader(Class, Int32) |
Faz um <>identificador de método em array-spreading</em>, que aceita um argumento de matriz à direita e espalha seus elementos como argumentos posicionais. |
| AsSpreader(Int32, Class, Int32) |
Faz um <>identificador de método em array-spreading</em>, que aceita um argumento de matriz em uma determinada posição e espalha seus elementos como argumentos posicionais no lugar da matriz. |
| AsType(MethodType) |
Produz um identificador de método de adaptador que adapta o tipo do identificador do método atual a um novo tipo. |
| AsVarargsCollector(Class) |
Torna um <>adaptador em variable arity</em> que é capaz de aceitar qualquer número de argumentos posicionais à direita e recolhê-los em um argumento de matriz. |
| BindTo(Object) |
Associa um valor |
| Clone() |
Cria e retorna uma cópia desse objeto. (Herdado de Object) |
| Construct(JniObjectReference, JniObjectReferenceOptions) |
Um identificador de método é uma referência digitada e executável diretamente a um método subjacente, construtor, campo ou operação de baixo nível semelhante, com transformações opcionais de argumentos ou valores retornados. (Herdado de JavaObject) |
| Dispose() |
Libera os recursos mantidos por esse par Java. (Herdado de Object) |
| Dispose(Boolean) |
Libera os recursos mantidos por esse par Java. (Herdado de Object) |
| DisposeUnlessReferenced() |
Um identificador de método é uma referência digitada e executável diretamente a um método subjacente, construtor, campo ou operação de baixo nível semelhante, com transformações opcionais de argumentos ou valores retornados. (Herdado de JavaObject) |
| Equals(Object) |
Um identificador de método é uma referência digitada e executável diretamente a um método subjacente, construtor, campo ou operação de baixo nível semelhante, com transformações opcionais de argumentos ou valores retornados. (Herdado de JavaObject) |
| Equals(Object) |
Indica se algum outro objeto é "igual a" este. (Herdado de Object) |
| GetHashCode() |
Retorna um valor de código hash para o objeto. (Herdado de Object) |
| Invoke(Object[]) |
Invoca o identificador de método, permitindo qualquer descritor de tipo de chamador e, opcionalmente, executando conversões em argumentos e valores retornados. |
| InvokeExact(Object[]) |
Invoca o identificador de método, permitindo qualquer descritor de tipo de chamador, mas exigindo uma correspondência de tipo exata. |
| InvokeWithArguments(IList<Object>) |
Executa uma invocação de aridade variável, passando os argumentos na matriz determinada para o identificador do método, como se fosse por meio de um inexact |
| InvokeWithArguments(Object[]) |
Executa uma invocação de aridade variável, passando os argumentos na lista fornecida para o identificador do método, como se por meio de um inexact |
| JavaFinalize() |
Chamado pelo coletor de lixo em um objeto quando a coleta de lixo determina que não há mais referências ao objeto. (Herdado de Object) |
| Notify() |
Ativa um único thread que está aguardando no monitor desse objeto. (Herdado de Object) |
| NotifyAll() |
Ativa todos os threads que estão aguardando no monitor deste objeto. (Herdado de Object) |
| SetHandle(IntPtr, JniHandleOwnership) |
Define a propriedade Handle (Herdado de Object) |
| SetPeerReference(JniObjectReference, JniObjectReferenceOptions) |
Um identificador de método é uma referência digitada e executável diretamente a um método subjacente, construtor, campo ou operação de baixo nível semelhante, com transformações opcionais de argumentos ou valores retornados. (Herdado de JavaObject) |
| ToArray<T>() |
Cria uma matriz gerenciada com base nesse wrapper de matriz Java. (Herdado de Object) |
| ToString() |
Retorna uma representação de cadeia de caracteres do objeto. (Herdado de Object) |
| Type() |
Relata o tipo desse identificador de método. |
| UnregisterFromRuntime() |
Cancela o registro desse par Java do runtime de interoperabilidade. (Herdado de Object) |
| Wait() |
Faz com que o thread atual aguarde até que seja despertado, normalmente sendo <notificado></em> ou <em>interrompido</em>. (Herdado de Object) |
| Wait(Int64, Int32) |
Faz com que o thread atual aguarde até que seja ativado, normalmente sendo <notificado></em> ou <em>interrompido</em>, ou até que uma determinada quantidade de tempo real tenha decorrido. (Herdado de Object) |
| Wait(Int64) |
Faz com que o thread atual aguarde até que seja ativado, normalmente sendo <notificado></em> ou <em>interrompido</em>, ou até que uma determinada quantidade de tempo real tenha decorrido. (Herdado de Object) |
| WithVarargs(Boolean) |
Adapta esse identificador de método para ser #asVarargsCollector aridade variável se o sinalizador booliano for verdadeiro, caso contrário, #asFixedArity aridade fixa. |
Implantações explícitas de interface
| Nome | Description |
|---|---|
| IJavaPeerable.Disposed() |
Um identificador de método é uma referência digitada e executável diretamente a um método subjacente, construtor, campo ou operação de baixo nível semelhante, com transformações opcionais de argumentos ou valores retornados. (Herdado de JavaObject) |
| IJavaPeerable.Finalized() |
Um identificador de método é uma referência digitada e executável diretamente a um método subjacente, construtor, campo ou operação de baixo nível semelhante, com transformações opcionais de argumentos ou valores retornados. (Herdado de JavaObject) |
| IJavaPeerable.JniObjectReferenceControlBlock |
Um identificador de método é uma referência digitada e executável diretamente a um método subjacente, construtor, campo ou operação de baixo nível semelhante, com transformações opcionais de argumentos ou valores retornados. (Herdado de JavaObject) |
| IJavaPeerable.SetJniIdentityHashCode(Int32) |
Um identificador de método é uma referência digitada e executável diretamente a um método subjacente, construtor, campo ou operação de baixo nível semelhante, com transformações opcionais de argumentos ou valores retornados. (Herdado de JavaObject) |
| IJavaPeerable.SetJniManagedPeerState(JniManagedPeerStates) |
Um identificador de método é uma referência digitada e executável diretamente a um método subjacente, construtor, campo ou operação de baixo nível semelhante, com transformações opcionais de argumentos ou valores retornados. (Herdado de JavaObject) |
| IJavaPeerable.SetPeerReference(JniObjectReference) |
Um identificador de método é uma referência digitada e executável diretamente a um método subjacente, construtor, campo ou operação de baixo nível semelhante, com transformações opcionais de argumentos ou valores retornados. (Herdado de JavaObject) |
Métodos de Extensão
| Nome | Description |
|---|---|
| GetJniTypeName(IJavaPeerable) |
Obtém o nome JNI do tipo da instância |
| JavaAs<TResult>(IJavaPeerable) |
Tente coagir a digitar |
| JavaCast<TResult>(IJavaObject) |
Executa uma conversão de tipo verificada pelo tempo de execução do Android. |
| JavaCast<TResult>(IJavaObject) |
Um identificador de método é uma referência digitada e executável diretamente a um método subjacente, construtor, campo ou operação de baixo nível semelhante, com transformações opcionais de argumentos ou valores retornados. |
| TryJavaCast<TResult>(IJavaPeerable, TResult) |
Tente coagir a digitar |