Java < Sonstige < Schule < Informatik < Vorhilfe
|
| Status: |
(Frage) beantwortet  | | Datum: | 22:24 Mi 17.10.2007 | | Autor: | SusaSch |
Hallo
Ich habe mal wieder ein problem mit java und eclipse. Unzwar habe ich im i net was zu arrays gelesen. Da stand folgendes zur erschaffung eines arrays+ zuweisung von werten.
int[] Zahlen = new int[100];
Zahlen[0] = 50;
Zahlen[1] = 500;
Zahlen[99] = 5000;
Schön und gut. Nun wollte ich das in eclipse ausprobieren und siehe da, eclipse meckert vonwegen sytaxfehler. Ich habe in der klasse keine main methode gehabt. Nun habe ich eine hinzugefügt und er mecker wegen den arrys nicht mehr, aber wegen den attributen. Aufeinmal mag er meine mit private angelegten Attribute nicht mehr. E will jezt welche mit final haben wieso?
Und warum weißt man dem array, wenn es doch ein objekt ist so die wete zu und nicht wie normalerweise mit Objektname.set?
Wäre nett wenn ihr mir auf die sprünge helfen würdet .).
LG Susi
|
|
| |
|
| Status: |
(Antwort) fertig  | | Datum: | 10:53 Do 18.10.2007 | | Autor: | rainerS |
Hallo Susi!
> Hallo
> Ich habe mal wieder ein problem mit java und eclipse.
> Unzwar habe ich im i net was zu arrays gelesen. Da stand
> folgendes zur erschaffung eines arrays+ zuweisung von
> werten.
>
> int[] Zahlen = new int[100];
>
> Zahlen[0] = 50;
> Zahlen[1] = 500;
> Zahlen[99] = 5000;
>
> Schön und gut. Nun wollte ich das in eclipse ausprobieren
> und siehe da, eclipse meckert vonwegen sytaxfehler. Ich
> habe in der klasse keine main methode gehabt. Nun habe ich
> eine hinzugefügt und er mecker wegen den arrys nicht mehr,
> aber wegen den attributen. Aufeinmal mag er meine mit
> private angelegten Attribute nicht mehr. E will jezt welche
> mit final haben wieso?
> Und warum weißt man dem array, wenn es doch ein objekt ist
> so die wete zu und nicht wie normalerweise mit
> Objektname.set?
Das sind ja gleich viele Fragen 
Die Frage nach dem final kann ich so, ohne dein Programm zu kennen, nicht beantworten.
Ein Array ist eine spezielle Art von Objekt. Arrays sind Bestandteil der Sprache Java.
Du kannst ein Array komplett zuweisen, was du ja in deinem Programmauszug auch tust:
int[] Zahlen = new int[100];
Du deklarierst ein Array namens Zahlen, dessen einzelne Elemente von Typ int sind und weist ihm ein neu erzeugtes Array mit 100 Elementen vom Typ int zu. Du einzelnen Elemente weist du mit dann mit Zahlen[0] usw. zu. Der Unterschied ist, dass du im ersten Fall dasselbe Array hast, im zweiten Fall einzelne Elemente modifizierst.
Das ist bei anderen Objekten auch nicht anders. Wenn sie öffentlich sichtbare Komponenten enthalten, kannst du die einzeln zuweisen (mit Objectname.Komponentenname = Wert), oder du weist das Objekt als ganzes zu. Wenn du es als ganzes zuweist (objA = objB), dann hast du dasselbe Objekt, das du unter zwei verschiedenen Namen ansprechen kannst.
Normalerweise heissen die Methoden zum Zuweisen von Komponenten eines Objekts Objektname.setXXX. Das ist kein Bestandteil der Sprache, sondern Konvention. Das macht man deswegen, damit man den Zugriff auf die Komponenten des Objekts besser kontrollieren kann: die Komponenten sind nicht öffentlich (public) sondern versteckt (private). Dann ist der Zugriff nur noch über öffentlich deklarierte Methoden möglich, die üblicherweise gerade setXXX und getXXX heißen. Niemand kann dich hindern, sie stattdessen Susi und Strolch zu nennen. Es ist nur nicht sehr praktisch
Ich hoffe, das hilft dir weiter.
Viele Grüße
Rainer
|
|
|
| |
|
| Status: |
(Frage) beantwortet | | Datum: | 12:37 Do 18.10.2007 | | Autor: | SusaSch |
Hallo
Vielen dank für deine antwort. Habe jetzt mal den "Programmtext" kopiert. Ist eigentlich nur viel unsinniges zeug zum probieren und hat keinen tieferen sinn :).
//**********************************************
package fachklassen;
public class Artikel
{
private double Preis;
private String SBezeichnung;
String text = "";
int Zahlen []= new int[100];
Zahlen[0] = 50;
Zahlen[1] = 500;
Zahlen[99] = 5000;
int laenge = Zahlen.length;
System.out.println(laenge);
String[] Texte = new String[2];
Texte[0] = "Hallo,";
Texte[1] = " Welt!";
int izahl = Zahlen[1];
System.out.println(izahl);
System.out.println(Zahlen[99]);
}
//****************************************************
Also wenn ich das so schreibe, mag er eben die zuweisungen der werte zum array nicht. Vonwegen syntaxfehler bei token....
Zahlen[0] = 50;
Zahlen[1] = 500;
Zahlen[99] = 5000;
//********************************************************
package fachklassen;
public class Artikel
{
public static void main(String[] args)
{
private double Preis;
private String SBezeichnung;
String text = "";
int Zahlen []= new int[100];
Zahlen[0] = 50;
Zahlen[1] = 500;
Zahlen[99] = 5000;
int laenge = Zahlen.length;
System.out.println(laenge);
String[] Texte = new String[2];
Texte[0] = "Hallo,";
Texte[1] = " Welt!";
int izahl = Zahlen[1];
System.out.println(izahl);
System.out.println(Zahlen[99]);
}
}
//***************************************************
Mit main methode jammert er vonwegen. Ungültiger änderungswert... nur final zulässig.
Mag also das nicht:
private double Preis;
private String SBezeichnung;
//********************************************************
Könnt ihr mir sagen was er und warum er das nicht mag ? Danke :)
LG Susi
|
|
|
| |
|
| Status: |
(Antwort) fertig | | Datum: | 13:31 Do 18.10.2007 | | Autor: | rainerS |
Hallo Susi!
Der Java-Compiler stört sich am Schlüsselwort "private".
Vereinfacht gesagt, gibt es einen großen Unterschied zwischen Variablen, die in einer Klasse und in einer Methode (allgemein: in einem Block) deklariert werden.
"private" (und "protected", "public") geben den Zugriff auf Variablen oder Methoden einer Klasse an. Das heisst, damit sagst du ob sie von außerhalb der Klasse zugegriffen (bei Variablen) oder aufgerufen (bei Methoden) werden können.
Innerhalb einer Methode hast du nur lokale Variablen; die sind nie außerhalb der Methode sichtbar. (Genauer gesagt, nur innerhalb des Blocks, in dem sie deklariert sind.) Daher gibt's dafür keine Zugriffsdeklaration, also ist "private" an dieser Stelle nicht erlaubt.
Viele Grüße
Rainer
|
|
|
| |
|
| Status: |
(Frage) beantwortet | | Datum: | 13:45 Do 18.10.2007 | | Autor: | SusaSch |
Hallo
Aha. also die attribute über die main methode oder? :).
Und warum muss man bei arrays eine main methode haben oder ist das problem irgendwo anders?
LG susi
|
|
|
| |
|
| Status: |
(Antwort) fertig | | Datum: | 14:47 Do 18.10.2007 | | Autor: | rainerS |
Hallo Susi!
> Hallo
> Aha. also die attribute über die main methode oder? :).
Die Deklaration mit private, meinst du? Entweder das, oder das private weglassen. Dann sind es aber Variablen, die nur in der main-Methode benutzbar sind.
> Und warum muss man bei arrays eine main methode haben oder
> ist das problem irgendwo anders?
Da kommen zwei Dinge zusammen.
1. Die main-Methode brauchst du, damit du ein komplettes Programm hast. Beim Ausführen wird immer die main-Methode gestartet.
2. In einer Klasse gibt es nur Deklarationen und Methoden. Eine Zuweisung wie
Zahlen[0] = 50;
ist keine Deklaration, sondern eine ausführbare Anweisung. Die kann nur innerhalb einer Methode vorkommen.
Die Unterscheidung ist bei Arrays subtil: Arrays sind Objekte. Daher musst du zwischen der Deklaration einer Array-Variablen
int[] Zahlen;
und der Erzeugung und Zuweisung des Arrays zur Laufzeit
Zahlen = new int[100];
unterscheiden.
Deswegen stolpert das Eclipse über deine Zeile
int[] Zahlen = new int[100];
Du deklarierst und erzeugst in einer Zeile dein Array, und die Erzeugung ist keine Deklaration, ist deswegen nur in einer Methode erlaubt.
Gleiches gilt für Zahlen[0]=1; oder System.out.println(...): keine Deklaration.
In einer Deklaration darfst du nur konstante Werte zuweisen. Erlaubt wäre zum Beispiel
int[] Zahlen = {1,2,3,4,5+1};
weil die rechte Seite konstant ist.
Viele Grüße
Rainer
|
|
|
| |
|
| Status: |
(Mitteilung) Reaktion unnötig  | | Datum: | 15:03 Do 18.10.2007 | | Autor: | SusaSch |
Hallo
Vielen dank für deine ausführlich erklärung. Das heißt( außer wenn ich das programm laufen lassen will) brauch ich die main methode gar nicht. Solane ich die array( außer meinetwegen die deklaration der array- variablen) in irgendwelchen methoden habe( in denen man sie braucht). > nur geschriebene gedanken :)
LG Susi
|
|
|
| |
|
| Status: |
(Mitteilung) Reaktion unnötig | | Datum: | 15:16 Do 18.10.2007 | | Autor: | SusaSch |
Hey
Bin schon dabei :). Habe eine seite mit mehreren tutorials bzw allen möglichen sachen zu java gefunden und kämpfe mich da gerade durch. Daher auch die fragen :). Gut das es menschen gibt, die einem helfen wenn man nicht weiter weiß.
LG Susi
|
|
|
| |
|
| Status: |
(Frage) beantwortet | | Datum: | 19:15 Do 18.10.2007 | | Autor: | SusaSch |
Hallöle
Nach einigen stunden lesen und tippen, bin ich erneut auf ein problem gestoßen. Unzwar bei folgendem ( im i net gefundenen) programmtext. Es geht um objektarrays
//*******************************************************class MyClass
{
public MyClass(int i)
{
this.i = i;
}
private int i;
}
public class MyTest
{
public static void main(String[] args)
{
// Schritt 1 - Erzeugung des Arrays
MyClass[] array = new MyClass[2];
// Schritt 2 - Instanziierung der Elemente
array[0] = new MyClass(1);
array[1] = new MyClass(2);
}
}
//******************************************************
Meine frage ist, warum beim schritt zwei bei : new MYClass etwas hinten in der klammer steht. Kenne die klammern bisher immer nur leer. Wofür sind die 1 und die 2 dort?
LG Susi
|
|
|
| |
|
| Status: |
(Antwort) fertig | | Datum: | 20:38 Do 18.10.2007 | | Autor: | piet.t |
Hallo,
wenn Du das
new MyClass(1);
meinst, dann liegt das daran, wie der sogenannte "Konstruktor" von MyClass gebaut ist.
Ein Konstruktor ist allgemein gesprochen eine Bauanleitung für MyClass-Objekte, und wird in java als eine Methode in der entsprechenden Klasse realisiert.
Wenn keine ausdrückliche Konstruktor-Methode angegeben wird, dann verwendet java einfach einen Standard-Konstruktor, der einfach sämtliche Attribute auf Standardwerte setzt.
In Deinem Fall finden wir aber folgendes:
| 1: | public class MyClass
| | 2: | {
| | 3: | public MyClass(int i)
| | 4: | {
| | 5: | this.i = i;
| | 6: | }
| | 7: |
| | 8: | private int i;
| | 9: | }
|
Die Zeile 3 sieht ja so ählich aus wie eine Methodendeklaration, allerdings fehlt der Rückgabetyp und die Methode heisst genau wie die Klasse: das ist immer die Kennzeichnung für Konstruktor-Methoden. Diese Methoden werden immer dann aufgerufen, wenn man mittels "new" ein neues Objekt erzeugt.
Wie jede andere Methode auch kann es aber bei einem Konstruktor nötig sein, beim Aufruf irgendwelche Werte mitzugeben. Im Beispiel steht ja MyClass(int i), d.h. mann muss dem Konstruktor eine (int-)Zahl übergeben, die dann in das Attribut i übertragen wird. Dummerweise hat man hier zwei mal den gleichen Namen, deshalb muss man das Attribut i durch "this.i" vom Parameter i unterscheiden.
Hmm, keine Ahnung, ob das jetzt verständlich war, aber denk einfach mal drüber nach und wenn Dir noch Fragen dazu einfallen dann einfach raus damit!
Gruß
piet
|
|
|
| |
|
| Status: |
(Frage) beantwortet | | Datum: | 21:38 Do 18.10.2007 | | Autor: | SusaSch |
Hallo
War durchaus verständlich danke :).
Man kann also mit einer gescheiten konstruktormethode Attributen von einem objekt, wenn man sie nicht von anfang an gefüllt hat, gleich beim erschaffen des objekts werte zuweisen lassen( der rechner würde sie ansonsten auf standartwerte setzen). Wenn man der konstruktormethode parameter übergeben lässt, stellt man sozusagen "demjenigen", der das objekt erschafft frei auf welche werte die attribute des objekts von anfang an "gestellt" sein sollen(kann ihm also zunächst lässtige set -methoden ersparen > oder so :)). Hab das auch schön ausprobiert > klappt schön.
Nu habe ich dann folgendes geschrieben:
//***************************************************
//*************************************************
public class Konstruktor
{
private int iZahl1;
private int iZahl2;
private int iZahl3;
public Konstruktor(int iZahl1, int iZahl2)
{
this.iZahl1 = iZahl1;
this.iZahl2 = iZahl2;
//this.iZahl3 = iZahl3;
}
}
//******************************************************
Hab über ne andere klasse der konstruktormethode entsprechende werte übergebn lassen. Und mir nach erschaffen des Objekts die werte der attribute auf dem bildschirm ausgeben lassen. Ich wollte schauen was passiert, wenn das objekt zwar 3 attribute hat, ich aber über den konstruktor nur 2 füllen lasse. Ausgegeben wurde mir dann eben für die ersten 2 zahlen, die über den konstrukto zugewiesenen werte, während für das nicht gefüllte attribut 0 zurückkam.
Ist ja nicht weiter verwunderlich. hat der rechner wohl doch wieder seine finger mit den standartwerten im spiel gehabt.
Aber warum ist das so? Habe gelesen, das wenn man eine eigene konstruktormethode schreibt, die des rechners"überschrieben" wird. Hab also eher damit gerechnet, das er meine methode ausführ und dann fehler meldungen auspuckt. Greift also der auch dann zu seinem konstrukto wenn er merkt das meine methode nicht für alle attribute gilt?
Hoffe man versteht was ich meine.
LG Susi
|
|
|
| |
|
| Status: |
(Antwort) fertig | | Datum: | 00:01 Fr 19.10.2007 | | Autor: | rainerS |
Hallo Susi!
> Hab über ne andere klasse der konstruktormethode
> entsprechende werte übergebn lassen. Und mir nach
> erschaffen des Objekts die werte der attribute auf dem
> bildschirm ausgeben lassen. Ich wollte schauen was
> passiert, wenn das objekt zwar 3 attribute hat, ich aber
> über den konstruktor nur 2 füllen lasse. Ausgegeben wurde
> mir dann eben für die ersten 2 zahlen, die über den
> konstrukto zugewiesenen werte, während für das nicht
> gefüllte attribut 0 zurückkam.
> Ist ja nicht weiter verwunderlich. hat der rechner wohl
> doch wieder seine finger mit den standartwerten im spiel
> gehabt.
Genau. Für Zahlen ist der Standardwert 0, der wird genommen, wenn kein anderer Wert beim Anlegen der Variablen zugewiesen wird.
> Aber warum ist das so? Habe gelesen, das wenn man eine
> eigene konstruktormethode schreibt, die des
> rechners"überschrieben" wird.
Nicht ganz. Jede Klasse ist Unterklasse einer anderen Klasse (der sog. Oberklasse oder auch Superklasse). Wenn du nichts angibst, wird Object als Oberklasse angenommen.
Wenn du keinen Konstruktur in deiner Klasse deklarierst, fügt der Java-Compiler automatisch einen Konstruktor ohne Parameter ein. Dieser Konstruktor ruft den Konstruktor der zugehörigen Oberklasse auf.
In deinem Fall hast du keine explizite Oberklasse von Konstruktor angegeben, also wird Object angenommen. Hast du keinen Konstruktor deklariert, so erzeugt der Compiler automatisch:
public Konstruktor() { Object(); }
Deklarierst du irgendeinen Konstruktor, dann tut der Compiler das nicht.
Hättest du für deine Klasse expliziert die Oberklasse angegeben:
public class Konstruktur extends Oberklasse { ...
so würde der Compiler automatisch
public Konstruktor() { Oberklasse(); }
erzeugen (es sei denn, du deklarierst selber einen Konstruktor).
Sinn der Sache ist es wohl, in einfachen Fällen automatisch zumindest den Speicher für die Klassenvaraible bereitzustellen und den einzelnen Felder Standardwerte zuzuweisen.
Häufig deklariert man mehrere Konstruktoren für verschiedene Spezialfälle, zum Beispiel:
| 1: | public class MeineKlasse {
| | 2: | private int feld1 = 0;
| | 3: | private int feld2 = 1;
| | 4: | private int feld3 = 2;
| | 5: |
| | 6: | public MeineKlasse() {} // keine Parameter, immer Standardwerte
| | 7: |
| | 8: | public MeineKlasse(int f1) { // Standardwerte außer für feld1
| | 9: | feld1 = f1;
| | 10: | }
| | 11: |
| | 12: | public MeineKlasse(int f1, int f2) { // Standardwert nur für feld3
| | 13: | feld1 = f1;
| | 14: | feld2 = f2;
| | 15: | }
| | 16: |
| | 17: | public MeineKlasse(int f1, int f2m int f3) { // alle Werte setzen
| | 18: | feld1 = f1;
| | 19: | feld2 = f2;
| | 20: | feld3 = f3;
| | 21: | }
| | 22: |
| | 23: | // weitere Methoden
| | 24: |
| | 25: | } |
Viele Grüße
Rainer
|
|
|
| |
|
| Status: |
(Frage) beantwortet | | Datum: | 09:49 Fr 19.10.2007 | | Autor: | SusaSch |
Guten Morgen
Ich muss zugeben, dass habe ich noch nicht so ganz verstanden.
Mir ist klar, dass wenn ich keinen konstruktor schreibe, der rechner sich selbst einen bastelt.
Aber ich hatte doch einen gehabt. Demnach dürfte doch der rechner keinen eigenen mehr schreiben.. Das muss er aber ja getan haben, wenn er die 3te zahl auf standartwert setzt.
LG Susi
|
|
|
| |
|
| Status: |
(Antwort) fertig | | Datum: | 12:53 Fr 19.10.2007 | | Autor: | rainerS |
Hallo Susi,
jetzt habe ich dich verwirrt.
Bei Java wird jeder Variablen beim Anlegen (das heisst noch vor der Ausführung des Konstruktors) ein Standardwert zugewiesen. Bei Zahlen ist das der Wert 0 (oder 0.0), bei Objekten der Wert null. Das passiert immer, egal wie die Variable angelegt wurde, außer du hast einen anderen Wert angegeben (Beispiel: int i = 1;). Danach werden die Anweisungen im Konstruktor ausgeführt.
In deinem Fall werden zunächst alle drei Variablen auf ihre Standardwerte gesetzt, dann werden die beiden übergebenen Werte zugewiesen.
Jetzt klarer?
Viele Grüße
Rainer
|
|
|
| |
|
| Status: |
(Frage) beantwortet | | Datum: | 13:18 Fr 19.10.2007 | | Autor: | SusaSch |
HAllo
Dumme frage :). Wenn eh alle variablen schon bei anlegen standardwerte zugewiesen werde( falls nicht andere werte zugewiesen wurden), wofür lässt dann der rechner (wenn ich keinen bastle) seinen konstruktor ablaufen? Ich dachte der wär dafür da, den variablen die s..werte zuzuweisen.
LG Susi
|
|
|
| |
|
| Status: |
(Antwort) fertig | | Datum: | 13:40 Fr 19.10.2007 | | Autor: | rainerS |
Hallo Susi!
Jetzt kommen wir zu den komplizierten Fällen.
Die Standardwerte sind oft nicht gewünscht. Bei Zahlen ist das ja noch einfach. Aber wenn du in deiner Klasse Objektvariablen deklarierst oder auch noch von eine Oberklasse ableitest, brauchst du einen Konstruktor.
Beispiel: Nimm die Klasse ArrayList (Standardklasse aus der Java-Bibliothek) und erweitere sie:
| 1: | public class MyArrayList extends ArrayList {
| | 2: |
| | 3: | int index = 0;
| | 4: |
| | 5: | } |
Ich habe also einfach ArrayList genommen und eine Variable hinzugefügt.
Es wird automatisch ein Konstruktor hinzugefügt, der so aussieht:
public MyArrayList() { ArrayList(); }
Es wird also die Initialisierung für den ArrayList-Anteil von MyArrayList ausgeführt.
So, und damit man in allen Fällen das Gleiche tun muss, hat man einfach gesagt, es wird immer ein Konstruktor ausgeführt, auch wenn er eigentlich gar nichts tut (wie in deinem Fall). Damit ist es eine einfache Regel.
Viele Grüße
Rainer
|
|
|
|
![[]](/images/popup.gif){kind=small}
Java-Tutorials von Sun