我应该如何构建这个 set 方法？

Question

我正在制定一个飞机座位预订计划，并且我正在处理其中两个课程：乘客和座位。我想让 Seat 持有一个乘客对象，反之亦然，因为在程序中我希望能够打印一个带有乘客的座位列表，或者，如果没有乘客，打开，以及一个带有他们的乘客的列表对应座位。

当我将乘客插入座位时，我是否也应该在同一个 insertPassenger 方法中将座位插入乘客，还是应该按照 set 方法只做一件事的想法，分别调用这两个方法？此外，这种“乘客有座位”和“座位有乘客”的思维方式是否适合我的需求，还是有更好、更有效且耦合更少的方法？

public class Seat {
    private Passenger passenger;
    //more fields and constructor etc.
    public void insertPassenger(Passenger passenger) {
        this.passenger = passenger;
        passenger.setSeat(this); //is this line good or terrible?
    }
}

public class Passenger {
    //String names and stuff
    private Seat seat;
    //Seat is left uninitialized in constructor, is this a good idea?
    public Passenger(String firstName, String lastName) {
        this.firstName = firstName;
        this.lastName = lastName;
    }
    public void setSeat(Seat seat) {
        this.seat = seat;
    }
}

Answer 1

我不完全确定这是否适合你，但如果我这样做，我会这样做：

class Flight{
    Set<SeatPassangerMapping> seatPassangerMapping;
}

class SeatPassengerMapping{
    Seat seat;
    Passenger passenger;

    Flight flight;

    public boolean equals(Object obj){
        if(obj instance of SeatPassangerMapping){
            // right your logic here on the basis of flight
        }

        return false
    }

}

这是因为，一个乘客在不同的航班上会有不同的床单。

Answer 2

如果是我，我不会让座位成为对象。我会使用哈希图来保存乘客。像HashMap<String, Passenger> seats = new HashMap<String, Passenger>(); 这样的东西你可以分配座位：

Passenger person = Passenger("John", "Doe"); 
Passenger person2 = Passenger("Jane", "Doe"); 
seats.add("1A", person1);
seats.add("1B", person2); 

等等。然后，您可以使用键（座位）或值（乘客）来获取座位的值。

使用座位对象的问题在于您没有明确的座位值，并且您还可能有重复的值。很难判断1A座位是否被占用。通过使用 HashMap，您可以保证每个值都是唯一的，因为您只能拥有 1 个键。而不是有一个Seat 类，我会创建一个Flight 类。座位在 OOP 中并没有太大用处。座位就是有人坐的地方。它更有组织性。您对航班所做的一切都是基于Passenger 而不是基于座位。

但这只是您可以做到这一点的众多方法之一。

Answer 3

不使用 collections 包的简单解决方案，

class Passenger {

  private Seat seat;

  void setSeat (Seat s){
     this.seat = s;
  }

  assignSeat (Seat s){
     s.setPassenger(this)
     setSeat(s);
   }

}

这符合您让二传手只做一件事的标准。但是为了记录，setter 通常需要做不止一件事来维护类的不变量。

但您真正想做的是在乘客和座位之间建立关系。这称为映射。地图在收藏包中可用。它需要了解泛型，这超出了此答案的范围。

new HashMap<Passenger, Seat>  seatMap = new HashMap<>();


class Passenger {

    assignSeat(Seat seat){
       seatMap.put(this, seat);
    }
}

现在，当您想要列出所有乘客及其座位时，您可以使用类似代码

 for(Passenger p : seatMap.getKeys()){
     System.println("Passenger " + p + " is in seat " seatMap.getValue(p));
  }

我实际上并没有编译所有这些代码。但我认为它为您提供了映射含义的要点。这是一种单向映射。这意味着如果您认识乘客，您可以直接找到他们的座位。如果您知道座位，您可以不直接找到乘客。您必须搜索地图中的所有乘客才能找到有座位的乘客。更糟糕的是，在上面的代码中，没有什么能阻止您将乘客放在同一个座位上（除了检查每位乘客以确保该座位尚未被其他人占用）。但所有这些缺点都适用于我的第一个解决方案。

您真正需要的是 2 路地图。也许 Java 在 collections 包中有其中之一。 :)

Answer 4

您要查找的术语是循环依赖，甚至是循环引用。从另一个角度看this answer。

两张地图会很好用。这些将由包含人员和座位的任何东西拥有（例如，飞行类等）。这将充当双向映射（在第三方库中也可以作为实际集合类型使用），让您全面了解每个元素列表以及它们映射到的任何内容（如果有的话）。

由于您可能已经有一些数据源来确定这些链接是什么，因此您可以将其应用于这些地图。

// Linked in case you want to preserve insertion order
Map<Seat, Passenger> seatMap = new LinkedHashMap<>();
Map<Passenger, Seat> passengerMap = new LinkedHashMap<>();

//
// Populate the maps here.
//   
//   if a seat has no passenger: 
//   seatMap.put(seat, null);
//

void printSeats() {
    for (Map.Entry<Seat, Passenger> entry : seatMap.entrySet()) {
        Passenger passenger = entry.getKey();
        Seat seat = entry.getValue();
        // print the seat 
    }
}

void printPassengers() {
    for (Map.Entry<Passenger, Seat> entry : passengerMap.entrySet()) {
        Seat seat = entry.getKey();
        Passenger passenger = entry.getValue();
        // print the passenger
    }
}

Answer 5

我认为这件事不同（只是为了补充其他答案）：

您有一个航班，其中有座位和乘客，所以我要做的是实现航班类以添加座位-乘客逻辑。唯一的诀窍是您必须选择哪个乘客将是非座位：

1. （座位号，空）
2. （seatNumber，defaultPassenger，id=0，name=OPEN）

我选择了二：

乘客：

   public class Seat {
        private int seatNumber;

        public Seat ( )
        {

        }

        public Seat ( int seatNumber )
        {
            this.seatNumber = seatNumber;
        }
        /**
         * @return the seatNumber
         */
        public int getSeatNumber ( )
        {
            return seatNumber;
        }

        /**
         * @param seatNumber the seatNumber to set
         */
        public void setSeatNumber ( int seatNumber )
        {
            this.seatNumber = seatNumber;
        }

        @Override
        public String toString ( )
        {
            return "Seats [seatNumber=" + seatNumber + "]";
        }

        /* (non-Javadoc)
         * @see java.lang.Object#hashCode()
         */
        @Override
        public int hashCode ( )
        {
            final int prime = 31;
            int result = 1;
            result = prime * result + seatNumber;
            return result;
        }

        /* (non-Javadoc)
         * @see java.lang.Object#equals(java.lang.Object)
         */
        @Override
        public boolean equals ( Object obj )
        {
            if ( this == obj )
                return true;
            if ( obj == null )
                return false;
            if ( getClass ( ) != obj.getClass ( ) )
                return false;
            Seat other = ( Seat ) obj;
            if ( seatNumber != other.seatNumber )
                return false;
            return true;
        }



    }

座位：

public class Seat {
    private int seatNumber;

    public Seat ( )
    {

    }

    public Seat ( int seatNumber )
    {
        this.seatNumber = seatNumber;
    }
    /**
     * @return the seatNumber
     */
    public int getSeatNumber ( )
    {
        return seatNumber;
    }

    /**
     * @param seatNumber the seatNumber to set
     */
    public void setSeatNumber ( int seatNumber )
    {
        this.seatNumber = seatNumber;
    }

    @Override
    public String toString ( )
    {
        return "Seats [seatNumber=" + seatNumber + "]";
    }

    /* (non-Javadoc)
     * @see java.lang.Object#hashCode()
     */
    @Override
    public int hashCode ( )
    {
        final int prime = 31;
        int result = 1;
        result = prime * result + seatNumber;
        return result;
    }

    /* (non-Javadoc)
     * @see java.lang.Object#equals(java.lang.Object)
     */
    @Override
    public boolean equals ( Object obj )
    {
        if ( this == obj )
            return true;
        if ( obj == null )
            return false;
        if ( getClass ( ) != obj.getClass ( ) )
            return false;
        Seat other = ( Seat ) obj;
        if ( seatNumber != other.seatNumber )
            return false;
        return true;
    }



}

航班：

import java.util.HashMap;

public class Flight
{
    private HashMap<Seat, Passenger>  seatMap;


    public Flight(int numberOfSeats)
    {
        seatMap = new HashMap<>();

        for(int i = 1; i <= numberOfSeats; i++)
        {
            seatMap.put ( new Seat ( i ) , new Passenger ( ) );
        }
    }

    /**
     * @return the seatMap
     */
    public HashMap < Seat , Passenger > getSeatMap ( )
    {
        return seatMap;
    }


    /**
     * @param seatMap the seatMap to set
     */
    public void setSeatMap ( HashMap < Seat , Passenger > seatMap )
    {
        this.seatMap = seatMap;
    }

    public void sitPassenger (int seatNumber, Passenger passenger)
    {
        seatMap.put ( new Seat ( seatNumber ) , passenger );
    }

    @Override
    public String toString ( )
    {
        return "Flight [seatMap=" + seatMap + "]";
    }

}

主类：

public class mainProgram
{
    public static void main(String args [])
    {
        //set number of seats
        Flight myFlight = new Flight ( 3 );
        //first passenger
        Passenger firstP = new Passenger ( );
        firstP.setSocialNumber ( 19993 );
        firstP.setName ( "John" );
        //second passenger
        Passenger secondP = new Passenger ( );
        secondP.setSocialNumber ( 19994 );
        secondP.setName ( "Brian" );
        //sit them
        myFlight.sitPassenger ( 1 , firstP );
        myFlight.sitPassenger ( 2 , secondP );
        //output
        System.out.println ( myFlight.toString ( ) );
    }
}

输出：

航班 [seatMap={

座位 [seatNumber=1]=乘客 [socialNumber=19993, name=John]，

座位 [seatNumber=2]=乘客 [socialNumber=19994, name=Brian]，

座位 [seatNumber=3]=乘客 [socialNumber=0, name=OPEN]

}]

这个解决方案允许在不同的航班（座位）上拥有相同的乘客，这是飞机座位预留计划应该做的，恕我直言。