Comment puis-je utiliser des pointeurs en Java?

Je sais que Java n'a pas de pointeurs, mais j'ai entendu dire que les programmes Java peuvent être créés avec des pointeurs et que cela peut être fait par quelques-uns qui sont des experts en Java. Est-ce vrai?

Tous les objets en Java sont des références et vous pouvez les utiliser comme des pointeurs.

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;

Déréférencer un null:

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

Problème d'aliasing:

third = new Tiger();
first = third;

Perdre des cellules:

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

Vous pouvez sécuriser cela en vous assurant d'abord qu'il n'y a plus besoin de l'ancienne valeur de second ou en attribuant à un autre pointeur la valeur de second.

first = second;
second = third; //OK

Notez que donner à second une valeur d'une autre manière (NULL, new ...) est tout autant une erreur potentielle et peut entraîner la perte de l'objet vers lequel il pointe.

Le système Java lèvera une exception ( OutOfMemoryError) lorsque vous appelez new et que l'allocateur ne peut pas allouer la cellule demandée. Ceci est très rare et résulte généralement d'une récursivité fugitive.

Notez que, du point de vue du langage, abandonner des objets au ramasse-miettes ne sont pas du tout des erreurs. C'est juste quelque chose dont le programmeur doit être conscient. La même variable peut pointer vers différents objets à des moments différents et les anciennes valeurs seront récupérées lorsqu'aucun pointeur ne les référencera. Mais si la logique du programme nécessite de conserver au moins une référence à l'objet, cela provoquera une erreur.

Les novices font souvent l'erreur suivante.

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

Ce que vous vouliez probablement dire était:

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

Casting incorrect:

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.

Pointeurs en 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
}

Pointeurs en 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
    }
} 

UPDATE: comme suggéré dans les commentaires, il faut noter que C a une arithmétique de pointeur. Cependant, nous n'avons pas cela en Java.

Java a des pointeurs. Chaque fois que vous créez un objet en Java, vous créez en fait un pointeur vers l'objet; ce pointeur pourrait alors être défini sur un objet différent ou sur null, et l'objet d'origine existera toujours (garbage collection en attente).

Ce que vous ne pouvez pas faire en Java, c'est l'arithmétique des pointeurs. Vous ne pouvez pas déréférencer une adresse mémoire spécifique ou incrémenter un pointeur.

Si vous voulez vraiment obtenir de bas niveau, la seule façon de le faire est d'utiliser l' interface native Java ; et même alors, la partie de bas niveau doit être effectuée en C ou C ++.

Comme Java n'a pas de types de données de pointeur, il est impossible d'utiliser des pointeurs en Java. Même les quelques experts ne pourront pas utiliser de pointeurs en java.

Voir aussi le dernier point dans: L'environnement du langage Java

Il existe des pointeurs en Java, mais vous ne pouvez pas les manipuler comme vous le pouvez en C ++ ou C. Lorsque vous passez un objet, vous passez un pointeur vers cet objet, mais pas dans le même sens qu'en C ++. Cet objet ne peut pas être déréférencé. Si vous définissez ses valeurs à l'aide de ses accesseurs natifs, cela changera car Java connaît son emplacement mémoire via le pointeur. Mais le pointeur est immuable. Lorsque vous essayez de définir le pointeur vers un nouvel emplacement, vous vous retrouvez à la place avec un nouvel objet local portant le même nom que l'autre. L'objet d'origine est inchangé. Voici un bref programme pour démontrer la différence.

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;
    }
}

Cela peut être exécuté sur Ideone.com.

Java n'a pas de pointeurs comme C, mais il vous permet de créer de nouveaux objets sur le tas qui sont "référencés" par des variables. Le manque de pointeurs empêche les programmes Java de référencer illégalement des emplacements mémoire et permet également d'effectuer automatiquement le nettoyage de la mémoire par la machine virtuelle Java.

Vous pouvez utiliser des adresses et des pointeurs à l'aide de la classe Unsafe. Cependant, comme son nom l'indique, ces méthodes ne sont pas sûres et sont généralement une mauvaise idée. Une utilisation incorrecte peut entraîner la mort de votre JVM de manière aléatoire (en fait, le même problème est lié à l'utilisation incorrecte des pointeurs en C / C ++)

Bien que vous soyez habitué aux pointeurs et que vous pensez en avoir besoin (parce que vous ne savez pas coder autrement), vous constaterez que vous ne le faites pas et que vous serez mieux lotis.

Techniquement, tous les objets Java sont des pointeurs. Cependant, tous les types primitifs sont des valeurs. Il n'y a aucun moyen de prendre le contrôle manuel de ces pointeurs. Java utilise juste en interne le passage par référence.

Non, pas vraiment.

Java n'a pas de pointeurs. Si vous le vouliez vraiment, vous pourriez essayer de les imiter en construisant autour de quelque chose comme la réflexion, mais cela aurait toute la complexité des pointeurs sans aucun des avantages .

Java n'a pas de pointeurs car il n'en a pas besoin. Quel genre de réponses espériez-vous à cette question, c'est-à-dire au fond espérez-vous pouvoir les utiliser pour quelque chose ou était-ce juste de la curiosité?

Tous les objets en java sont passés aux fonctions par copie de référence à l'exception des primitives.

En fait, cela signifie que vous envoyez une copie du pointeur vers l'objet d'origine plutôt qu'une copie de l'objet lui-même.

Veuillez laisser un commentaire si vous voulez un exemple pour comprendre cela.

Les types de référence Java ne sont pas les mêmes que les pointeurs C car vous ne pouvez pas avoir de pointeur vers un pointeur en Java.

Comme d'autres l'ont dit, la réponse courte est «non».

Bien sûr, vous pouvez écrire du code JNI qui joue avec les pointeurs Java. Selon ce que vous essayez d'accomplir, cela vous mènerait peut-être quelque part et peut-être pas.

Vous pouvez toujours simuler des points en créant un tableau et en utilisant des index dans le tableau. Encore une fois, selon ce que vous essayez d'accomplir, cela pourrait être utile ou non.

extrait du livre intitulé Decompiling Android de Godfrey Nolan

La sécurité dicte que les pointeurs ne sont pas utilisés en Java afin que les pirates ne puissent pas sortir d'une application et entrer dans le système d'exploitation. Aucun pointeur signifie que quelque chose d'autre - dans ce cas, la JVM - doit s'occuper de l'allocation et de la libération de mémoire. Les fuites de mémoire devraient également devenir une chose du passé, du moins selon la théorie. Certaines applications écrites en C et C ++ sont réputées pour fuir la mémoire comme un tamis parce que les programmeurs ne font pas attention à libérer de la mémoire indésirable au moment opportun - pas que quiconque lisant ceci serait coupable d'un tel péché. Le garbage collection devrait également rendre les programmeurs plus productifs, avec moins de temps consacré au débogage des problèmes de mémoire.

vous pouvez également avoir des pointeurs pour les littéraux. Vous devez les mettre en œuvre vous-même. C'est assez basique pour les experts;). Utilisez un tableau de int / object / long / byte et voilà, vous avez les bases pour implémenter des pointeurs. Maintenant, toute valeur int peut être un pointeur vers ce tableau int []. Vous pouvez incrémenter le pointeur, vous pouvez décrémenter le pointeur, vous pouvez multiplier le pointeur. Vous avez en effet l'arithmétique des pointeurs! C'est la seule façon d'implémenter 1000 classes d'attributs int et d'avoir une méthode générique qui s'applique à tous les attributs. Vous pouvez également utiliser un tableau d'octets [] au lieu d'un int []

Cependant, je souhaite que Java vous laisse passer des valeurs littérales par référence. Quelque chose dans le sens

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

Tous les objets java sont des pointeurs car une variable contenant une adresse est appelée pointeur et un objet contenant une adresse.so est une variable de pointeur.