Como posso usar pointers em Java?

Eu sei que o Java não tem pointers, mas ouvi dizer que programas Java podem ser criados com pointers e que isso pode ser feito por poucos especialistas em java. É verdade?

Todos os objects em Java são referências e você pode usá-los como pointers.

abstract class Animal {... } class Lion extends Animal {... } class Tiger extends Animal { public Tiger() {...} public void growl(){...} } Tiger first = null; Tiger second = new Tiger(); Tiger third; 

Desreferenciando um nulo:

 first.growl(); // ERROR, first is null. third.growl(); // ERROR, third has not been initialized. 

Problema de aliasing:

 third = new Tiger(); first = third; 

Perder Células:

 second = third; // Possible ERROR. The old value of second is lost. 

Você pode tornar isso seguro, primeiro assegurando que não há mais necessidade do valor antigo de segundo ou atribuindo a outro ponteiro o valor de segundo.

 first = second; second = third; //OK 

Note que dar um segundo valor de outras maneiras (NULL, new …) é um erro potencial e pode resultar na perda do object para o qual ele aponta.

O sistema Java lançará uma exceção ( OutOfMemoryError ) quando você chamar new e o alocador não puder alocar a célula solicitada. Isso é muito raro e geralmente resulta da recursion de fuga.

Observe que, do ponto de vista da linguagem, o abandono de objects para o coletor de lixo não é um erro. É apenas algo que o programador precisa estar ciente. A mesma variável pode apontar para objects diferentes em momentos diferentes e os valores antigos serão recuperados quando nenhum ponteiro fizer referência a eles. Mas se a lógica do programa exigir a manutenção de pelo menos uma referência ao object, isso causará um erro.

Os novatos geralmente cometem o seguinte erro.

 Tiger tony = new Tiger(); tony = third; // Error, the new object allocated above is reclaimed. 

O que você provavelmente quis dizer foi:

 Tiger tony = null; tony = third; // OK. 

Fundição imprópria:

 Lion leo = new Lion(); Tiger tony = (Tiger)leo; // Always illegal and caught by compiler. Animal whatever = new Lion(); // Legal. Tiger tony = (Tiger)whatever; // Illegal, just as in previous example. Lion leo = (Lion)whatever; // Legal, object whatever really is a Lion. 

Ponteiros em C:

 void main() { int* x; // Allocate the pointers x and y int* y; // (but not the pointees) x = malloc(sizeof(int)); // Allocate an int pointee, // and set x to point to it *x = 42; // Dereference x to store 42 in its pointee *y = 13; // CRASH -- y does not have a pointee yet y = x; // Pointer assignment sets y to point to x's pointee *y = 13; // Dereference y to store 13 in its (shared) pointee } 

Ponteiros em Java:

 class IntObj { public int value; } public class Binky() { public static void main(String[] args) { IntObj x; // Allocate the pointers x and y IntObj y; // (but not the IntObj pointees) x = new IntObj(); // Allocate an IntObj pointee // and set x to point to it x.value = 42; // Dereference x to store 42 in its pointee y.value = 13; // CRASH -- y does not have a pointee yet y = x; // Pointer assignment sets y to point to x's pointee y.value = 13; // Deference y to store 13 in its (shared) pointee } } 

ATUALIZAÇÃO: como sugerido nos comentários, deve-se notar que C possui aritmética de pointers. No entanto, não temos isso em Java.

Java tem pointers. Toda vez que você cria um object em Java, você está criando um ponteiro para o object; Esse ponteiro pode então ser definido como um object diferente ou como null , e o object original ainda existirá (garbage collection pendente).

O que você não pode fazer em Java é a aritmética de pointers. Você não pode desreferenciar um endereço de memory específico ou incrementar um ponteiro.

Se você realmente deseja obter um nível mais baixo, a única maneira de fazer isso é com a Java Native Interface ; e mesmo assim, a parte de baixo nível deve ser feita em C ou C ++.

Como o Java não possui tipos de dados de ponteiro, é impossível usar pointers em Java. Mesmo os poucos especialistas não poderão usar pointers em java.

Veja também o último ponto em: The Java Language Environment

Java não possui pointers como o C tem, mas permite criar novos objects no heap que são “referenciados” por variables. A falta de pointers é impedir que os programas Java façam referência a localizações de memory ilegalmente e também permite que o Garbage Collection seja automaticamente executado pela Java Virtual Machine.

Existem pointers em Java, mas você não pode manipulá-los da maneira que puder em C ++ ou C. Quando você passa um object, você está passando um ponteiro para esse object, mas não no mesmo sentido que em C ++. Esse object não pode ser desreferenciado. Se você definir seus valores usando seus accessres nativos, ele será alterado porque Java conhece sua localização de memory por meio do ponteiro. Mas o ponteiro é imutável. Quando você tenta definir o ponteiro para um novo local, você acaba com um novo object local com o mesmo nome do outro. O object original é inalterado. Aqui está um breve programa para demonstrar a diferença.

 import java.util.*; import java.lang.*; import java.io.*; class Ideone { public static void main(String[] args) throws java.lang.Exception { System.out.println("Expected # = 0 1 2 2 1"); Cat c = new Cat(); c.setClaws(0); System.out.println("Initial value is " + c.getClaws()); // prints 0 obviously clawsAreOne(c); System.out.println("Accessor changes value to " + c.getClaws()); // prints 1 because the value 'referenced' by the 'pointer' is changed using an accessor. makeNewCat(c); System.out.println("Final value is " + c.getClaws()); // prints 1 because the pointer is not changed to 'kitten'; that would be a reference pass. } public static void clawsAreOne(Cat kitty) { kitty.setClaws(1); } public static void makeNewCat(Cat kitty) { Cat kitten = new Cat(); kitten.setClaws(2); kitty = kitten; System.out.println("Value in makeNewCat scope of kitten " + kitten.getClaws()); //Prints 2. the value pointed to by 'kitten' is 2 System.out.println("Value in makeNewcat scope of kitty " + kitty.getClaws()); //Prints 2. The local copy is being used within the scope of this method. } } class Cat { private int claws; public void setClaws(int i) { claws = i; } public int getClaws() { return claws; } } 

Isso pode ser executado em Ideone.com.

Você pode usar endereços e pointers usando a class Inseguro. No entanto, como o nome sugere, esses methods são inseguros e geralmente uma má idéia. O uso incorreto pode resultar em sua JVM morrendo aleatoriamente (na verdade, o mesmo problema é usar pointers incorretamente em C / C ++)

Enquanto você pode estar acostumado com pointers e achar que precisa deles (porque você não sabe como codificar de outra maneira), você descobrirá que não precisa e ficará melhor com isso.

Todos os objects em java são passados ​​para funções por cópia de referência, exceto primitivos.

Na verdade, isso significa que você está enviando uma cópia do ponteiro para o object original em vez de uma cópia do próprio object.

Por favor, deixe um comentário se você quiser um exemplo para entender isso.

Tecnicamente, todos os objects Java são pointers. Todos os tipos primitivos são valores embora. Não há como fazer o controle manual desses indicadores. Java apenas usa internamente passagem por referência.

Não, realmente não.

Java não tem pointers. Se você realmente quisesse, poderia tentar imitá-los construindo algo como reflection, mas teria toda a complexidade de pointers sem nenhum dos benefícios .

Java não tem pointers porque não precisa deles. Que tipo de respostas você esperava desta pergunta, ou seja, no fundo você esperava poder usá-las para algo ou era apenas curiosidade?

do livro chamado Decompiling Android por Godfrey Nolan

A segurança determina que os pointers não são usados ​​em Java para que os hackers não possam sair de um aplicativo e entrar no sistema operacional. Nenhum ponteiro significa que algo mais —- neste caso, a JVM —- tem que cuidar da alocação e liberação de memory. Vazamentos de memory também devem se tornar uma coisa do passado, ou assim vai a teoria. Algumas aplicações escritas em C e C ++ são notórias por vazar memory como uma peneira porque os programadores não prestam atenção em liberar memory indesejada no momento apropriado – não que alguém que esteja lendo isso seja culpado de tal pecado. A garbage collection também deve tornar os programadores mais produtivos, com menos tempo gasto na debugging de problemas de memory.

Os tipos de referência Java não são os mesmos que os pointers C, pois você não pode ter um ponteiro para um ponteiro em Java.

Como outros disseram, a resposta curta é “Não”.

Claro, você poderia escrever código JNI que toca com pointers Java. Dependendo do que você está tentando realizar, talvez isso te levaria a algum lugar e talvez não.

Você sempre pode simular pointes criando uma matriz e trabalhando com índices na matriz. Novamente, dependendo do que você está tentando realizar, isso pode ou não ser útil.

você pode ter pointers para literais também. Você tem que implementá-los sozinho. É bastante básico para especialistas;). Use uma matriz de int / object / long / byte e voila você tem o básico para implementar pointers. Agora, qualquer valor int pode ser um ponteiro para esse array int []. Você pode incrementar o ponteiro, você pode diminuir o ponteiro, você pode multiplicar o ponteiro. Você realmente tem aritmética de pointers! Essa é a única maneira de implementar 1000 classs de atributos int e ter um método genérico que se aplique a todos os atributos. Você também pode usar uma matriz byte [] em vez de um int []

No entanto, eu gostaria que o Java permitisse que você passasse valores literais por referência. Algo ao longo das linhas

//(* telling you it is a pointer) public void myMethod(int* intValue);

Todos os objects java são pointer porque uma variável que contém o endereço é chamada pointer e object hold address.so o object é variável de ponteiro.