Ik weet dat Java geen pointers heeft, maar ik heb gehoord dat Java-programma’s kunnen worden gemaakt met pointers en dat dit kan worden gedaan door enkelen die experts zijn in Java. Is het waar?
Antwoord 1, autoriteit 100%
Alle objecten in Java zijn referenties en je kunt ze gebruiken als aanwijzers.
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;
Verwijderen van een null:
first.growl(); // ERROR, first is null.
third.growl(); // ERROR, third has not been initialized.
Aliasingprobleem:
third = new Tiger();
first = third;
Verlies van cellen:
second = third; // Possible ERROR. The old value of second is lost.
U kunt dit veilig stellen door er eerst voor te zorgen dat de oude waarde van seconde niet meer nodig is of door een andere aanwijzer de waarde van seconde toe te wijzen.
first = second;
second = third; //OK
Merk op dat het geven van een tweede waarde op andere manieren (NULL, nieuw…) net zo goed een potentiële fout is en kan leiden tot verlies van het object waarnaar het verwijst.
Het Java-systeem genereert een uitzondering (OutOfMemoryError) wanneer u nieuw aanroept en de allocator de gevraagde cel niet kan toewijzen. Dit is zeer zeldzaam en is meestal het gevolg van run-away recursie.
Merk op dat, vanuit taaloogpunt, het overlaten van objecten aan de vuilnisman helemaal geen fouten zijn. Het is gewoon iets waar de programmeur zich bewust van moet zijn. Dezelfde variabele kan op verschillende tijdstippen naar verschillende objecten verwijzen en oude waarden worden teruggewonnen als geen enkele aanwijzer ernaar verwijst. Maar als de logica van het programma vereist dat er ten minste één verwijzing naar het object moet worden bewaard, zal het een fout veroorzaken.
Beginnen maken vaak de volgende fout.
Tiger tony = new Tiger();
tony = third; // Error, the new object allocated above is reclaimed.
Wat je waarschijnlijk wilde zeggen was:
Tiger tony = null;
tony = third; // OK.
Onjuist casten:
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.
Aanwijzers in 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
}
Aanwijzingen in 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: Zoals voorgesteld in de opmerkingen moet men opmerken dat C aanwijzer rekenkundig heeft. We hebben echter niet dat in Java.
Antwoord 2, Autoriteit 18%
Java heeft geen aanwijzingen. Elke keer dat u een object in Java maakt, maakt u daadwerkelijk een aanwijzer op het object; Deze aanwijzer kan vervolgens worden ingesteld op een ander object of op null, en het originele object zal nog steeds bestaan (in afwachting van garbage-collectie).
Wat u niet kunt doen in Java is aanwijzer rekenkundig. U kunt een specifiek geheugenadres niet nerfecteren of een aanwijzer verhogen.
Als u echt op laag niveau wilt, is de enige manier om het te doen is met de Java Native Interface ; En zelfs dan moet het onderdeel op laag niveau worden gedaan in C of C++.
Antwoord 3, Autoriteit 18%
Zoals Java geen wijzer-gegevenstypen heeft, is het onmogelijk om aanwijzingen in Java te gebruiken. Zelfs de weinige deskundigen zullen niet in staat zijn om aanwijzingen in Java te gebruiken.
Zie ook het laatste punt in: de Java-taalomgeving
Antwoord 4, autoriteit 4%
Java heeft geen pointers zoals C heeft, maar het stelt je wel in staat om nieuwe objecten op de heap te maken waarnaar wordt “verwezen” door variabelen. Het ontbreken van aanwijzingen is om te voorkomen dat Java-programma’s illegaal naar geheugenlocaties verwijzen, en zorgt er ook voor dat Garbage Collection automatisch wordt uitgevoerd door de Java Virtual Machine.
Antwoord 5, autoriteit 4%
Er zijn aanwijzers in Java, maar je kunt ze niet manipuleren zoals je kunt in C++ of C. Als je een object doorgeeft, geef je een aanwijzer door naar dat object, maar niet op dezelfde manier als in C++. Dat object kan niet worden afgeleid. Als u de waarden instelt met behulp van de native accessors, zal deze veranderen omdat Java zijn geheugenlocatie kent via de aanwijzer. Maar de aanwijzer is onveranderlijk. Wanneer u probeert de aanwijzer naar een nieuwe locatie te plaatsen, krijgt u in plaats daarvan een nieuw lokaal object met dezelfde naam als het andere. Het oorspronkelijke object is ongewijzigd. Hier is een kort programma om het verschil te demonstreren.
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;
}
}
Dit kan worden uitgevoerd op Ideaone.com.
Antwoord 6, autoriteit 3%
U kunt adressen en verwijzingen gebruiken met de klasse Onveilig. Maar zoals de naam al doet vermoeden, zijn deze methoden ONVEILIG en over het algemeen een slecht idee. Onjuist gebruik kan ertoe leiden dat uw JVM willekeurig doodgaat (eigenlijk hetzelfde probleem om aanwijzers verkeerd te gebruiken in C/C++)
Hoewel je misschien gewend bent aan verwijzingen en denkt dat je ze nodig hebt (omdat je niet weet hoe je op een andere manier moet coderen), zul je merken dat je dat niet doet en dat je er beter aan zult zijn.
Antwoord 7, autoriteit 2%
Technisch gezien zijn alle Java-objecten pointers. Alle primitieve typen zijn echter waarden. Er is geen manier om deze wijzers handmatig te bedienen. Java gebruikt intern alleen pass-by-reference.
Antwoord 8
Niet echt, nee.
Java heeft geen pointers. Als je echtzou willen, zou je kunnen proberen ze na te bootsen door iets als reflectie te bouwen, maar het zou alle complexiteitvan pointers hebben zonder de voordelen.
Java heeft geen aanwijzingen omdat het ze niet nodig heeft. Naar wat voor soort antwoorden hoopte je van deze vraag, d.w.z. diep naar beneden hoefde je dat je ze voor iets zou kunnen gebruiken of was dit gewoon nieuwsgierig?
Antwoord 9
Alle objecten in Java worden doorgegeven aan functies per referentiekopie behalve primitieven.
In werking betekent dit dat u een kopie van de aanwijzer naar het oorspronkelijke object verzendt in plaats van een kopie van het object zelf.
Laat een reactie achter als u een voorbeeld wilt om dit te begrijpen.
Antwoord 10
Java-referentietypen zijn niet hetzelfde als C-aanwijzers, omdat u geen aanwijzer kunt hebben naar een aanwijzer in Java.
Antwoord 11
Zoals anderen hebben gezegd, is het korte antwoord “nee”.
Natuurlijk, u zou JNI-code kunnen schrijven die met Java-pointers speelt. Afhankelijk van wat je probeert te bereiken, misschien zou dat je ergens ergens heen krijgen en misschien zou het dat niet.
U kunt Pointes altijd simuleren door een array te maken en met indexen in de array te werken. Nogmaals, afhankelijk van wat je probeert te bereiken, kan dat wel of niet nuttig zijn.
Antwoord 12
Uit het boek genaamd Decompiling Android door Godfrey Nolan
Beveiliging dicteert dat aanwijzingen dat niet zijn
Gebruikt in Java , zodat hackers geen applicatie en in de operatie kunnen uitbreken
systeem. Geen enkele aanwijzers betekent dat iets anders —- in dit geval, de JVM —- moet
Zorg voor het geheugen van de toewijzing en de vrijheid. Memory Lekken moeten ook
Word een ding van het verleden, of zo gaat de theorie. Sommige toepassingen geschreven in
C en C++ zijn berucht voor het lekken van geheugen als een zeef omdat programmeurs
Let niet op om ongewenst geheugen op het juiste moment te bevrijden —- Not
dat iemand die dit leest, schuldig zou zijn aan zo’n zonde. Garbage Collection
Moet ook programmeurs productiever maken, met minder tijd doorgebracht
geheugenproblemen opsporen.
Antwoord 13
je kunt ook pointers voor letterlijke waarden gebruiken. Je moet ze zelf uitvoeren. Het is vrij eenvoudig voor experts ;). Gebruik een array van int/object/long/byte en voila je hebt de basis voor het implementeren van pointers. Nu kan elke int-waarde een aanwijzer zijn naar die array int[]. U kunt de aanwijzer verhogen, u kunt de aanwijzer verlagen, u kunt de aanwijzer vermenigvuldigen. Je hebt inderdaad pointer-rekenkunde!
Dat is de enige manier om 1000 int-attribuutklassen te implementeren en een generieke methode te hebben die van toepassing is op alle attributen. U kunt ook een byte[]-array gebruiken in plaats van een int[]
Ik zou echter willen dat Java je letterlijke waarden zou laten doorgeven als referentie. Iets in de trant van
//(* telling you it is a pointer)
public void myMethod(int* intValue);
Antwoord 14
Alle Java-objecten zijn pointer omdat een variabele die adres bevat pointer wordt genoemd en object hold address.so object is pointervariabele.