public static void main(String args[]) {
myMethod(); // i am calling static method from main()
}
public static ? myMethod(){ // ? = what should be the return type
return value;// is String
return index;// is int
}
myMethod()将返回String和int值。因此，从main()获取这些返回值，我想出了以下解决方案。
创建一个类调用ReturningValues
public class ReturningValues {
private String value;
private int index;
// getters and setters here
}
并按如下方式更改myMethod()。
public static ReturningValues myMethod() {
ReturningValues rv = new ReturningValues();
rv.setValue("value");
rv.setIndex(12);
return rv;
}
现在我的问题是，有没有更简单的方法来实现这一目标？
答案 0 :(得分：18)
我使用枚举创建各种返回类型。它没有自动定义。该实现看起来像工厂模式。
All values are null.Not sure what I am missing.please help me on this.
单元测试：
public enum SmartReturn {
IntegerType, DoubleType;
@SuppressWarnings("unchecked")
public <T> T comeback(String value) {
switch (this) {
case IntegerType:
return (T) Integer.valueOf(value);
case DoubleType:
return (T) Double.valueOf(value);
default:
return null;
}
}
}
答案 1 :(得分：17)
没有。 Java方法只能返回一个结果（void，一个原语或一个对象），而创建一个struct类型的类就像你这样做。
作为一个注释，经常可以像你这样的ReturningValues类这样的类是不可变的：
public class ReturningValues {
public final String value;
public final int index;
public ReturningValues(String value, int index) {
this.value = value;
this.index = index;
}
}
这样做的好处是可以传递ReturningValues，例如线程之间，而不用担心意外地使事情不同步。
答案 2 :(得分：6)
通常，如果您不确定最终返回的值是什么，则应考虑使用return-type作为所有返回值的超类。在这种情况下，您需要返回String或int，请考虑返回Object类（它是java中定义的所有类的基类）。
但是请注意 instanceof checks 调用此方法。否则你可能最终得到 ClassCastException 。
public static void main(String args[]) {
Object obj = myMethod(); // i am calling static method from main() which return Object
if(obj instanceof String){
// Do something
}else(obj instance of Integer) {
//do something else
}
答案 3 :(得分：2)
你采取的方法很好。 只是实施可能需要更好。 例如，ReturningValues应该被很好地定义 如果你可以将ReturningValues设为不可变，那就更好了。
// this approach is better
public static ReturningValues myMethod() {
ReturningValues rv = new ReturningValues("value", 12);
return rv;
}
public final class ReturningValues {
private final String value;
private final int index;
public ReturningValues(String value, int index) {
this.value = value;
this.index = index;
}
}
或者，如果您有许多键值对，则可以使用HashMap
public static Map<String,Object> myMethod() {
Map<String,Object> map = new HashMap<String,Object>();
map.put(VALUE, "value");
map.put(INDEX, 12);
return Collections.unmodifiableMap(map); // try to use this
}
答案 4 :(得分：1)
这可能是解决方案之一。但是你目前的解决方案还不错。您还可以添加新变量并保持清洁，但现有代码无法完成。
private static final int INDEX_OF_STRING_PARAM = 0;
private static final int INDEX_OF_INT_PARAM = 1;
public static Object[] myMethod() {
Object[] values = new Object[2];
values[INDEX_OF_STRING_PARAM] = "value";
values[INDEX_OF_INT_PARAM] = 12;
return values;
}
答案 5 :(得分：1)
您可以将返回作为对象。您可以在飞行中创建该对象。在你的
long == signed long字符串相同。但我担心这是一个昂贵的解决方案......
答案 6 :(得分：1)
我只想发表自己的观点
因此，您需要创建一个通用的返回类型并由不同类型的具体返回类型实现。 Service类可以创建不同类型的对象具体类，并作为通用类型返回。
public interface GenericReturnType{
public static RETURN_TYPE enum{
MACHINE, PERSON;
}
public RETURN_TYPE getReturnType();
}
public class PersonReturnType implements GenericReturnType{
// CONSTRUCTORS //
// GETTRE AND SETTER //
public RETURN_TYPE getReturnType(){
return PERSON;
}
public String getAddress(){
return something;
}
}
public class MachineReturnType implements GenericReturnType{
// CONSTRUCTORS //
// GETTRE AND SETTER //
public RETURN_TYPE getReturnType(){
return MACHINE;
}
public String getManufatureName(){
return something;
}
}
public class TestService{
public GenericReturnType getObject(// some input //){
GenericReturnType obj ;
if(// some code //){
obj = new PersonReturnType();
// some code //
}
if(// some code //){
obj = new MachineReturnType();
// some code //
}
return obj;
}
}
public class TestDriver{
TestService service = new TestService();
GenericReturnType genObj = TestService.getObject(// some input //);
if(genObj.getReturnType() == RETURN_TYPE.MACHINE){
// SOME CODE //
}
if(genObj.getReturnType() == RETURN_TYPE.PERSON){
// SOME CODE //
}
}
答案 7 :(得分：0)
@ruchira你的解决方案它自我是最好的。但我认为如果它只是关于整数和字符串我们可以很容易和简单的方式做到这一点..
class B {
public String myfun() {
int a=2; //Integer .. you could use scanner or pass parameters ..i have simply assigned
String b="hi"; //String
return Integer.toString(a)+","+b; //returnig string and int with "," in middle
}
}
class A {
public static void main(String args[]){
B obj=new B(); // obj of class B with myfun() method
String returned[]=obj.myfun().split(",");
//splitting integer and string values with "," and storing them in array
int b1=Integer.parseInt(returned[0]); //converting first value in array to integer.
System.out.println(returned[0]); //printing integer
System.out.println(returned[1]); //printing String
}
}
我希望它有用.. :)）
答案 8 :(得分：0)
最后我认为我的方式更好，因为当返回类型的数量增加时，这种实现方式会以最佳方式执行此操作。
public static ReturningValues myMethod() {
ReturningValues rv = new ReturningValues();
rv.setValue("value");
rv.setIndex(12);
return rv;
}
答案 9 :(得分：0)
您正在寻找的课程已经存在。 Map.Entry：
public static Entry<Integer,String> myMethod(){
return new SimpleEntry<>(12, "value");
}
后来：
Entry<Integer,String> valueAndIndex = myMethod();
int index = valueAndIndex.getKey();
String value = valueAndIndex.getValue();
这只是一个简单的双字段数据结构，用于存储密钥和值。如果你需要进行任何特殊的处理，存储两个以上的字段，或者有任何其他的边缘情况，你应该创建自己的类，但除此之外，Map.Entry是未充分利用的Java类之一，非常适合各种情况喜欢这些。
答案 10 :(得分：0)
我知道这已经很晚了，但我认为这对那些正在寻找答案的人有所帮助。您可以使用Bundle返回多个数据类型值，而无需创建其他方法。我尝试过并完美地工作。
在您调用方法的MainActivity中：
Bundle myBundle = method();
String myString = myBundle.getString("myS");
String myInt = myBundle.getInt("myI");
方法：
public Bundle method() {
mBundle = new Bundle();
String typicalString = "This is String";
Int typicalInt = 1;
mBundle.putString("myS", typicalString);
mBundle.putInt("myI", typicalInt);
return mBundle;
}
P.S：我不确定是否可以像这样实现Bundle，但对我来说，它完美无缺。
答案 11 :(得分：0)
public ArrayList divineCast(String object) {
try
{
Integer result = Integer.parseInt(object);
ArrayList<Integer> generic = new ArrayList<Integer>();
generic.add(result);
return generic;
}
catch(Exception e)
{
//not a Integer
}
try
{
Float result = Float.parseFloat(object);
ArrayList<Float> generic = new ArrayList<Float>();
generic.add(result);
return generic;
}
catch(Exception e)
{
//not a Float
}
try
{
Double result = Double.parseDouble(object);
ArrayList<Double> generic = new ArrayList<Double>();
generic.add(result);
return generic;
}
catch(Exception e)
{
//not a double
}
try
{
Boolean result = Boolean.parseBoolean(object);
ArrayList<Boolean> generic = new ArrayList<Boolean>();
generic.add(result);
return generic;
}
catch(Exception e)
{
//not a Boolean
}
try
{
String result = String.valueOf(object);
ArrayList<String> generic = new ArrayList<String>();
generic.add(result);
return generic;
}
catch(Exception e)
{
//not a String
}
return null;
}
然后您可以调用，然后像这样
String test1 = "0.90854938";
String test2 = "true";
System.out.println(divineCast(test1).get(0));
System.out.println(divineCast(test1).get(0).getClass());
System.out.println(divineCast(test2).get(0));
System.out.println(divineCast(test2).get(0).getClass());
Java不会强迫您在函数声明中声明要返回的ArrayList的类型，因此您可以返回任何类型的ArrayList。
答案 12 :(得分：0)
一种解决方案如下。 函数可以定义如下（输入的数量/类型可以是套利）
static List<Object> multiTypeInputOut (int a, double b, String c, List<Object> d)
{
List<Object> multiTypes = new ArrayList<>();
multiTypes.add(a);
multiTypes.add(b);
multiTypes.add(c);
multiTypes.add(d);
return multiTypes;
}
调用此类方法/函数时，示例如下（只需记住并正确设置返回类型的顺序）：
List<Object> HelloWorldStrList = new ArrayList<Object>(Arrays.asList("Welcome", "Hello", "World"));
List<Object> multiType = multiTypeInputOut (1, 2.1, "HelloWorld", HelloWorldStrList);
int entry1 = (int) multiType.get(0);
double entry2 = (double) multiType.get(1);
String entry3 = (String) multiType.get(2);
List<Object> entry4 = (List<Object>) multiType.get(3);
答案 13 :(得分：-1)
方法重载在这里可以派上用场 像：
<code>
public class myClass
{
int add(int a, int b)
{
return (a + b);
}
String add(String a, String b)
{
return (c + d);
}
public static void main(String args[])
{
myClass ob1 = new myClass);
ob1.add(2, 3);
//will return 5
ob1.add("Hello, ", "World!");
//will return Hello, World!
}
}