variadic-functions

We use some varargs functions and as we move to java 1.7 we are getting a strange unchecked warning. Function add in interface ICache public interface ICache<O> { void add(Object source, O... objects); } in an interface reports the error. ICache.java:18: warning: [unchecked] Possible heap pollution from parameterized vararg type O void add(Object source, O... objects); where O is a type-variable: O extends Object declared in interface ICache 1 warning O extends Object, as its generic cache class. I read the xlint warnings and we do compile with unchecked on, but http://docs.oracle.com/javase/7

I'm looking for an elegant way to avoid re-writing a function, whose implementation is almost the same, but only the signature (the number of input parameters and their data types) is different. I know function overloading is not possible in C. I also know about the existence of variadic functions. But I think they won't be helpful in this situation. Consider the following problem, where we need to calculate the area of a triangle. We have two functions implementing two different formulae: S = 1/2bh and S = sqrt(s(s-a)(s-b)(s-c)). Apart from calculating the area each of the functions also

Say I have a function that takes a variable number of parameters: I want to call this function from somewhere else, building the list of parameters, but without knowing in advance how many parameters I'll need. Sorry that's not well explained, hopefully this code makes my question clearer: void foo(int n, ...) { va_list vl; va_start(vl,n); for (int i = 0; i<n; i++) { // Do something to each passed variable } } That function's being called from this one: void bar(int howManyParams) { // Here I want to call foo() with howManyParams parameters // (values are irrelevant for the question) // // I.e

I am curious about unpacking a slice of slices and sending them as arguments to a variadic function. Let's say we have a function with variadic parameters: func unpack(args ...interface{}) If we wan't to pass in a slice of interfaces it works, it doesn't matter if we unpack it or not: slice := []interface{}{1,2,3} unpack(slice) // works unpack(slice...) // works It gets tricky if we have a slice of slices. Here the compiler doesn't let us pass in an unpacked version: sliceOfSlices := [][]interface{}{ []interface{}{1,2}, []interface{}{101,102}, } unpack(sliceOfSlices) // works unpack

Could someone help me understand section 15.12.2.5 of the JLS re: most specific method ? (bludgeoned cut&paste from JLS follows) In addition, one variable arity member method named m is more specific than another variable arity member method of the same name if either: One member method has n parameters and the other has k parameters, where n >= k. The types of the parameters of the first member method are T1, . . . , Tn-1 , Tn[], the types of the parameters of the other method are U1, . . . , Uk-1, Uk[]. If the second method is generic then let R1 ... Rp p1, be its formal type parameters, let