Parameter-Übergabe bei Klassen und Methoden

Hallo zusammen,

Ich habe eine Frage zur Weitergabe von Parameter einer Methode. Ich habe eine Instanz Maze mit der Methode boolean isWall(int direction). Die Instanz beinhaltet darüberhinaus eine final class Direction mit den beiden Variable RIGHT und LEFT.
Dazu mein Code:
Java:
public interface Maze {
     final class Direction {
         public static final int RIGHT = 1;
         public static final int LEFT = 2;
     }
boolean isWall(int direction);
}
In einer anderen Klasse, Explorer, möchte ich in der Methode istPlatz(Maze garten) auf die Methode isWall() zugreifen.
Java:
public class Explorer {

public static boolean istPlatz(Maze garten){
  /* 1. Möglichkeit */  if(garten.isWall(Maze.Direction.RIGHT & Maze.Direction.LEFT)){...}
 /* oder 2. Möglichkeit */  if(garten.isWall(Maze.Direction.Right) & garten.isWall(Maze.Direction.LEFT){...}
}
}
Meine Frage: Kann ich die Parameter mit beiden Möglichkeiten übergeben oder kann ich nur die 2. Möglichkeit nutzen? Bei der 1. Möglichkeit spare ich mit dadurch sehr viel Schreibarbeit. Ich möchte nämlich durch das "&" beide directions (Rechts und Links) in einer if-Bedingung überprüfen.
Danke für jeden Hinweis :).

PS: Als Anfänger habe ich evtl. nicht die richtigen Begriffe verwendet: sorry dafür.
 
Alles klar vielen Dank für die schnelle Antwort.
Stimmt, du hast recht. Ich war mir unsicher ob & oder && aber Letzteres macht mehr Sinn.
Wie hast du das &-Symbol hervorgehoben? (Bestimmt nützlich für zukünftige Fragen) danke
 
Du kannst natürlich mittels Bit-Operationen int-Werte verknüpfen, dann aber mit | und nicht mit &. D. h. theoretisch würde das funktionieren, was Du vorhast, das ist aber äußerst low-level und für den Fall auch unpraktisch, außer Du hast Deine Wege im Labyrinth schon derart kodiert.

Besser: verwende eine Methode isWall(Direction ... dir), dann kannst Du mehrere Direction-Objekte oder ein Direction-Array als Parameter übergeben. Für Direction böte sich ein enum an.
 
Auch, wenn ich @mihe7 natürlich absolut Recht gebe, was die Vermeidung von Low-Leveligkeit? in Java angeht und sauberer und verständlicher Code in den allermeisten Fällen absoluten Vorrang vor vielleicht den einen oder anderen Microsekunden Performancegewinn hat, so finde ich es ab und an schade, dass Dinge wie Bitmasken und Bitshifts, die in C allgegenwärtig sind, bei Java-Entwickler meist auf Unkenntnis stoßen. :)
Ich erinnere noch an eine Situation, da hatte ich mal keine Enums verwendet, sondern die typischen "power-of-two" Bitshifts (1<<0, 1<<1, 1<<2, ...) mit Bit-UND und -ODER um Set-Operationen auf diesen "Enums" zu berechnen. Drei Java-Entwickler saßen anschließend rätselnd vor dem Code... ja, ich hätte wohl lieber Enums und das gute EnumSet verwenden sollen. :)
 
@mihe7 vielen Dank für den Tipp.
Besser: verwende eine Methode isWall(Direction ... dir), dann kannst Du mehrere Direction-Objekte oder ein Direction-Array als Parameter übergeben. Für Direction böte sich ein enum an.
Leider sind diese Methode und die Typen für Direction vorgegeben und ich darf sie nicht ändern.
 
Leider sind diese Methode und die Typen für Direction vorgegeben und ich darf sie nicht ändern.
Na, und?

Variante 1: Methode in Explorer
Java:
private boolean hasWall(int ... directions) {
    for (int dir : directions) {
        if (garten.isWall(dir)) {
            return true;
        }
    }
    return false;
}
bzw. als statische Variante:
Java:
private static boolean hasWall(Maze garten, int ... directions) {
    for (int dir : directions) {
        if (garten.isWall(dir)) {
            return true;
        }
    }
    return false;
}
Variante 2: als Maze-Decorator
Java:
class AmazingMaze implements Maze {
    private final Maze maze;

    public AmazingMaze(Maze maze) { this.maze = maze; }
    
    public boolean isWall(int dir) { return maze.isWall(dir); }

    public boolean hasWall(int ... directions) {
        for (int dir : directions) {
            if (isWall(dir)) {
                return true;
            }
        }
        return false;
    }
}
Verwendung:
Java:
AmazingMaze maze = new AmazingMaze(garten);
if (maze.hasWall(Maze.Direction.LEFT, Maze.Direction.RIGHT)) {
    ...
}
 
@mihe7 vielen Dank für die Alternativen. Variante 2 finde ich am "schönsten". Leider ist das für meinen Anwendungsfall dann doch zu kompliziert, sodass ich letztendlich bei meiner 2. Möglichkeit geblieben bin. Trotzdem Danke ;)
 
Ich hätte doch nochmal eine ähnliche Frage.
Kann ich in einer If-Bedingung mehrere Möglichkeiten von &-Kombinationen durch || trennen? Bsp.:
Java:
if (aktView == 2 & nextStep == 1 || aktView == 1 & nextStep == 4 || aktView == 3 & nextStep = 2 || aktView == 4 & nextStep == 3){
    x=x-1;
}
Ich möchte also x um 1 verringern, sobald eine der &-Kombinationen true ist.
Geht das?
Danke schonmal :)
 
Passende Stellenanzeigen aus deiner Region:

Neue Themen

Oben