Object oder Primitiv

[DontKnowJava]

Hallo,

ich habe zu dem Thema bereits im WWW und hier im Forum gesucht, bin aber nicht so richtig schlau aus dem Gefundenen geworden. Die Frage mag eher von theoretischem Interesse sein, ich brauche aber Antworten auf so etwas, damit ich die Sprache besser begreifen kann - mag komisch sein, ich weiß ;-)

Wie kann ich feststellen ob eine Variable ein Objekt oder Primitiv ist?
So etwas wie

System.out.println(wert.getClass());
boolean isMyObject = (wert instanceof String);


funktioniert ja nur bei Objekten und führt ansonsten zu einem Fehler :-(
Mit einer Exception zu arbeiten halte ich für unsauber und etwas anderes fällt mir nicht ein :-(

Wie kann ich also feststellen ob es sich um ein Objekt oder einen primitiven Wert handelt?

 

[Noctarius]

[c]Class.isPrimitive()[/c]

 

[DontKnowJava]

Hallo, vielen Dank für die schnelle Antwort.

Etwas naiv habe ich es so ausprobiert.

		int wert = 1;		
		System.out.println(wert.isPrimitive());

Eclipse mag das aber nicht (soll nichts heißen, mich mag Eclipse auch nicht ;-) ):
"Cannot invoke isPrimitive() on the primitive type int"

Was habe ich vergessen oder übersehen? Muss ich die Variable erst einer Art künstlichem Objekt übergeben?

 

[jgh]

wenn dir bei eclipse keine Methoden angeboten werden, ist die Variable ein primitiver Datentyp...werden die Methoden bei eclipse angeboten (Strg+Leertaste) ist es ein Objekt.

 int i= 4;
i.//Strg+Leertaste => keine Angebote an Methoden => kein Objekt
Integer ii = new Integer(i);
ii.//Strg+Leertaste => Angebote an Methoden => Objekt

 

[DontKnowJava]

wenn dir bei eclipse keine Methoden angeboten werden, ist die Variable ein primitiver Datentyp...werden die Methoden bei eclipse angeboten (Strg+Leertaste) ist es ein Objekt.

Der Compiler meckert es natürlich genauso an, erfahrungsgemäß brauche ich den aber gar nicht anwerfen wenn Eclipse bereits etwas moniert.

Vielleicht um die Motivation meiner Frage besser verstehen zu können: Ich komme von Sprachen wie Perl oder PHP. Dort bekomme ich oft von anderen "Systemen" Daten geliefert und muss den Typ feststellen, logisch auf Gültigkeit überprüfen, etc.

Ich will im Programm zur Laufzeit feststellen/ abfragen ob eine Variable ein Objekt ist oder einen primitiven Datentyp hat (int, char, etc.).

Das mag möglicherweise in Java keine so große Rolle spielen, wäre für mich aus Verständnisgründen aber ganz wichtig das zu wissen.

 

[Illuvatar]

In Java steht aber bereits zur Compilezeit fest, ob eine Variable ein Primitiv oder ein Objekt ist. Deshalb gibt es da auch keine Möglichkeiten, das abzufragen, weil das keinen Sinn machen würde.
Nur in bestimmten Spezialfällen wie Reflection kann mal etwas ähnliches nötig sein, daher die genannte [c]isPrimitive[/c] Methode. Im Normalfall ist diese aber auch nicht anwendbar, da der Compiler eben weiß, dass da kein Objekt ist, und man sich davon also auch keine Klasse o.ä. anschauen kann.

 

[TKausL]

Ich verstehe das Problem auch nicht. Wenn du "von anderen Systemen" Daten geliefert bekommst, weißt du doch schon, welchen Typ die Methode zurück gibt. Bei PHP ist es ja so, dass Jede Variable jeden Datentyp enthalten kann, dafür gibt es ja dann auch Funktionen wie is_numeric und co. Bei Java ist das aber nicht nötig.

 

[DontKnowJava]

In Java steht aber bereits zur Compilezeit fest, ob eine Variable ein Primitiv oder ein Objekt ist. Deshalb gibt es da auch keine Möglichkeiten, das abzufragen, weil das keinen Sinn machen würde.
Nur in bestimmten Spezialfällen wie Reflection kann mal etwas ähnliches nötig sein, daher die genannte [c]isPrimitive[/c] Methode. Im Normalfall ist diese aber auch nicht anwendbar, da der Compiler eben weiß, dass da kein Objekt ist, und man sich davon also auch keine Klasse o.ä. anschauen kann.

Ah, ich glaube ich beginne zu verstehen.
Ich komme gar nicht in die Verlegenheit auf Primitive zu testen, da ich intern wohl nur mit Objekten arbeite, die höchstens ihrerseits mit externen Daten (Primitiven) in Verbindung kommen können?

Danke!

 

[Fu3L]

Wenn dir irgendwas einen primitiven Datentyp zurückliefern wird, dann MUSS das von vornherein feststehen. So sind die Regeln in Javas Typsystem.

Wenn du aber von "Außen", wie du sagst, irgentetwas unbekanntes bekommst (warum auch immer) und das könnte Zahl, komisches Objekt, Wahrheitswert sein, dann müsste das als Objekt übergeben werden. Da gibts dann die entsprechenden Klassen "Integer, Boolean" oder halt die Klasse des "komischen Objekts". Deswegen gibt es auch keine Collections-Klassen in der Standardbibliothek wie List<int>, weil du nur bei Objekten beliebiges einfügen kannst.

Ich komme gar nicht in die Verlegenheit auf Primitive zu testen, da ich intern wohl nur mit Objekten arbeite, die höchstens ihrerseits mit externen Daten (Primitiven) in Verbindung kommen können?

Dieser Satz scheint mir komisch^^ Wenn du mit externe Daten irgendwelche Quellen wie Datei oder Netzwerk meinst und dass du selbst nie int, double und co nutzen wirst, dann liegst du falsch^^

 

[Gastredner]

Wenn du von einem anderen System Daten geliefert bekommst, dann erfolgt dies in Java normalerweise über eine Schnittstelle, die zuvor von irgendjemandem - vorzugsweise von dir - definiert worden ist, beispielsweise durch ein Interface:

public interface ForeignSystem {

	void receiveData(int number, float secondNumber, String foo);
}

Da Java sicherstellt, dass die einer Methode übergebenen Argumente mit denen der Methodendeklaration übereinstimmen, kannst du sicher sein, dass bei einem Aufruf der Methode [c]receiveData()[/c] von dem Fremdsystem tatsächlich ein int, ein float und ein String dabei übergeben werden. Bei Klassen musst du allerdings daran denken, dass auch Unterklassen eines Typs Klassen dieses Typs sind:

class A {

	private int a;

	public A(int a) {
		this.a = a;
	}
}

class B extends A {
	// Vererbung bildet eine "Ist-Ein"-Beziehung ab, jede Instanz von B ist daher auch eine von A.

	private int b;

	public B(int a, int b) {
		super(a);
		this.b = b;
	}
}

public interface ForeignSystem {

	void receiveData(A a);
}

public class Test {

	public static void main(String[] args) {
		ForeignSystem system = // Irgendwoher kommt eine Implementierung des Interfaces;
		system.receiveData(new B(0, 0));	// B ist auch eine Instanz von A, daher ist dieser Aufruf zulässig. Innerhalb von reveiceData ist die Instanz von B sichtbar als eine Instanz von A.
	}
}

Kurz: du kannst davon ausgehen, dass bei einem Aufruf einer Java-Methode tatsächlich Datentypen übergeben werden, die mit den in der Methodendeklaration angegebenen Datentypen kompatibel sind. Ob es sich tatsächlich um diesen konkreten Typen oder eine Unterklasse davon handelt, kann dir an dieser Stelle egal sein - deine "Sicht" auf das gegebene Objekt entspricht dem Typen, mit dem es in der Methodendeklaration angegeben worden ist.

Problematisch wird es allerdings, wenn deine Methode irgendwie so deklariert worden ist: [c]receiveData(Object number, Object foo)[/c]. In diesem Fall könntest du nur Objekte verwenden und müsstest die übergebenen Datentypen tatsächlich auf ihren Typ prüfen - allerdings würde ich dies eher als Problem der Schnittstellendefinitioon ansehen und dort eine Änderung verlangen, da eine solche Schnittstelle fast immer unsinnig ist. Java bietet strenge Typisierung, die man auch nutzen sollte.

 

[DontKnowJava]

Dieser Satz scheint mir komisch^^ Wenn du mit externe Daten irgendwelche Quellen wie Datei oder Netzwerk meinst und dass du selbst nie int, double und co nutzen wirst, dann liegst du falsch^^

Naja, der Satz _war komisch_
Aber ich denke ich verstehe es wirklich so langsam

Vielen Dank für die zahlreichen Antworten, vor allem der letzte Beitrag von Gastredner, den ich mir heute Abend in Ruhe ansehen werde!

DANKE