Ok also ich erklärs dir noch einmal genauer:
Wir haben folgende Klassen:
[ul]
[li]Start[/li][li]Auto[/li][li]Rad[/li][li]Tür[/li][li]Scheibenwischer[/li][/ul]
Okay, die Struktur ist klar: Wir brauchen ein Auto, und unser Auto braucht vier Räder, zwei Türen und zwei Scheibenwischer.
In der Klasse Start wollen wir 3 solcher Autos erzeugen.
fangen wir einfach mal - Klasse Start:
//unsere Klasse, in der alles beginnt
public class Start {
//die Hauptmethode, die beim Starten des Programms aufgerufen wird
public static void main(String[] args){
//wir erzeugen hier 3 Autos: autoFritz, autoHans, autoPeter
Auto autoFritz = new Auto();
Auto autoHans = new Auto();
Auto autoPeter = new Auto();
//damit hätten wir 3 gleiche Autos, die nur unterschiedliche namen haben
}
}
So weit so gut, das sollte verständlich sein.
Nun werfen wir einen Blick auf die Klasse Auto:
//Klasse Auto
public class Auto {
//das ist der konstruktor dieser klasse, er wird aufgerufen bei new Auto()
public Auto(){
//erzeugung von vier rädern:
Rad radVorneLinks = new Rad();
Rad radVorneRechts = new Rad();
Rad radHintenLinks = new Rad();
Rad radHintenRechts = new Rad();
//erzeugung von zwei Türen
Tuer tuerLinks = new Tuer();
Tuer tuerRechts = new Tuer();
//erzeugung von zwei Scheibenwischern
Scheibenwischer wischerVorne = new Scheibenwischer();
Scheibenwischer wischerHinten = new Scheibenwischer();
}
}
So weit so ebenfalls gut, unser auto ist erzeugt. Nun die Klasse Rad die eine Variable groesse besitzt, Tuer die eine Variable aufmachbar besitzt, und Scheibenwischer die eine variable
Laenge besitzt:
public class Rad {
public Rad(){
//das ist ein Rad
//die variable groesse
int groesse = 30;
}
}
public class Tuer {
public Tuer(){
//das ist eine tuer
//die variable aufmachbar (true | false) bedeutet soviel wie (ja | nein) oder (1 | 0) und boolean beschreibt einfach diesen typ
//hiermit sagen wir das man die tuer aufmachen kann - also aufmachbar ja ist
boolean aufmachbar = true;
}
}
public class Scheibenwischer {
public Scheibenwischer(){
//das ist ein scheibenwischer
//die variable laenge - float weil ich eine kommazahl will und es meter sein soll, es kann ja auch sein das wir zentimeter haben, wie hier: 1.5 also 1,50 meter
float laenge = 1.5;
}
}
und nochmal so weit so gut.
Nun, werfen wir nochmal ein blick auf die klasse start - was machen wir jetzt wenn wir zum beispiel
die reifengroesse vom auto von hans haben wollen?
Man könnte meinen:
autoHans.radVorneRechts.groesse
aber das geht natürlich nicht. Also machen wir, wie du auch schon getan hast eine instanz variable groesse, die also von überall her aufrufbar ist:
public class Rad {
//allgemein sichtbare variable rad, die wir hier nur deklarieren, (also sagen das es sie gibt) ...
int groesse;
public Rad(){
//...... und hier sagen welchen wert sie hat:
groesse = 30;
}
}
nun, es wird aber immer noch nicht klappen, da wir ja in autoHans auch die ganzen variablen unsichtbar sind. also bauen wir es so um:
public class Auto {
//allgemein sichtbare variablen..
Rad radVorneLinks;
Rad radVorneRechts;
//und so weiter mit allen...
public Auto(){
//und weisen hier wieder die werte zu
radVorneLinks = new Rad();
//... und so weiter.
}
nun, jetzt können wir in der klasse Start, weil dort ja die drei objekte vom auto liegen einfach sagen:
autoHans.radVorneLinks.groesse
wenn wir jetzt auch die Tuer so umbauen, das aufmachbar sichtbar ist,
public class Tur {
boolean aufmachbar;
public Tuer(){
aufmachbar = true;
//....
dann könnten wir in start sogar folgendes machen:
if(autoPeter.tuerLinks.aufmachbar){
//mache die linke tuer auf
}
else{
//melde, das die linke tuer geschlossen bzw nicht aufmachbar ist und gucke ob die rechte tuer auf ist:
if(autoPeter.tuerRechts.aufmachbar){
//mache halt die rechte tuer auf
}
else{
//oder melde das beide tueren geschlossen sind.
}
}
Ist das einiger massen verständlich? 
