parent:
public int[] GetNums() {
return new int[] {a,b,c};
}
child:
float[] GetNums() {
return new float[] {a,b,c};
}
This doesn't work, is there any reasonable workaround for this?
#How do you change the return type of a child-class method inherited from the parent
spiral panther
bleak vaporBOT
parent:
```java
public int[] GetNums() {
return new int[] {a,b,c};
}
```
child...
Detected code, here are some useful tools:
<@&987246399047479336> please have a look, thanks.
Here is an AI assisted attempt to answer your question 🤖. Maybe it helps! In any case, a human is on the way 👍. To continue talking to the AI, you can use </chatgpt:1108714622413963314>.
TJ-Bot
native veldt
proper pond
parent:
```java
public int[] GetNums() {
return new int[] {a,b,c};
}
```
child...
you can't,it wouldn't make sense
you can only return subtypes
pearl sequoia
there is Number as common supertype but it likely wont really do what u want either
maybe u can explain ur use case a bit and we find a proper solution
🙂
rose scaffold
As others have said you can't do that. But, you can return Object instead in the parent, if you control that class.
// in parent class
public Object GetNums() {
return new int[] {a,b,c};
}
// in subclass
public Object getNums(){
return new float[] {a,b,c};
}
That is the only way to return ANY type (that's not a primitive). All arrays, even primitive ones are technically Object. So this is the only way to work generically with arrays of primitives. You would be required to cast the Object back to it's original int[] or float[] where it is used, which is not ideal.
Now, people will yell at you for doing this. The logical idea being that you would use the wrapper class of primitive types (Integer, Float, Double, Long) instead and return List<T> where T is Integer, Float, etc.
public List<T> getNums(){
return List.of(a,b,c);
}
You could also return just a T where T would be an int[] or float[] since those are still reference types. This is slightly better than returning Object since you won't need a cast where it's used.
public T getNums(){
return new int[]{a,b,c};
}
odd prairie
Another issue is that you generally want a super type to give a "less specific" promise about what it returns
And then a subtype to give a "more specific" one
int[] and float[] don't have that relationship. They are just different
You could have something like
sealed interface Numeric {
double doubleValue();
}
sealed interface IntegerNumeric extends Numeric {
int intValue();
}
And then have the super type give a Numeric[] and the subtype give a IntegerNumeric[]
Or vice versa
But you see how this opens up a whole can of worms over just using doubles
rose scaffold
I think OP has implemented some algorithm, it's in a class instead of just being a static utility method, and this getNums method is a way to get the result. And now he want's to implement with float, double, etc.
bleak vaporBOT
@spiral panther