java 可变参数方法Object... objs

public abstract List find(String hql, Object... values);
Object... values，你也可以认为是Object[]values,数组.

 

可变参数(Varargs)

　　可变参数使程序员可以声明一个接受可变数目参数的方法。注意，可变参数必须是
函数声明中的最后一个参数。假设我们要写一个简单的方法打印一些对象，
util.write(obj1);
util.write(obj1,obj2);
util.write(obj1,obj2,obj3);
…
　　在JDK1.5之前，我们可以用重载来实现，但是这样就需要写很多的重载函数，显得
不是很有效。如果使用可变参数的话我们只需要一个函数就行了
public　void　write(Object...　objs)　{
　　　for　(Object　obj:　objs)
　　　　　　System.out.println(obj);
}
　　在引入可变参数以后，Java的反射包也更加方便使用了。对于
c.getMethod("test",　new　Object[0]).invoke(c.newInstance(),　new　
Object[0]))，现在我们可以这样写了
c.getMethod("test").invoke(c.newInstance())，这样的代码比原来清楚了很多。

可变参数的调用

 public static void closeAll(Object... objs) {//可变参数
            for (Object obj : objs) {
                    if (obj instanceof Connection) close((Connection) obj);
                    if (obj instanceof Statement) close((Statement) obj);
                    if (obj instanceof ResultSet) close((ResultSet) obj);
            }
    }

 

 

 

 UtilDB  udb = new UtilDB();
        
         try{
            Connection     conn= udb.makeConnection();
             
             
                 Statement st =  conn.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE,ResultSet.CONCUR_READ_ONLY); 
                 ResultSet rt = st.executeQuery("select * from jobs");
             
          rt.last();
          System.out.println(rt.getRow()); 
         // rt.first();  //返回到第一条记录的位置
          rt.beforeFirst();  //反回到第一条记录的前面
        
        
        
         System.out.println("ok");
         if(rt.next())
         {
         System.out.println(rt.getInt(1)); //rs.getInt方法， 若数据库中记录的数值为null，getInt返回的是数值“0”，而不是null！
         System.out.println(rt.getInt(4));
         System.out.println(rt.getRow());  //是显示游标的当前行号 ，而非表的ID号
         }
         udb.closeAll(new Object[]{st, rt, conn}); 
         }catch(SQLException e)
         {
          e.printStackTrace();
         }finally {
                //udb.closeAll(new Object[]{st, rt, conn});
            }

 

 

 

 

static void printArray(Object...args){
     for(Object obj:args)
     System.out.print(obj+" ");
     System.out.println();
     }

     

printArray(new Object[]{
              new Integer(47),new Float(3.14),new Double(11.11)
              });
              printArray(new Object[]{"one","two","three"});

 

 

 

public class VariArgs {

     public static void main(String[] args) {
        test();
         test("aaa");
         test("aaa", "bbb");
         test("aaa", "bbb", "ccc");
    }

     public static void test(String... args) {
        System.out.println(args.getClass());
         for (String arg : args) {
            System.out.println(arg);
        }
    }
}

public class VariArgs {

	public static void main(String[] args) {
		test();
		test("aaa");
		test("aaa", "bbb");
		test("aaa", "bbb", "ccc");
	}

	public static void test(String... args) {
		System.out.println(args.getClass());
		for (String arg : args) {
			System.out.println(arg);
		}
	}
}

第二个例子:

public class VariArgs {

     public static void main(String[] args) {
         test("aaa");
         test("aaa", "bbb");
         test("aaa", "bbb", "ccc");
    }

     public static void test(String arg, String... args) {
        System.out.println(arg);
         System.out.println("----------------");
         for (String s : args) {
            System.out.println(s);
        }
    }
}

public class VariArgs {

	public static void main(String[] args) {
		test("aaa");
		test("aaa", "bbb");
		test("aaa", "bbb", "ccc");
	}

	public static void test(String arg, String... args) {
		System.out.println(arg);
		System.out.println("----------------");
		for (String s : args) {
			System.out.println(s);
		}
	}
}

   读者可以自己运行一下，这个不定长度参数的类型为String[]，即字符串数组。
从上面可以看出，如果一个方法的参数定为不定参数的话，这个参数可以根据参数个数动态生成一个数组，然后传入方法执行。
    不过，不定参数有两个规定：第一，方法的参数列表中最多只有一个不定长度的参数；第二，就是不定长度的数组的位置必须是最后一个参数。不然不能通过编译。
    对于第一个规定，是因为如果有多于一个不定长度的参数，当真正调用这个方法的时候，JVM、将不知道前面的不定长度参数有多长, 下一个参数是从哪里开始.
    对于第二个参数也是一样，编译器不知道不定长度参数的长度，无法确定从哪里开始下一个参数。
    以下是几种不正确使用不定长度参数的例子，请不要这样写程序：

public static void test(Object... objs, Object obj);

 public static void test(Object obj1, Object... objs, Object obj2);

 public static void test(Object... objs1, Object... objs2);

public static void test(Object... objs, Object obj);

public static void test(Object obj1, Object... objs, Object obj2);

public static void test(Object... objs1, Object... objs2);

   不定参数的方法可以重载。（大家都知道，重载就是方法名相同，而方法的参数列表不同）
   下面给出重载的示例:

public class VariArgs {

     public static void main(String[] args) {
         test("aaa");
         test("aaa", "bbb");
         test("aaa", "bbb", "ccc");
    }

     public static void test(Object... args) {
    }

     public static void test(String arg, String... args) {
    }
}

public class VariArgs {

	public static void main(String[] args) {
		test("aaa");
		test("aaa", "bbb");
		test("aaa", "bbb", "ccc");
	}

	public static void test(Object... args) {
	}

	public static void test(String arg, String... args) {
	}
}

   读者如果细心的话，可以看出文章开头给出的两个例子的区别，就是第二个例子比第一个例子的test方法的参数多出了一个String arg，从感觉上没有太大的区别，这有点像编译原理的*和+的区别。第一个test方法指可以有0或N个String做参数，但第二个test方法指至少一个String做为参数。
   然后结合重载来看，把第一个例子和第二个例子合并成一个类，得到以下代码：

public class VariArgs {

     public static void main(String[] args) {
        test();
         test("aaa");
         test("aaa", "bbb");
         test("aaa", "bbb", "ccc");
    }

     public static void test(String... args) {
        System.out.println(args.getClass());
         for (String arg : args) {
            System.out.println(arg);
        }
    }

     public static void test(String arg, String... args) {
        System.out.println(arg);
         System.out.println("----------------");
         for (String s : args) {
            System.out.println(s);
        }
    }
}

public class VariArgs {

	public static void main(String[] args) {
		test();
		test("aaa");
		test("aaa", "bbb");
		test("aaa", "bbb", "ccc");
	}

	public static void test(String... args) {
		System.out.println(args.getClass());
		for (String arg : args) {
			System.out.println(arg);
		}
	}

	public static void test(String arg, String... args) {
		System.out.println(arg);
		System.out.println("----------------");
		for (String s : args) {
			System.out.println(s);
		}
	}
}

    读者可以编译下这个程序，结果是编译不通过。为什么呢？程序编译到第五行时，不能确定test("aaa")该用第10行的test方法还是第17行的方法，因为两个方法都可以有相同的参数列表。都能精确匹配上参数列表，编译器在这种情况下只好报出编译不能通过的错误。所以在重载这样的方法时，注意参数列表，不要使两个方法可以有同样的参数列表。