Можно ли вернуть несколько предметов за один звонок?

Question

возможно ли, чтобы следующий элемент возвратил несколько элементов за один вызов (т.е. два GRects)

    private GObject getColidingObject(){
    if(getElementAt(ball.getX(), ball.getY()) != null){
        return getElementAt(ball.getX(), ball.getY());
    }else if(getElementAt(ball.getX() + BALL_RADIUS *2, ball.getY()) != null){
        return getElementAt(ball.getX() + BALL_RADIUS *2, ball.getY());
    }else if(getElementAt(ball.getX(), ball.getY() + BALL_RADIUS *2) != null){
        return getElementAt(ball.getX(), ball.getY() + BALL_RADIUS *2);
    }else if(getElementAt(ball.getX() + BALL_RADIUS *2, ball.getY() + BALL_RADIUS *2) != null){
        return getElementAt(ball.getX() + BALL_RADIUS *2, ball.getY() + BALL_RADIUS *2);
    }else{
        return null;
    }
}

Answer 1

Вы можете вернуть только одно значение, но вы можете сделать это значение массивом. Например:

private GObject[] getCollidingObjects() {
    GObject[] ret = new GObject[2];

    ret[0] = ...;
    ret[1] = ...;
    return ret;
}

Кстати, когда вы начинаете многократное использование одного и того же выражения в одном и том же методе, вам следует подумать о введении локальной переменной для ясности. Например, рассмотрите это вместо своего исходного кода:

private GObject getCollidingObject(){
    int x = ball.getX();
    int y = ball.getY();
    if (getElementAt(x, y) != null) {
        return getElementAt(x, y);
    }
    if (getElementAt(x + BALL_RADIUS * 2, y) != null) {
        return getElementAt(x + BALL_RADIUS * 2, y);
    }
    if (getElementAt(x, y + BALL_RADIUS * 2) != null) {
        return getElementAt(x, y + BALL_RADIUS * 2);
    }
    if (getElementAt(x + BALL_RADIUS * 2, y + BALL_RADIUS * 2) != null) {
        return getElementAt(x + BALL_RADIUS * 2, y + BALL_RADIUS * 2);
    }
    return null;
}

(Вы можете сделать то же самое для x + BALL_RADIUS * 2 и y + BALL_RADIUS * 2.)

Вы также можете рассмотреть что-то вроде этого:

private GObject getCollidingObject(){
    int x = ball.getX();
    int y = ball.getY();
    return getFirstNonNull(getElementAt(x, y),
        getElementAt(x + BALL_RADIUS * 2, y),
        getElementAt(x, y + BALL_RADIUS * 2),
        getElementAt(x + BALL_RADIUS * 2, y + BALL_RADIUS * 2));
}

private static getFirstNonNull(GObject... objects) {
    for (GObject x : objects) {
        if (x != null) {
            return x;
        }
    }
    return null;
}

(В C # есть лучший способ сделать это с помощью оператора объединения нулей, но не берите в голову ...)

Answer 2

Нет, можно вернуть только один предмет из звонка. В опубликованном вами коде будет выполняться только одна из строк getElementAt. * ​​1001 *

Answer 3

Вы спрашиваете, может ли ваша функция возвращать несколько объектов?

Я думаю, что самое простое, что нужно сделать, это вернуть список или массив объектов в вашей функции.

Answer 4

Понравилась коллекция GObject?

private List<GObject>getColidingObject(){
    ...
    List<GObject> colidingObjects = new ArrayList<GObject>();
    colidingObjects.add(...);
    return colidingObjects;
}

Answer 5

Да и нет. Короткий ответ - не то, как вы пытаетесь это сделать.

Если вы хотите вернуть «две» вещи, вы можете инкапсулировать их в один объект, который можно вернуть как одну сущность.

Например, карта или любая другая коллекция должны помочь. Альтернативно, вы можете вернуть массив.

Answer 6

Просто верните массив из двух GRect с.

Answer 7

Вы можете вернуть массив или список GRects. Или, возможно, укажите пустой массив или список, который метод может заполнить.

Answer 8

Простой ответ - «Нет», вы можете иметь только одно возвращаемое значение.

Но большинство плакатов правы, говоря, что вы можете использовать коллекции, чтобы вернуть несколько вещей. Я замечаю, что большинство, кажется, выступает за возвращение либо списка, либо объекта коллекции, что, безусловно, работает, но если ваша проблема изолирована внутри конкретного класса, который вы разрабатываете, вы можете также рассмотреть возможность определения внутреннего класса удобства, чтобы сделать ваш жизнь проще Это абсолютно умопомрачительный пример, но, надеюсь, он поможет понять:

public class InnerClassDemo
{
    public static void main(final String[] args)
    {
        InnerClassDemo icd = new InnerClassDemo();

        Holder h = icd.getTwoRandomValues();
        System.out.println("Value 1 = " + h.getVal1());
        System.out.println("Value 2 = " + h.getVal2());
    }

    public Holder getTwoRandomValues()
    {
        Random r = new Random();

        int x = r.nextInt();
        int y = r.nextInt();

        return(new Holder(x,y));
    }

    private class Holder
    {
        private int val1;
        private int val2;

        public Holder()
        {
            this.val1 = 0;
            this.val2 = 0;
        }

        public Holder(int val1,int val2)
        {
            this.val1 = val1;
            this.val2 = val2;
        }

        public int getVal1()
        {
            return this.val1;
        }

        public void setVal1(int val1)
        {
            this.val1 = val1;
        }

        public int getVal2()
        {
            return this.val2;
        }

        public void setVal2(int val2)
        {
            this.val2 = val2;
        }
    }
}

Так что в вашем случае просто создайте внутренний класс, который содержит пару GRects, если одновременная передача двух GRects будет для вас обычной операцией.

Answer 9

Да, но это будет кошмаром для кого-то, чтобы поддерживать в производственной среде.

Answer 10

Если вы хотите вернуть более одного элемента одного типа, вы всегда можете вернуть коллекцию этих объектов. Если вы всегда будете возвращать два объекта, массив может быть лучше, потому что он дает вам быстрый сортированный доступ к объектам.

Если у вас много значений и вам нужно их вернуть, вам, возможно, потребуется ввести новый тип объекта для хранения всех значений и возврата этого объекта. Это очень хороший намек на то, что вам рано или поздно понадобится этот объект для перемещения данных в вашем приложении, если вы встретите много массивов, списков промежуточных или пар