Ik probeer 2 waarden van een Java-methode te retourneren, maar ik krijg deze fouten. Hier is mijn code:
// Method code
public static int something(){
int number1 = 1;
int number2 = 2;
return number1, number2;
}
// Main method code
public static void main(String[] args) {
something();
System.out.println(number1 + number2);
}
Fout:
Exception in thread "main" java.lang.RuntimeException: Uncompilable source code - missing return statement
at assignment.Main.something(Main.java:86)
at assignment.Main.main(Main.java:53)
Java-resultaat: 1
Antwoord 1, autoriteit 100%
In plaats van een array te retourneren die de twee waarden bevat of een generieke klasse Pairte gebruiken, kunt u overwegen een klasse te maken die het resultaat vertegenwoordigt dat u wilt retourneren, en een instantie van die klasse retourneren. Geef de klas een betekenisvolle naam. De voordelen van deze benadering ten opzichte van het gebruik van een array zijn typeveiligheid en het zal uw programma veel gemakkelijker te begrijpen maken.
Opmerking: een generieke klasse Pair, zoals voorgesteld in sommige van de andere antwoorden hier, geeft u ook typeveiligheid, maar geeft niet weer wat het resultaat voorstelt.
Voorbeeld (dat geen echt betekenisvolle namen gebruikt):
final class MyResult {
private final int first;
private final int second;
public MyResult(int first, int second) {
this.first = first;
this.second = second;
}
public int getFirst() {
return first;
}
public int getSecond() {
return second;
}
}
// ...
public static MyResult something() {
int number1 = 1;
int number2 = 2;
return new MyResult(number1, number2);
}
public static void main(String[] args) {
MyResult result = something();
System.out.println(result.getFirst() + result.getSecond());
}
Antwoord 2, autoriteit 29%
Java ondersteunt geen retourzendingen met meerdere waarden. Retourneer een reeks waarden.
// Function code
public static int[] something(){
int number1 = 1;
int number2 = 2;
return new int[] {number1, number2};
}
// Main class code
public static void main(String[] args) {
int result[] = something();
System.out.println(result[0] + result[1]);
}
Antwoord 3, autoriteit 18%
U zou een generiek Pairkunnen implementeren als u zeker weet dat u slechts twee waarden hoeft te retourneren:
public class Pair<U, V> {
/**
* The first element of this <code>Pair</code>
*/
private U first;
/**
* The second element of this <code>Pair</code>
*/
private V second;
/**
* Constructs a new <code>Pair</code> with the given values.
*
* @param first the first element
* @param second the second element
*/
public Pair(U first, V second) {
this.first = first;
this.second = second;
}
//getter for first and second
en laat dan de methode teruggeven dat Pair:
public Pair<Object, Object> getSomePair();
Antwoord 4, autoriteit 11%
Je kunt in Java maar één waarde retourneren, dus de handigste manier is als volgt:
return new Pair<Integer>(number1, number2);
Hier is een bijgewerkte versie van uw code:
public class Scratch
{
// Function code
public static Pair<Integer> something() {
int number1 = 1;
int number2 = 2;
return new Pair<Integer>(number1, number2);
}
// Main class code
public static void main(String[] args) {
Pair<Integer> pair = something();
System.out.println(pair.first() + pair.second());
}
}
class Pair<T> {
private final T m_first;
private final T m_second;
public Pair(T first, T second) {
m_first = first;
m_second = second;
}
public T first() {
return m_first;
}
public T second() {
return m_second;
}
}
Antwoord 5, autoriteit 4%
Hier is de echt eenvoudige en korte oplossing met SimpleEntry:
AbstractMap.Entry<String, Float> myTwoCents=new AbstractMap.SimpleEntry<>("maximum possible performance reached" , 99.9f);
String question=myTwoCents.getKey();
Float answer=myTwoCents.getValue();
Gebruikt alleen ingebouwde Java-functies en wordt geleverd met het type veiligheidsvoordeel.
Antwoord 6, autoriteit 2%
je moet collecties gebruiken om meer dan één retourwaarde te retourneren
in jouw geval schrijf je je code als
public static List something(){
List<Integer> list = new ArrayList<Integer>();
int number1 = 1;
int number2 = 2;
list.add(number1);
list.add(number2);
return list;
}
// Main class code
public static void main(String[] args) {
something();
List<Integer> numList = something();
}
Antwoord 7, autoriteit 2%
Gebruik een Pair/Tuple type object , je hoeft er niet eens een te maken als je afhankelijk bent van Apache commons-lang. Gebruik gewoon het paarklas.
Antwoord 8, autoriteit 2%
public class Mulretun
{
public String name;;
public String location;
public String[] getExample()
{
String ar[] = new String[2];
ar[0]="siva";
ar[1]="dallas";
return ar; //returning two values at once
}
public static void main(String[] args)
{
Mulretun m=new Mulretun();
String ar[] =m.getExample();
int i;
for(i=0;i<ar.length;i++)
System.out.println("return values are: " + ar[i]);
}
}
o/p:
return values are: siva
return values are: dallas
Antwoord 9
U hoeft uw eigen klasse niet te maken om twee verschillende waarden te retourneren. Gebruik gewoon een HashMap zoals deze:
private HashMap<Toy, GameLevel> getToyAndLevelOfSpatial(Spatial spatial)
{
Toy toyWithSpatial = firstValue;
GameLevel levelToyFound = secondValue;
HashMap<Toy,GameLevel> hm=new HashMap<>();
hm.put(toyWithSpatial, levelToyFound);
return hm;
}
private void findStuff()
{
HashMap<Toy, GameLevel> hm = getToyAndLevelOfSpatial(spatial);
Toy firstValue = hm.keySet().iterator().next();
GameLevel secondValue = hm.get(firstValue);
}
Je hebt zelfs het voordeel van typeveiligheid.
Antwoord 10
Ik ben benieuwd waarom niemand de elegantere callback-oplossing heeft bedacht. Dus in plaats van een retourtype te gebruiken, gebruik je een handler die als argument aan de methode is doorgegeven. Het onderstaande voorbeeld heeft de twee contrasterende benaderingen. Ik weet welke van de twee voor mij het meest elegant is. 🙂
public class DiceExample {
public interface Pair<T1, T2> {
T1 getLeft();
T2 getRight();
}
private Pair<Integer, Integer> rollDiceWithReturnType() {
double dice1 = (Math.random() * 6);
double dice2 = (Math.random() * 6);
return new Pair<Integer, Integer>() {
@Override
public Integer getLeft() {
return (int) Math.ceil(dice1);
}
@Override
public Integer getRight() {
return (int) Math.ceil(dice2);
}
};
}
@FunctionalInterface
public interface ResultHandler {
void handleDice(int ceil, int ceil2);
}
private void rollDiceWithResultHandler(ResultHandler resultHandler) {
double dice1 = (Math.random() * 6);
double dice2 = (Math.random() * 6);
resultHandler.handleDice((int) Math.ceil(dice1), (int) Math.ceil(dice2));
}
public static void main(String[] args) {
DiceExample object = new DiceExample();
Pair<Integer, Integer> result = object.rollDiceWithReturnType();
System.out.println("Dice 1: " + result.getLeft());
System.out.println("Dice 2: " + result.getRight());
object.rollDiceWithResultHandler((dice1, dice2) -> {
System.out.println("Dice 1: " + dice1);
System.out.println("Dice 2: " + dice2);
});
}
}
Antwoord 11
Naar mijn mening is het het beste om een nieuwe klasse te maken waarvan de constructor de functie is die je nodig hebt, bijvoorbeeld:
public class pairReturn{
//name your parameters:
public int sth1;
public double sth2;
public pairReturn(int param){
//place the code of your function, e.g.:
sth1=param*5;
sth2=param*10;
}
}
Gebruik dan gewoon de constructor zoals je de functie zou gebruiken:
pairReturn pR = new pairReturn(15);
en u kunt pR.sth1, pR.sth2 gebruiken als “2 resultaten van de functie”
Antwoord 12
U kunt ook veranderlijke objecten als parameters insturen. Als u methoden gebruikt om ze te wijzigen, worden ze gewijzigd wanneer u terugkeert van de functie. Het werkt niet op dingen als Float, omdat het onveranderlijk is.
public class HelloWorld{
public static void main(String []args){
HelloWorld world = new HelloWorld();
world.run();
}
private class Dog
{
private String name;
public void setName(String s)
{
name = s;
}
public String getName() { return name;}
public Dog(String name)
{
setName(name);
}
}
public void run()
{
Dog newDog = new Dog("John");
nameThatDog(newDog);
System.out.println(newDog.getName());
}
public void nameThatDog(Dog dog)
{
dog.setName("Rutger");
}
}
Het resultaat is:
Rutger
Antwoord 13
Retourneer een reeks objecten
private static Object[] f ()
{
double x =1.0;
int y= 2 ;
return new Object[]{Double.valueOf(x),Integer.valueOf(y)};
}
Antwoord 14
Ten eerste zou het beter zijn als Java tuples had voor het terugzenden van meerdere waarden.
Ten tweede, code de eenvoudigst mogelijke Pairklasse of gebruik een array.
Maar als u doet hoeft u een paar te retourneren, overweeg dan welk concept het vertegenwoordigt (beginnend met zijn veldnamen en vervolgens klasnaam) – en of het een grotere rol speelt dan u dacht, en Als het uw algehele ontwerp zou helpen om er een expliciete abstractie voor te hebben. Misschien is het een code hint…
Let op: ik zeg het niet dogmatisch Will Help, maar gewoon om te kijken, naar Zie als het dat doet … of dat het niet.