Klassen hintereinander ausführen

[Kaibear]

Moin moin,

ich habe für ein Projekt derzeit eine Klasse "ModifyXML" erstellt und eine Klasse "InsertName".
Bei InsertName wird eine Texteingabe getätigt, die dadurch die Variable "name" definiert. Diese variable soll dann in der zweiten Klasse, ModifyXML genutzt werden um innerhalb der XML eine Änderung vorzunehmen.
Beide Klassen funktionieren einwandfrei allein, aber eine Kopplung wäre jetzt wünschenswert.

Doch hierbei muss ich beide Klassen nacheinander ausführen. Wie wäre dies zu tätigen? Ich stehe diesbezüglich grade leicht auf dem Schlauch.

Ich danke euch für eure Hilfe.

 

[Phash]

Dinge nacheinander auszuführen ist prozedural - und damit nicht objekt orientiert.

Natürlich werden auch in OO viele Sachen nacheinander gemacht - aber man spricht nicht drüber


Was du machen möchtest:

du hsat 2 Klassen - KlasseA und KlasseB

und irgendwo hast du deine MainMethode - wo auch immer die liegt..

in Main machst du:

KlasseA klasseA = new KlasseA();
klasseA.tolleFunktion();

jetzt wird ein neues Objekt vom Typ KlasseA erzeugt, und du rufst eine Methode darauf auf.

Dann musst du entscheiden - weiss KlasseB von KlasseA? Oder KlasseA von KlasseB? ODer wissen die nichts voneinander, und brauchen lediglich ein paar Infos?

so wie das klingt, bekommst du irgendwas von der o.g Methode, und möchtest das in einer Methode von Klasse2 verwenden

also muss deine Methode oben, das gewünschte zurückliefern
Main:

KlasseA klasseA = new KlasseA();
String ergebnis = klasseA.tolleFunktion();
KlasseB klasseB = new KlasseB();
klasseB.stringErwarteFunktion(ergebnis);

KlasseA:

public class KlasseA{

public String tolleFunktion(){

return "ein toller String";
}

}

und KlasseB bekommt eine Methode, die auf genau so einen String wartet:


KlasseB:

public class KlasseB{

public void stringErwarteFunktion(String eingabe){

String ausgabe = "Ausgabe: " + eingabe;
System.out.println(ausgabe);
}

}

 

[kaoZ]

Muss der Code in der main Methode dann aber nicht so aussehen ?

public class Main {

	/**
	 * @param args
	 */
	public static void main(String[] args) {

		Foo foo = new Foo();
		new Bar().erwarteString(foo.ausgabe());

               // oder mit komplett Anonymen Objekten  * new Bar().erwarteString(new Foo().ausgabe()); *

	}

}

woher soll

.erwarteString(s);

der Klasse B(hier Bar) den sonst wissen welchen String es erhält, schließlich wartet die Methode ja auf einen String, natürlich nur wenn man den String der durch die Methode in Klasse A(hier Foo) returned wird nicht in irgendwo zwischenspeichert .

 

[Phash]

in meinem Beispiel wirds in "String ergebnis" zwischengespeichert, um den Schritt deutlicher zu zeigen.


Die Ausgabe einer Funktion als Eingabe einer anderen Funktion zu nutzen, ist für jemanden mit dem Level des TE zu hoch...

 

[ARadauer]

Wie wäre dies zu tätigen?

Im Grunde hast du zwei Werkzeuge gebaut. Ich würde jetzt eine dritte Klasse machen die die Beiden benutzt. Ließt mit der einen den Werte ein und übergibt den Wert an die andere Klasse.

Poste mal deine Klassen...

 

[Kaibear]

Der Code wie angefragt:

package javaIOtests;

import java.io.File;
import java.io.IOException;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.ParserConfigurationException;
import javax.xml.transform.Transformer;
import javax.xml.transform.TransformerException;
import javax.xml.transform.TransformerFactory;
import javax.xml.transform.dom.DOMSource;
import javax.xml.transform.stream.StreamResult;
import org.w3c.dom.Document;
//import org.w3c.dom.Element;
import org.w3c.dom.NamedNodeMap;
import org.w3c.dom.Node;
//import org.w3c.dom.NodeList;
import org.xml.sax.SAXException;
//import javaIOtests.InsertName;

public class ModifyStartXML {

	private static String pathDev = "C:\\Users\\049kopitz\\Desktop\\ENVIRONMENTS\\01_Dev";
	private static String xml = "\\Start.xml";
				
		public static void main (String args[]){
		try{
			String filepath = pathDev+xml;
			
			DocumentBuilderFactory docFactory = DocumentBuilderFactory.newInstance();
			DocumentBuilder docBuilder = docFactory.newDocumentBuilder();
			Document doc = docBuilder.parse(filepath);
			
			Node project = doc.getElementsByTagName("Project").item(0);
			
			NamedNodeMap name = project.getAttributes();
			Node nodeName = name.getNamedItem("Name");
			nodeName.setTextContent("Projektname");
			
			TransformerFactory transformerFactory = TransformerFactory.newInstance();
			Transformer transformer = transformerFactory.newTransformer();
			DOMSource source = new DOMSource(doc);
			StreamResult result = new StreamResult(new File(
					"C:\\Users\\049kopitz\\Desktop\\start.xml"));
			transformer.transform(source, result);

			System.out.println("Done");

		} catch (ParserConfigurationException pce) {
			pce.printStackTrace();
		} catch (TransformerException tfe) {
			tfe.printStackTrace();
		} catch (IOException ioe) {
			ioe.printStackTrace();
		} catch (SAXException sae) {
			sae.printStackTrace();
		}

	}

}

package javaIOtests;

import java.io.*;

public class InsertName {
	public static String projectName;
	
	public static void main (String args[]){
		System.out.println("Wie soll das Projekt heißen?");
		try {
			BufferedReader eingabe = new BufferedReader(new InputStreamReader(System.in));
			projectName = eingabe.readLine();
			
		}
		catch (IOException exception){
			exception.printStackTrace();
		}
	}
	
}

[STRIKE]
Ein weiteres Problem, das ich noch beheben muss:

Die XML hat ab und an zwei mal die Benennung "Project" in sich, beide müssten denselben Namen erhalten. Doch bisher kann mein Code das nur beim Ersten machen.[/STRIKE]

Is gelöst, for-schleife vor dem Part mit dem "[...].item(i)".

[XML]<Magicxpi_Startup>
<Projects>
<Project Name="Projektname" ProjectsDirPath="\\test\test\">
<Servers>
<Server host="test">
<ProjectsDirPath></ProjectsDirPath>
<NumberOfWorkers>10</NumberOfWorkers>
<NumberOfInstances>1</NumberOfInstances>
<Triggers load="true">
</Triggers>
<Scheduler load="true"/>
<AutoStart load="true"/>
</Server>
</Servers>
</Project>
<Project Name="Projektname" ProjectsDirPath="\\test\test\">
<Servers>
<Server host="test2">
<ProjectsDirPath></ProjectsDirPath>
<NumberOfWorkers>10</NumberOfWorkers>
<NumberOfInstances>1</NumberOfInstances>
<Triggers load="true">
</Triggers>
<Scheduler load="false"/>
<AutoStart load="false"/>
</Server>
</Servers>
</Project>
</Projects>
</Magicxpi_Startup>
[/XML]

 

[Natac]

Alles klar.

Erster Schritt:
Erstelle für jede Main-Methode je eine Klasse, und implementiere in dieser Klasse eine Methode, die genau das macht, was aktuell in der jeweiligen Main steht.

Zweiter Schritt:
Implementiere eine neue Klasse, die eine Methode hat, die das macht, was du aktuell machen möchtest.

Dritter Schritt:
Erzeuge von der Klasse aus Schritt 2 ein Objekt und rufe die Methode in der main auf.

Prinzipiell sollten in der main-Methode nur ein paar Zeilen stehen, die ei Objekt erzeugen und dann eine Methode darauf aufrufen. Funktionalität so "nakt" in die Main zu schreiben, ist nie eine gute Idee. Warum, siehst du ja gerade

 

[Kaibear]

Es funktioniert!

Vielen Dank!