Rollen verändern, Interfaces austauschen wie?

[skuki]

Hallo,

ich stehe gerade vor einem lästigen Problem, für das ich leider noch nichts passendes gefunden habe :rtfm:


Ich habe eine Roboterklasse von der es zwei verschiedene Typen gibt.

JumpRoboter (zählt Sprünge) und Driveroboter(zählt Weglänge). (Soweit so gut)

Diese Jump bzw. Driveroboter können jetzt aber noch verschiedene Aufsätze erhalten. Bei diesen Aufsätzen handelt es sich entweder um eine Kamera (int Pixel kommt hier hinzu) oder um einen Bohrer (double length) kommt hinzu.

Jetzt denke ich man wird dass mit einem Interface schön lösen können, jedoch kann man die Aufsätze auch austauschen.

Ein JumpRoboter mit Kamera, darf aber keine Bohrerlänge besitzen und umgekehrt, daher kann ich auch nicht im Vorhinein beide Variablen in eine Klasse geben.


Jetzt war ich so dreist und unerfahren dass ich einfach eine adoptTo() Methode geschrieben habe die ein neues Objekt der anderen Klasse erstellt und sie der alten Referenz zum Überschreiben mitgibt. Funktioniert natürlich nicht


Wie löst man dieses Problem?

Vielen vielen Dank!!

 

[Gucky]

Du könntest eine abstrakte Klasse AbstractAufsatz oder ein Interface Aufsatz erstellen. Diese Klasse oder dieses Interface bietet alle Methoden, die es bei beiden Aufsätzen gibt, sodass die Roboter gar nicht wissen, was sie da eigentlich für einen Aufsatz haben.
Wenn sich die beiden Aufsätze doch so stark unterscheiden, kannst du noch mit instanceof überprüfen, welchen Aufsatz die Roboter haben und somit aufsatzspezifische Methoden aufrufen.

Wie du das machst, dass ein Roboter keine zwei Aufsätze hat: Es gibt nur eine Variable, die einen Aufsatz enthalten kann.

 

[skuki]

Danke das ist schon mal ein guter Tipp.

Das Problem ist dass es diese 4 Klassen geben muss.

JumpingRobotDrill
JumpingRobotCamera
DrivingRobotDrill
DrivingRobotCamera


Alle diese Roboter werden in einer Raumsonde gespeichert und über diese können die "Aufsätze" ausgetauscht werden.

Nur wie soll eine Klasse x zur Klasse y werden?

Oder den Listenplatz X1 einfach mit der neuen Klasse mit der gleichen ID überschreiben?

 

[kaoZ]

Ich weiß nicht ob ich dich richtig verstanden habe , demnach auch nicht ob dir das hier weiterhilft , hier mal unter verwendung von interface und abstrakter klasse :

public class Test{

	interface Robot {
		void action();
	}
	
	abstract class DefaultRobot implements Robot {}
	
	class JumpRobot extends DefaultRobot{

		@Override
		public void action(){
			System.out.println("ich springe");
		}
	}
	
	class DrillRobot extends DefaultRobot{
		
		@Override
		public void action(){
			System.out.println("ich bohre");
		}
	}
	
	public static void main(String[] args){
		Robot r = new Test().new DrillRobot();
		
		Robot x = new Test().new JumpRobot();
		
		r.action();
		
		x.action();
	}
}

du könntest hier auch der action methode einfach eine variable mitgeben , die dann jeweils entweder die tiefe beim bohren oder die höhe beim springen angibt.

{EDIT : ihr wart schneller als ich ^^}

Nur wie soll eine Klasse x zur Klasse y werden?

Garnicht , aber wie gucky schon erwähnt hat kannst du per instanceof prüfen von welcher Spezialisierung die instanz ist ,und dann dementsprechend Downcasten und dann die jeweilige methode aufrufen

oder du verwendest halt einfach das command pattern / eine abhandlung davon , dann gibt es wie in meinem Beispiel z.B einfach nur eine action methode

 

[skuki]

Bitte tausche jetzt den DrillRobo in einen JumpRobo damit ich das verstehe

Garnicht , aber wie gucky schon erwähnt hat kannst du per instanceof prüfen von welcher Spezialisierung die instanz ist ,und dann dementsprechend Downcasten und dann die jeweilige methode aufrufen

Bei downcasten steige ich leider aus

EDIT:
Commant Pattern seh ich mir gleich an, das war am Anfang noch nicht da ^^

 

[Gucky]

Muss es unbedingt so sein?
Wenn es unbedingt so sein muss, kannst du auch ein Interface/eine abstrake Klasse DrivingRobotAufsatz und DrillingRobotAufsatz erstellen.

Warum speicherst du die Aufsätze in einer Liste?

 

[kaoZ]

Also nach dem Adapter-Pattern kannst/könntest du das ganze auch so machen :

Robot.java

public class Robot{

	private Adapter adapter;
	
	public Robot(Adapter a){
		adapter = a;
	}
	
	public void doWork(){
		adapter.doWork();
	}
	
	public void changeAdapter(Adapter a){
		adapter = a;
	}
}

Das Interface Adapter:

public interface Adapter{

	void doWork();
}

Eine konkrete implementierung könnte dann so aussehen :

public class DrillAdapter implements Adapter{

	@Override
	public void doWork(){
		System.out.println("jetzt bohre ich!");
	}
}

oder auch so:

public class JumpAdapter implements Adapter{

	@Override
	public void doWork(){
		System.out.println("Jetzt springe ich !");
	}
}

und das ganze ließe sich dann so benutzen :

public class Test{
	
	public static void main(String[] args){
		Robot r = new Robot(new JumpAdapter());
		
		r.doWork();
		
		r.changeAdapter(new DrillAdapter());
		
		r.doWork();
	}
}

ausgabe wäre dann logischerweise :

Jetzt springe ich !
jetzt bohre ich!

Zum Thema Downcast, du musst wenn du z.B in einer Methode einen Supertyp übergibst und oder eben erwartest, und dann mehrere Funktion und oder zwischen spezialisierungen unterscheiden möchtest, prüfen welche Spezialisierung übergeben wurde, dies kannst du dann per

instanceof

und oder in eingigen fällen per

.getClass();

machen , und dann das Interface auf eben eine dieser spezialisierungen casten, damit dir die jeweiligen methoden zur verfügung stehen insofern nicht in der Superklasse / dem Interface vorhanden.

Hier müsste dann ein Cast auf die konkrete implementierung stattfinden damit z.B eine methode ausgeführt werden kann die nur in der klasse HalloWelt existiert, und die der Superklasse oder dem Interface nicht bekannt ist.

Setzt vorraus das HalloWelt das Interface MeinInterface implementiert :

public void work(MeinInterface i){
  if(i instanceof HalloWelt){
     HalloWelt w = (HalloWelt) i;

     w.sayHello();
  }
}

 

[kaoZ]

Letzten endes gibt es unzählige wege dein konkretes Problem zu lösen, ob mit dekorator, command oder Adapter pattern , oder mit einer eigenen Intuitiven lösung bleibt dann ganz dir überlassen.

Eine art Dekorator könnte z.B so aussehen :

public class JumpRobot{

	private Robot robot;
	
	public JumpRobot(Robot r){
		robot = r;
	}
	
	void jump(int height){
		System.out.println("wuhu !");
	}
}

hier wird einfach ein Robot entgegen genommen und um die Funktionalität des springens erweitert.

public class Test{
	
	public static void main(String[] args){
		Robot r = new Robot(new JumpAdapter());
		
		r.doWork();
		
		r.changeAdapter(new DrillAdapter());
		
		r.doWork();
		
//		Robot konstruktor ohne adapter !
		JumpRobot j = new JumpRobot(new Robot()); 
		j.jump(20);
	}
}

 

[Gucky]

@kaoZ
Kennst du denn jedes Pattern, dass sich irgendjemand mal ausgedacht hat?

 

[kaoZ]

Zumindest einen Teil der gängigsten , alle kann man glaube ich nicht kennen xD

Ich habe mich da mal durch Design pattern - von Kopf bis Fuß gelesen, da konnte ich ein bisschen was von behalten ^^

 

[Gucky]

Das wäre wohl auch ein bisschen zu viel verlangt.

Ah. Das erklärt das du ständig die Namen von diesen Patterns kennst.