Vererbung Sonnensystem mit Planeten generieren

[Fesker]

Guten Abend,
ich bin seit gestern unter den Hobby-Java-Programmierern ...

Ich möchte mich ein wenig mit Klassen, Vererbung und dergleichen ausprobieren. Folgende Situation:
Ein Sonnensystem soll generiert werden (erst mal nur eins, soll später auf mehrere erweitert werden)
Jedes Sonnensystem soll eine zufällige Anzahl an Planeten zugesagt bekommen.
Die Planeten erhalten verschiedene Eigenschaften, wie "Entfernung zur Sonne", "Durchschnittstemperatur", "Typ (Eis, Gas, Terranisch)" usw.

Ich habe allerdings keine Ahnung, wie man sowas vernünftig realisiert.
Eine "Planet"-Klasse konnte ich einigermaßen gut strukturieren.
Das Planetobjekt wird derzeit in meiner Main-Funktion erzeugt mittels new Planet();

Ich möchte aber gern in der Mainfunktion nur das Sonnensystem erstellen und die Planetengenerierung in die SolarSystem-Klasse verschieben. Doch dort, kann er irgendwie keine Objekte erzeugen und gibt mir immer Fehlermeldungen aus. Oder ich greife falsch darauf zu.

In Basic hätte ich beispielsweise Nur print(Solarsystem1.Planet1.sName) schreiben müssen (oder so ähnlich) um ein Ergebnis zu bekommen, hier wills nicht richtig klappen.

Main-Klasse

import java.util.*;
import java.awt.*;

public class huhu
{

    public static void main(String[] args) 
	{
    	SolarSystem SolarSystem1 = new SolarSystem();

    // --> In SolarSystem class verschoben	Planet planet1 = new Planet();
    //	Planet planet2 = new Planet();
    	
    	System.out.println(planet1.sName); 
        System.out.println("Distanz: "+planet1.iDistance + " AU");
    	System.out.println(planet1.iTemp); 
    	
    	System.out.println(planet2.sName + "Distanz: "+planet2.iDistance + " AU");
	}
    
}

Planet-Klasse

import java.util.*;
public class Planet extends SolarSystem
{
	
	public Integer iName,      // RandomNumber
	               iDistance,  // DistanceToSun
	               iTemp;      // Average temperature based on Distance
	        
	public String  sType,      // Terran, Water, Gas, Ice
	               sName;      // Planet's Name      
	
	Planet() {
		GenerateName();
		GenerateDistance();
	}
	
	void GenerateName() // Wie der Name schon sagt...
	{
		String    sAlphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
		Character cRandChar;
		
		Random iRandom = new Random();
		         sName = "";
		         
		// 3 Anfangsbuchstaben ausdenken
		for (int i = 0; i < 3; i++) 
		{
			cRandChar = sAlphabet.charAt(iRandom.nextInt(sAlphabet.length()));
			sName = sName + cRandChar;
		}
		
		// Und Nummern hinzufügen
		sName = sName + "-" + Integer.toString(iRandom.nextInt(899)+100);
	}
	
	void GenerateDistance() 
	{
		Random iRandom = new Random();
		iDistance = iRandom.nextInt(50)+5;	
	}	
}

SolarSystem-Klasse

public class SolarSystem
{

	String sSunType;
	
	public static void SolarSytem() 
	{
		Planet planet1 = new Planet();
    	        Planet planet2 = new Planet();
    	
	}
}

Ende vom Lied:
planet1 cannot be resolved to a variable
planet1 cannot be resolved to a variable
planet1 cannot be resolved to a variable
planet2 cannot be resolved to a variable
planet2 cannot be resolved to a variable

Sofern ich dann

Planet planet1 = new Planet();
    	        Planet planet2 = new Planet();

in die Mainschleife packe, gehts allerdings.

Was ist hier falsch?

Danke euch im Voraus.

 

[rme]

Hallo,

das ist eine schöne Idee für ein Projekt

Die Trennung in verschiedene Klassen und Methoden macht man unter anderem, damit alles übersichtlicher wird und man nicht im Chaos versinkt, wenn das Projekt wächst. Deshalb hat man sich auch entschlossen, dass Variablen, die man innerhalb von Methoden anlegt, nur in diesen auch sichtbar sind.

In deiner SolarSystem-Klasse legst du innerhalb einer Methode Planeten an - diese sind nach außen aber gar nicht sichtbar. Deine Idee war glaube ich, dass du die Planeten von SolarSystem erben lässt, damit sie sichtbar werden? Dafür müssten sie aber auf Ebene der Klasse definiert werden (so, wie du es mit sSunType getan hast). Diese Idee halte ich allerdings nicht für sonderlich gut. Vererbung sollte immer ein "ist ein"-Beziehung sein und "Planet ist ein Sonnensystem" gilt in der Astronomie, die ich kenne, allerdings nicht

In meinem Sonnensystem gäbe es ein Array oder eine Liste von Planeten. main() könnte dann ein Sonnensystem erzeugen und Methoden benutzen, um dieses mit Planeten zu füllen. Oder ein Sonnensystem hätte die Möglichkeit, zufällige Planeten für sich selbst zu erzeugen. Oooder ein Planet hätte die Möglichkeit, mit zufälligen Werten initialisiert zu werden, sodass diese in main() einfach erzeugt und hinzugefügt werden können

 

[Fesker]

Ja, ich muss dazu sagen, ich hatte so etwas vor Jahren schon mal programmiert. Bin da nur leider wirklich aus der Übung. Zu allem Überfluss jedoch in Pascal, wollte das ganze auch dreidimensional gestalten und habe dann OpenGL mit einbezogen (Umlaufbahnen, Texturen usw.)
Das sollte mal eine Nerd-Endlos-Handels-/ Explorationssimulation werden, mit OgameElementen.. habs aber nie wirklich vollbracht :bloed:

Da hatte ich das auch mit mehrdimensionalen Arrays gelöst, nun dachte ich man könnte eventuell das mit Java gleich über diese Klassenvererbungsdings machen.
Nun ja, aber ich hab davon keine Ahnung und fange halt wieder von null an und vielleicht eine andere Auffassung, was eine Klasse für mich bedeuten könnte.

Wenn ich halt den Planeten untergeordnet in mein Sonnensystem stecke, sehe ich den eben als Teil des jeweiligen Sonnensystems, aber deine Argumentation leuchtet (Nach Programmiererlogik) ein.

Mich hatte lediglich die Übersichtlichkeit von Java überzeugt. Eigentlich eher von "Eclipse".
Vielleicht verwirrt die mich auch gerade etwas...

Danke für die schnelle Antwort.

 

[Phash]

Übersicht ist das richtige Wort. Man hat sich auf einige Dinge mehr geeinigt, als sie von der Natur übernommen.

Momentan sieht man es eher so, dass eine Komposition besser ist als Vererbung. Google mal nach composition oder inheritance.

Gibt ein super Beispiel hier im forum. Stichwort jframe

 

[Fesker]

Heyho, ich hab mich wieder ein bisschen mit der Materie befasst und die ganze Situation etwas arraymäßiger abgewandelt, aber ein paar Sachen finde ich leider auf Anhieb nicht, darum frag ich einfach mal hier weiter.

Vorweg ein bisschen Code zum Verständnis:
main-klasse:

import java.util.*;
import java.awt.*;

public class huhu
{
		
    public static void main(String[] args) 
	{

    	SolarSystem[] SolarSystem = new SolarSystem[2];
    	SolarSystem[0] = new SolarSystem(1,1);
    	SolarSystem[1] = new SolarSystem(1,2);
    	
    	System.out.println(SolarSystem[0].iPlanetQuantity);
    	System.out.println(SolarSystem[1].iPlanetQuantity);
    	
	}
    
}

SolarSystem-Klasse:

public class SolarSystem
{

	public int iPlanetQuantity, iSunType;
	
	public SolarSystem(int iSunType, int iPlanetQuantity) {
		this.iPlanetQuantity = iPlanetQuantity;
		this.iSunType = iSunType;
	}
	
}

Ich bin soweit klargekommen, aus dem SolarSystem einen Array zu erstellen und etwaige Eigenschaften auszulesen oder zu schreiben.
Was mir jetzt fehlt ist ein Array im Array sozusagen.
Oben könnt ihr ja nochmal sehen, dass ich ja eine "Planeten-KLasse", ebenfalls mit eigenen Eigenschaften erstellen will um sie ins Sonnensystem einzubinden.

Aber bei dem Thema hören irgendwie alle Tutorials auf (falls sowas in Java überhaupt geht)

Sodass ich hinterher die möglichkeit habe ala

println(SolarSystem[1].Planet[1].Name)

mit den Werten herumexperimentieren zu können. Dass das SolarSystem seine eigenen Eigenschaften behält, genauso wie der dazugehörige Planet.

Ich hoffe, das klingt irgendwie verständlich.

Kann mir jemand einen Denkanstoß geben, wie ich das einbinden kann? Code-Schnipsel sind auch gern gesehen. =)

Grüße, Fesker.

 

[rme]

Aus chronometrischen Gründen bin ich gerade müde, daher nur ein bisschen Code ohne viele Kommentare. Ich habe versucht, eine Sonnensystem- und Planetenklasse mit möglichst einfachen Mitteln umzusetzen. Aber auf Listen wollte ich dabei nicht verzichten, die Arbeit mit Arrays macht nämlich wenig Spaß und findet auch in der Praxis selten Anwendung.

Falls du Fragen dazu hast, stell sie gern, nach der nächsten Schlafphase bin ich wieder fit und kann gerne Dinge erklären

SolarSystem

import java.util.LinkedList;
import java.util.List;

public class SolarSystem {
    private final List<Planet> planets;

    // constructor to create an empty solar system
    public SolarSystem() {
        this.planets = new LinkedList<Planet>();
    }

    // add a given planet to this solar system
    public void addPlanet(Planet p) {
        planets.add(p);
    }

    // retrieve number of planets in this solar system
    public int getPlanetCount() {
        return planets.size();
    }

    // retrieve a planet given by its index, 0 <= i < planetCount
    public Planet getPlanet(int i) {
        return planets.get(i);
    }

    public static void main(String[] args) {
        SolarSystem sol = new SolarSystem();
        sol.addPlanet(new Planet(Planet.PlanetType.GAS, "Uranus", 9e25));
        sol.addPlanet(new Planet(Planet.PlanetType.TERRAN, "Earth", 6e24));

        for(int i = 0; i < sol.getPlanetCount(); i++) {
            Planet p = sol.getPlanet(i);
            System.out.println(p.getName() + ", mass: " + p.getMass() + ", type: " + p.getType());
        }
    }
}

Planet

public class Planet {
    public enum PlanetType {TERRAN, WATER, GAS, ICE};
    private final PlanetType type;
    private final String name;
    private final double mass;

    // construct a new planet with given attributes
    public Planet(PlanetType type, String name, double mass) {
        this.type = type;
        this.name = name;
        this.mass = mass;
    }

    public String getName() {
        return name;
    }

    public double getMass() {
        return mass;
    }

    public PlanetType getType() {
        return type;
    }
}

 

[Fesker]

Wow, danke für die schnelle Rückmeldung. (Keine Ahnung, wo es hier einen "Danke"-Button gibt, aber wenn ich ihn finde, drück ich drauf

Das mit den Linked_lists hilft mir definitiv weiter, aber da muss ich mich auch erst wieder belesen...
Aber hast es schon mal sehr verständlich geschrieben.
Ich kann deinen Code erst heute abend ausprobieren, aber für mich sieht es gerade so aus, dass ich in der main-methode doch wieder darauf angewiesen bin, jedem Sonnensystem eine eigene Variable zuzuweisen (in deinem Bsp. "sol")

Nur möchte ich später gern tausende nacheinander weg generieren, und das kann ja nur mit einem Array + Schleife gelöst werden. Also sowas in der Richtung

for (int i=0; ganz oft; i++){ sol[i].addPlanet(random,random,random) }

Du sagtest, die Arbeit mit Arrays findet in der Praxis wenig Anwendung, aber die versuchen ja auch keine tausendfach verschachtelten Sonnensysteme zu gestalten. =P
Zu den Planeten sollen dann auch noch eigene Monde kommen usw. Steht aber noch in den Sternen, je nach dem wie motiviert ich bin...

In Basic gibt es dafür Möglichkeiten unzählige Arrays aneinanderzuketten (und das ist schon jahre veraltet) also muss doch in Java sowas auch gehen!

Oder hättest du einen besseren Lösungsvorschlag für solch eine Problematik mit den Objekten praktischer umzugehen? Ich will mich ja an meiner Methodik hier nicht aufhängen, bin ja lernfähig.

Grüße!

 

[rme]

Du könntest einfach in main eine LinkedList vom Typ SolarSystem anlegen, dort beliebig viele SolarSystem-Objekte hinzufügen und dann sowas machen:

systems.get(2).getPlanet(4).getName();

Der Vorteil gegenüber Arrays ist, dass Listen sich dynamisch vergrößern können. Bei Arrays müsstest du zum Vergrößern alles manuell machen: Neuen Speicher besorgen, alte Daten reinkopieren, neue Daten anfügen..

 

[ARadauer]

Listen, Maps, Sets usw..

 

[Harry Dolm]

Klingt nach einem interessanten Programm. Was ist daraus geworden?
Ich hätte Interesse

 

[Harry Dolm]

Klingt nach einem interessanten Programm. Was ist daraus geworden?
Ich hätte Interesse

 

[temi]

Klingt nach einem interessanten Programm. Was ist daraus geworden?
Ich hätte Interesse

Das ist schon ein paar Jahre her. Ich würde vorschlagen, dass du dich einfach selbst daran versuchst. Fragen kannst du gerne hier im Forum stellen und am besten ein eigenes Thema dazu aufmachen.