Methoden aus anderer classe über nehmen

[Fansana]

Hallo liebe Java Forum,
Ich bin seit einiger Zeit hobby Programmierer und möchte jetzt gerne in die Java Programmierung einsteigen.
Nun habe ich aber eine Frage und mein Freund Google scheint mir dabei auch nicht weiterhelfen zu können
(Zumindest unter den Begriffen unter denen ich gesucht habe.)

Kann ich Methoden aus einer anderen Classe übernehmen?
Dies funktioniert mit extends ich weiß aber nehmen wir an ich habe ein GameObject.

public abstract class GameObject{
    protected Point position;
    protected Point renderPosition;

    public GameObject(Point position){

    this.position = new Point(position);
    
    }
    public void dooSomeStuff(int doo, int stuff){
    int some = doo + stuff;
    }

}

Eine Classe in der methoden stehen um das Object zu bewegen.

public class Moveable{

    public void moveTo(int x, int y){
    ...
    }
    public void move(){
    ...
    }
}

und dann die Player Classe die ein Gameobject ist

public class Player extends GameObject{
    public Player(Point position){
    super(position);
    dooSomeStuff(19,12);
    moveTo(2,1);
    }

}

Nun das würde Natürlich nicht funktionieren, Player hat keinen zugriff auf moveTo() aus der Moveable Classe.
Die Frage wie bekomme ich das hin das Player doch auf moveTo zugreifen kann?
Das ganz würde ich gerne Wissen damit ich nicht bei jedem child von GameObject das sich bewegen kann die Funktionen neu Schreiben muss. Sowas macht die Übersichtlichkeit kaputt.

 

[Fansana]

Achso vieleich kann mir noch jemand ein Buch oder Webseite ans Herz legen mit dem ich schneller und besser zum einem Experten werden kann. Ich finde es giebt viele Tutorials für Java Anfänger aber ich suche nach etwas wo schon weiterführender kram drinne bearbeited wird.

 

[Saheeda]

Du kannst zwar nur von einer Klasse erben, aber mehrere Interfaces implementieren.

Mir scheint aber dein Klassenkonzept noch etwas undurchdacht und wirr.

 

[Fansana]

klar ich kann Interfaces einbinden aber danach suche ich nicht Interfaces zwingen mich doch nur bestimmte methoden zu implementieren. Ich möchte gerne wie bei extends methoden ans child weiter erben.

 

[Saheeda]

Wie wäre es mit ner Instanz der Klasse Moveable in der GameObject-Klasse, über welche du die Methoden aufrufst? Deine Moveable-Methoden könnten dann z.B. die neuen Koordinaten zurückgeben.

 

[Fansana]

kannst du mir dazu ein Code beispiel geben?

 

[Saheeda]

abstract class GameObject{
	protected Moveable mover = new Moveable();
}

class Moveable{
	
	public Point doSome(){}
}

class Player extends GameObject{
	
	public void doElse(){
		mover.doSome();
	}	
}

Wo du die Moveable-Instanz deklarierst, hängt auch davon ab, wie oft in der GameObject-Klasse sie gebraucht wird. Nur einmal --> deklariere sie in der benötigten Methode und gut ist.
Mehrmals --> global als privates Feld oder von GameObject geerbt, aber dann würde ich sie in GameObject wenigstens protected setzen.

 

[Fansana]

Ah, Ich glaube ich bin selber auf die Lösung gestoßen.

class abstract GameObject {
    protected Point position;
}
class abstract Moveable extends GameObject{
    public void moveTo(){
    //Code to calculate the Movement
    }
    public void move(){
    //moving 
    
    }
}
class Player extends Player{
    public void tick(){
        move();
    }
}

So muss ich die methoden nicht in jedem Child von GameObject deklarieren und Player ist trotzdem noch eine Instanz von GameObject.

 

[kaoZ]

Das ganze könnte hierarchisch auch so aufgebaut werden , indem man halt doch einfach ein Interface verwendet, hier kannst du dir die Unterklasse insofern du diese nicht benötigst auch weglassen ( MoveableGameObject )

abstract class GameObject{
	protected int x;
	protected int y;
}

interface Moveable{
	
	void move(int x, int y);
}

class MoveableGameObject extends GameObject implements Moveable{
	
	@Override
	public void move(int x, int y){
		this.x = x;
		this.y = y;
	}
}

class Player extends MoveableGameObject{
	
	@Override
	public void move(int x, int y){
		super.move(x, y);
//		platz für weiterführende Implementierung der Methode
	}
}

rein als fiktives Beispiel könnte man dann einfach folgendes machen und die ganzen Beweglichen Objekte in einer map sammeln ,

	public static void main(String[] args){

		HashMap<String, Moveable> moveables = new HashMap<>();
		
		Moveable m = new Player();
		moveables.put("Player", m);
		
		for (Entry<String, Moveable> entry: moveables.entrySet()) {
			entry.getValue().move(20, 20);
		}
	}

ich habe hier einfach zur veranschaulichung nur die move methode gewählt , richtig wäre dann hier natürlich moveTo(int x, int y), aber ich hoffe es wird klar worauf ich hinaus wollte, du kannst so auf einer viel höheren Abstraktionsebene arbeiten 🙂

Zudem hat sich hier bei dir ein kleiner Fehler eingeschlichen ^^ :

class Player extends Player{
    public void tick(){
        move();
    }
}

 

[Fansana]

Super, Danke für die tolle und Hilfreiche erklärung 😀.
Die Methode die du beschreibst würde mir auch noch die Möglichkeit lassen Instanzen die Moveable implementieren, aber kein Child von MoveableGameObject sind zu erstellen.
I hoffe ich liege damit richtig.

 

[kaoZ]

Jede Klasse die das Moveable interface implementiert ist dazu "gezwungen" wie bei einem bindenden Kontrakt, die methoden des Interfaces zu implementieren, was genau dann passiert ist der jeweiligen spezialisierung selbst überlassen.

so kann z.B ein MoveableGameObject zwar beweglich, ohne Steuerbar zu sein , wie eben der Player

nehmen wir an du hättest noch ein Controllable Interface, welches nur von der Klasse Player implementiert wird:

das hier ist eine rein rudimentäre implementierung !

interface Controllable{
	void controll(KeyEvent event);
}

class Player extends MoveableGameObject implements Controllable{
	
	@Override
	public void controll(KeyEvent event){
		if(event.getKeyCode() == KeyEvent.VK_A) {
			move(20, 50);
		}
	}
	
	@Override
	public void move(int x, int y){
		super.move(x, y);
//		platz für weiterführende Implementierung der Methode
	}
}

Diese könnte dann z.B die move() methode aufrufen , und der spieler wäre ein "Steuerbares" GameObjekt während ein Objekt(Instanz) einer eventuell vorhandenen Klasse "Block" oder "MoveableBlock" zwar beweglich , jedoch nicht Steuerbar ist.

Und trotzdem sind alles GameObjekte bzw. Intanzen von klassen welche das Moveable Interface implementieren.

So kannst du unter verwendung von instanceof prüfungen später unterscheiden für welche art von Objekt, Aktionen durchgeführt werden sollen und für welche nicht.

Genau dafür sind Schnittstellen ( Interfaces ) gedacht ( zur Kommunikation zwischen Klassen / auf einer möglichst Abstrakten Ebene ) , es reicht dann die Schnittstelle nach außen zu kennen, ohne zu wissen welche eigentliche Spezialisierung dahinter steckt , das übernehmen dann die Klassen alle für sich, sprich dem "Aufrufer" kann es vollkommen egal sein was sich am ende wohin bewegt, es weiß nur das diese Funktion zur verfügung steht und es "ruft" diese auf.