精华内容
下载资源
问答
  • Java方法的参数个

    万次阅读 多人点赞 2014-08-29 10:00:37
    原文:Java方法的参数类型许多Java新人在看到下面的这段代码的时候,都会问一个问题:dealArray方法里那三小点点是什么啊?[java] view plaincopyprint?public class TestVarArgus { public static ...

    原文:Java方法的可变参数类型

    许多Java新人在看到下面的这段代码的时候,都会问一个问题:dealArray方法里那三个小点点是什么啊?

    1. public class TestVarArgus {  
    2.     public static void dealArray(int... intArray){  
    3.           
    4.     }  
    5.       
    6.     public static void main(String args[]){  
    7.           
    8.     }  
    9. }  

    这就是今天这篇blog的主角:可变的参数类型,也称为不定参数类型。英文缩写是varargus,还原一下就是variable argument type。通过它的名字可以很直接地看出来,这个方法在接收参数的时候,个数是不定的。那么好,现在就先来调用下这个方法。请看代码和输出:

    1. public class TestVarArgus {  
    2.     public static void dealArray(int... intArray){  
    3.         for (int i : intArray)  
    4.             System.out.print(i +" ");  
    5.           
    6.         System.out.println();  
    7.     }  
    8.       
    9.     public static void main(String args[]){  
    10.         dealArray();  
    11.         dealArray(1);  
    12.         dealArray(123);  
    13.     }  
    14. }  

    输出:

    1. 1   
    2. 1 2 3   

    通过main方法里的调用,可以看出来这个可变参数既可以是没有参数(空参数),也可以是不定长的。看到这里估计都能明白,这个不定长的参数其实和数组参数挺像的。事实上,也确实是这么回事儿。编译器会在悄悄地把这最后一个形参转化为一个数组形参,并在编译出的class文件里作上一个记号,表明这是个实参个数可变的方法。请看代码:

    1. dealArray(); //dealArray(int[] intArray{});  
    2.         dealArray(1); //dealArray(int[] intArray{1});  
    3.         dealArray(123); //dealArray(int[] intArray{1, 2, 3});  

    说到这里,那么可以来验证一下,看看是不是这个可变参数就是数组类参数?看代码:

    1. public class TestVarArgus {  
    2.     public static void dealArray(int... intArray){  
    3.         for (int i : intArray)  
    4.             System.out.print(i +" ");  
    5.           
    6.         System.out.println();  
    7.     }  
    8.       
    9.     public static void dealArray(int[] intArray){//会有Duplicate method dealArray(int[]) in type TestVarArgus的错误  
    10.         for (int i : intArray)  
    11.             System.out.print(i +" ");  
    12.           
    13.         System.out.println();  
    14.     }  
    15.       
    16.     public static void main(String args[]){  
    17.         dealArray();   
    18.         dealArray(1);  
    19.         dealArray(123);  
    20.     }  
    21. }  

    从上面这段代码可以看出,这两个方法是冲突的,是无法重载的。到这里,再来做一个有意思的实验:

    1. public class TestVarArgus {  
    2.     public static void dealArray(int... intArray){  
    3.         for (int i : intArray)  
    4.             System.out.print(i +" ");  
    5.           
    6.         System.out.println();  
    7.     }  
    8.       
    9.     public static void main(String args[]){  
    10.         int[] intArray = {123};  
    11.           
    12.         dealArray(intArray);  //通过编译,正常运行  
    13.     }  
    14. }  

    1. public class TestVarArgus {  
    2.     public static void dealArray(int[] intArray){  
    3.         for (int i : intArray)  
    4.             System.out.print(i +" ");  
    5.           
    6.         System.out.println();  
    7.     }  
    8.       
    9.     public static void main(String args[]){  
    10.         dealArray(123);  //编译错误  
    11.     }  
    12. }  

    从上面这两段代码可以看出来,可变参数是兼容数组类参数的,但是数组类参数却无法兼容可变参数。其实对于第二段代码而言,编译器并不知道什么可变不可变,在它看来,需要定义一个dealArray(int, int, int)类的方法。所以,自然就无法去匹配数组类参数的dealArray方法了。

     

    写不完了,吃完午饭,下午继续...

     

    吃好午饭,睡了一会儿,继续上午的话题,接下来谈一下Java的可变参数。

     

    既然Java方法接收可变参数,那么接下来我们再来看一下下面的代码:

    1. public class TestVarArgus {  
    2.     public static void dealArray(int count, int... intArray){  
    3.           
    4.     }  
    5.       
    6.     public static void dealArray(int... intArray, int count){//编译报错,可变参数类型应该作为参数列表的最后一项  
    7.           
    8.     }  
    9.       
    10.     public static void main(String args[]){  
    11.             
    12.     }  
    13. }  

    这段代码说明了,可变参数类型必须作为参数列表的最后一项,而不能放在定长参数的前面。估计你会想到一个词“优先级”。因为没有确切的说明,只是这样一种规定,这里可以借用“优先级”这个词来理解一下,请看下面的代码:

    1. public class TestVarArgus {  
    2.     public static void dealArray(int... intArray){  
    3.         System.out.println("1");  
    4.     }  
    5.       
    6.     public static void dealArray(int count, int count2){  
    7.         System.out.println("2");  
    8.     }  
    9.       
    10.     public static void main(String args[]){  
    11.         dealArray(12);  
    12.     }  
    13. }  

    代码贴出来估计都知道是输出2,而不是1。记住:能匹配定长的方法,那么优先匹配该方法。含有不定参数的那个重载方法是最后被选中的。

     

    最后,大家都知道main方法的参数就是一个数组类型的,那么它其实也是可以改成不定参数类型。试一试吧,看看有没有编译错误。


    展开全文
  • 当写了一方方法后,想让这方法传入确定的参数值,就要用到参数 在jdk1.5加入了此方法,使用语法: 数据类型 ... 参数名称 如:int ... data public class Test { public static void main(String...

    java可变参数

    当写了一方方法后,想让这个方法传入不确定的参数值,就要用到可变参数

    在jdk1.5加入了此方法,使用语法:

    数据类型 ... 可变参数名称

    如:int ... data

    public class Test {
        public static void main(String[] args) {
            int x = add(1,2,3,5,6,2);
            System.out.println(x);
        }
    
        public static int add(int ... a){
            int result = 0;
            for (int data:a) {
                result += data;
            }
            return result;
        }
    }
    

    可变参数的本质是数组,相当于

    public class Test {
        public static void main(String[] args) {
            int xx = add1(new int[]{1,2,3,5,6,2});
            System.out.println(xx);
        }
    
        public static int add1(int[] a){
            int result = 0;
            for (int data:a) {
                result += data;
            }
            return result;
        }
    }
    

    但要注意,一个方法只允许一个可变参数,并且写在参数最后一个。

    public class Test {
        public static void main(String[] args) {
            int xxx = addAtLeastTwo(1,2,3,4,23);
            System.out.println(xxx);
        }
    
        public static int addAtLeastTwo(int a,int b,int ... n){
            //如果有可变参数,一定要吧他放在最后一个参数
            int result = 0;
            for (int data:n) {
                result += data;
            }
            return result;
        }
    }
    

     

    展开全文
  • JAVA参数参数中有三

    万次阅读 多人点赞 2014-06-19 14:25:46
    许多Java新人在看到下面的这段代码的时候,都会问一个问题:dealArray方法里那三小点点是什么啊? [java] view plaincopyprint? public class TestVarArgus {   public static void ...

    许多Java新人在看到下面的这段代码的时候,都会问一个问题:dealArray方法里那三个小点点是什么啊?

    1. public class TestVarArgus {  
    2.     public static void dealArray(int... intArray){            
    3.     }        
    4.     public static void main(String args[]){            
    5.     }  
    6. }  

    可变的参数类型,也称为不定参数类型。英文缩写是varargus,还原一下就是variable argument type。通过它的名字可以很直接地看出来,这个方法在接收参数的时候,个数是不定的。那么好,现在就先来调用下这个方法。请看代码和输出:

    1. public class TestVarArgus {  
    2.     public static void dealArray(int... intArray){  
    3.         for (int i : intArray)  
    4.             System.out.print(i +" ");            
    5.         System.out.println();  
    6.     }  
    7.       
    8.     public static void main(String args[]){  
    9.         dealArray();  
    10.         dealArray(1);  
    11.         dealArray(123);  
    12.     }  
    13. }  

    输出:


    1. 1   
    2. 1 2 3   

    通过main方法里的调用,可以看出来这个可变参数既可以是没有参数(空参数),也可以是不定长的。看到这里估计都能明白,这个不定长的参数其实和数组参数挺像的。事实上,也确实是这么回事儿。编译器会在悄悄地把这最后一个形参转化为一个数组形参,并在编译出的class文件里作上一个记号,表明这是个实参个数可变的方法。请看代码:

    1. dealArray(); //dealArray(int[] intArray{});  
    2. dealArray(1); //dealArray(int[] intArray{1});  
    3. dealArray(123); //dealArray(int[] intArray{1, 2, 3});  

    说到这里,那么可以来验证一下,看看是不是这个可变参数就是数组类参数?看代码:

    1. public class TestVarArgus {  
    2.     public static void dealArray(int... intArray){  
    3.         for (int i : intArray)  
    4.             System.out.print(i +" ");            
    5.         System.out.println();  
    6.     }        
          //会有Duplicate method dealArray(int[]) in type TestVarArgus的错误
    7.     public static void dealArray(int[] intArray){  
    8.         for (int i : intArray)  
    9.             System.out.print(i +" ");            
    10.         System.out.println();  
    11.     }  
    12.       
    13.     public static void main(String args[]){  
    14.         dealArray();   
    15.         dealArray(1);  
    16.         dealArray(123);  
    17.     }  
    18. }  

    从上面这段代码可以看出,这两个方法是冲突的,是无法重载的。到这里,再来做一个有意思的实验:

    1. public class TestVarArgus {  
    2.     public static void dealArray(int... intArray){  
    3.         for (int i : intArray)  
    4.             System.out.print(i +" ");            
    5.         System.out.println();  
    6.     }  
    7.       
    8.     public static void main(String args[]){  
    9.         int[] intArray = {123};            
    10.         dealArray(intArray);  //通过编译,正常运行  
    11.     }  
    12. }  
    1. public class TestVarArgus {  
    2.     public static void dealArray(int[] intArray){  
    3.         for (int i : intArray)  
    4.             System.out.print(i +" ");            
    5.         System.out.println();  
    6.     }  
    7.       
    8.     public static void main(String args[]){  
    9.         dealArray(123);  //编译错误  
    10.     }  
    11. }  

    从上面这两段代码可以看出来,可变参数是兼容数组类参数的,但是数组类参数却无法兼容可变参数。其实对于第二段代码而言,编译器并不知道什么可变不可变,在它看来,需要定义一个dealArray(int, int, int)类的方法。所以,自然就无法去匹配数组类参数的dealArray方法了。

    既然Java方法接收可变参数,那么接下来我们再来看一下下面的代码:

    1. public class TestVarArgus {  
    2.     public static void dealArray(int count, int... intArray){            
    3.     }  
    4.     //编译报错,可变参数类型应该作为参数列表的最后一项  
    5.     public static void dealArray(int... intArray, int count){            
    6.     }        
    7.     public static void main(String args[]){              
    8.     }  
    9. }  

    这段代码说明了,可变参数类型必须作为参数列表的最后一项,而不能放在定长参数的前面。估计你会想到一个词“优先级”。因为没有确切的说明,只是这样一种规定,这里可以借用“优先级”这个词来理解一下,请看下面的代码:

    1. public class TestVarArgus {  
    2.     public static void dealArray(int... intArray){  
    3.         System.out.println("1");  
    4.     }  
    5.       
    6.     public static void dealArray(int count, int count2){  
    7.         System.out.println("2");  
    8.     }  
    9.       
    10.     public static void main(String args[]){  
    11.         dealArray(12);  
    12.     }  
    13. }  

    代码贴出来估计都知道是输出2,而不是1。记住:能匹配定长的方法,那么优先匹配该方法。含有不定参数的那个重载方法是最后被选中的。

    最后,大家都知道main方法的参数就是一个数组类型的,那么它其实也是可以改成不定参数类型。试一试吧,看看有没有编译错误。

    转自:http://blog.csdn.net/justinavril/article/details/4674305

    展开全文
  • Java 后端接收Request请求参数的7种方式

    千次阅读 多人点赞 2020-11-13 14:43:36
    Java 后端接收Request请求参数的7种方式 1.直接在Controller 方法参数上配置参数名 @RequestMapping("/method01") public String method01(String name, Integer age, Double mon) { User user = new User(); ...

    Java 后端接收Request请求参数的7种方式

    1.直接在Controller 方法参数上配置参数名

     @RequestMapping("/method01")
        public String method01(String name, Integer age, Double mon) {
            User user = new User();
            user.setName(name);
            user.setAge(age);
            user.setMoney(mon);
            return JSON.toJSONString(user);
        }
    

    method01

    这种格式接收的是method01?name=zhangsan&age=15&mon=20.0格式的传参,并且要求参数名与url 地址中携带的参数名完全一致;

    这种形式传参与请求方式无关,get post .put 等皆可;

    2.@RequestParam 接收url地址中的参数

    @RequestMapping(value = "/method02")
        public String method02(@RequestParam("name") String name,
                               @RequestParam("age") Integer age,
                               @RequestParam(value = "money", required = false) Double mon) {
            User user = new User();
            user.setName(name);
            user.setAge(age);
            user.setMoney(mon);
            return JSON.toJSONString(user);
        }
    

    method02

    这种方式原理上与第一种一致,都是接收请求url地址种的参数,所以与请求方式无关;

    这种方式注解种的value值会去映射请求url 中的同名参数取参然后赋值给加注解的形参,所以注解中的参数名必须与url中一致,而方法形参名可以根据自身需求灵活变更;

    注意加此注解的required 属性 默认为true,也就是接收请求时会根据value去url寻找同名参数,如果没找到会报错;

    所以如果有某一参数可能不传的情况,需要将required属性设为false

    3.@RequestBody 接收body中JSON字符串参数

    @RequestMapping(value = "/method03")
        public String method03(@RequestBody User user) {
            return JSON.toJSONString(user);
        }
    

    method03

    上面两种方式都是通过从请求头(url) 中传参的方式实现获取参数,@RequestBody则是接收请求体中的JSON 字符串参数直接映射实体对象,所以body类型必须是JSON字符串;

    注意实体类中的属性名称必须与JOSN串中的参数key名称完全一致,不同命参数无法正确接收;

    使用此种方式推荐使用Post请求携带body参数,get请求虽然也可以携带body参数并请求成功但并不推荐这样操作,

    通常get请求通过url携带参数可以根据url作为key缓存资源,常用的静态资源服务器都是这种原理,如果参数在body中这种方式就失效了

    4.直接通过实体接收参数

    @RequestMapping(value = "/method04")
        public String method04(User user) {
            return JSON.toJSONString(user);
        }
    

    method05

    这种方式要求请求中的参数名与实体中的属性名一致即可自动映射到实体属性中;

    支持url拼接的多个params 传参

    支持post请求 的form类型传参(form-data,x-www-form-urlencoded), 不支持JSON 传参

    5.@ModelAttribute 接收实体参数

    @RequestMapping("/method05")
        public String method05(@ModelAttribute("user") User user) {
            return JSON.toJSONString(user);
        }
    

    method05

    @ModelAttribute 注解主要作用是自动将数据暴露为模型数据用于视图页面展示时使用,比如此处注解value为user, 前端视图就可以通过${user.name}来获取绑定的命令对象的属性

    此用法与方法4完全一致,支持url拼接的多个params 传参

    可以用于接收url 或者from表单中的数据映射实体;

    支持post请求 的form类型传参(form-data,x-www-form-urlencoded), 不支持JSON 传参

    6.HttpServletRequest request接收参数

     @RequestMapping("/method06")
        public String method06(HttpServletRequest request) {
            User user = new User();
            user.setName(request.getParameter("name"));
            user.setAge(Integer.valueOf(request.getParameter("age")));
            user.setMoney(Double.parseDouble(request.getParameter("money")));
            return JSON.toJSONString(user);
        }
    

    method06

    传统的接收参数方式,可以接收url params 传参,支持post from类型传参,不支持JSON传参

    注意如果请求中未传递指定名称的参数,取参时会报错

    7.@PathVariable RestFul 风格传参

    @RequestMapping(value = {"/method07/{name}/{age}/{money}","/method07/{name}/{money}"})
        public String method07(@PathVariable("name") String name,
                               @PathVariable(value = "age", required = false) Integer age,
                               @PathVariable("money") Double money) {
            User user = new User();
            user.setName(name);
            user.setMoney(money);
            user.setAge(age);
            return JSON.toJSONString(user);
        }
    

    在这里插入图片描述

    通过@PathVariable实现restFul 风格传参,直接将参数拼接到url地址中,支持get,post,put delete 等多种请求

    required属性默认为true ,不传递参数会报错;

    如果出现某个参数未传递的情况可以通过设置required属性为false并设置多个value 字符串的形式实现

    User实体类

    @Data
    @ToString
    public class User {
        private String name;
        private Integer age;
        private Double money;
    }
    

    总结:

    以上就是七种常见的请求方式,不足之处请多指正啦

    展开全文
  • Java数组传递及参数

    万次阅读 多人点赞 2018-09-02 11:39:20
    如果要向方法中传递一个数组,则方法的接收参数处必须是符合其类型的数组。而且数组属于引用数据类型,所以在把数组传递进方法之后,如果方法对数组本身做了任何修改,修改结果都是会保存下来的。   向方法中传递...
  • Java 参数,快速学习教程

    万次阅读 2015-11-18 18:18:29
    参数:适用于参数个确定,类型确定的情况,java参数当做数组处理。
  • 定义一个计算器类, 实现计算器类中加、 减、 乘、 除的运算方法, 每方法能够接收2个参数。 实现思路: 定义计算器类。 定义计算器类中加、减、乘、除的方法。 定义测试,进行四则运算。 实现代码: ...
  • 本文通过一个例子来说明 java中长度参数的实现,其实质相当于传入的参数一个数组: 在以上的例子中先定义类StringVarargTest再定义一个方法f(),其接收参数类型是String ...String代表传入的参数类型是...
  • SpringMVC接收对象参数

    千次阅读 2020-02-28 22:23:15
    为了能够在controller中获取多对象,我定义了两@RequestBody的参数,结果报错: I/O error while reading input message;...只用一个@RequestBody参数,另外一个参数用@RequestParam,则controller接收到...
  • Java 参数传递

    千次阅读 2018-03-30 20:26:14
    1.JDK 1.5 开始,Java支持传递同类型的参数一个方法。 方法的参数的声明如下所示:typeName... parameterName 在方法声明中,在指定参数类型后加一个省略号(...) 。 一个方法中只能指定一个可参数,...
  • 1.定义接口 ... import java.lang.annotation.ElementType; import java.lang.annotation.Retention; import java.lang.annotation.RetentionPolicy;... * TODO:自定义注解校验接收参数不能为空 * * Elem
  • 深度解析Java可参数类型以及与数组的区别

    万次阅读 多人点赞 2017-09-19 19:22:46
    深度解析Java可参数类型以及它与数组的区别
  • Java如何创建参数个限的函数

    千次阅读 2018-04-21 11:15:00
    变的参数类型,也称为不定参数类型。...通过它的名字可以很直接地看出来,这方法在接收参数的时候,数是不定的。 publicclassTestVarArgus{ publicstaticvoiddealArray(int...intArray){ for(inti:intArr...
  • 在很多时候我们的Controller是需要对接收参数进行校验的,如果为空的会影响一些操作. 然后自己写了一个自定义注解实现了参数校验 上代码~~~~~~~~~~~~~~ 首先是自定义注解 import java.lang.annotation.Element...
  • Java启动参数(-, -X, -XX参数)详解

    千次阅读 2020-08-12 15:14:15
    Java启动参数分类 、JVM标准参数(-) 获取方法:java -help 二、JVM非标准参数(-X) 获取方法:java -X 三、JVM非Stable参数(-XX) 获取方法:java -XX:+PrintFlagsInitial JDK8的-XX参数整理 JDK8 获取所有-...
  • JsonIgnore导致接收参数

    千次阅读 2019-09-19 10:27:11
    最近的项目里有某个属性需要接收,但...如果想接收则需要添加 @JsonProperty ,则实现接收,但返回的效果 这2注解直接加在字段上即可,也可以@JsonIgnore添加在getter @JsonProperty添加在setter ,不过现在...
  • Java controller 参数注解

    千次阅读 2018-07-26 10:12:52
    Java controller 参数注解 @PathVariavle pathvariable是把变量存放在url中,比较适用于传输变量较少的情况。但是也可以用来传输多变量。比如: 前台: targetUrl/参数1/参数2/参数3 后台@RequestMapping(...
  • java命令行参数

    千次阅读 2016-09-07 22:12:18
    命令行参数就是main方法里面的参数String[] args他就是一个数组,args只是数据类型的一个名称,就是一个数组的变量,名称无所谓,类型没变就行了。这就是程序的入口点
  • Java的学习过程当中,有些小伙伴可能会遇到这样的问题,那就是如何能在确定方法会接收到几个参数的时候来定义这方法呢? 例如最简单的定义一个加法方法 虽然方法可以通过重载来相同名字不同参数的方法, 如 ...
  • 接收的是一个Json对象的字符串,而不是一个Json对象 A)GET、POST方式提时, 根据request header Content-Type的值来判断: application/x-www-form-urlencoded, 选(即非必须,因为这种情况的数据@...
  • Java启动参数及调优

    千次阅读 2017-11-23 13:08:10
    java启动参数共分为三类; 其是标准参数(-),所有的JVM实现都必须实现这些参数的功能,而且向后兼容; 其二是非标准参数(-X),默认jvm实现这些参数的功能,但是并保证所有jvm实现都满足,且保证向后兼容...
  • 一个以json格式传参,后台controller参数接收问题 问题描述 前端向后台以json格式传参时,碰到时间类型,boolean类型的参数该如何接受? 解决 先解决boolean类型的参数接收问题; 我们接收前端传进来的json,一般...
  • JAVA启动参数整理

    万次阅读 2012-05-31 13:53:41
    java启动参数共分为三类; 其是标准参数(-),所有的JVM实现都必须实现这些参数的功能,而且向后兼容; 其二是非标准参数(-X),默认jvm实现这些参数的功能,但是并保证所有jvm实现都满足,且保证向后兼容...
  • java 启动参数大全

    千次阅读 2016-02-22 16:40:10
    java启动参数共分为三类: 标准参数(-),所有的JVM实现都必须实现这些参数的功能,而且向后兼容; 非标准参数(-X),默认jvm实现这些参数的功能,但是并保证所有jvm实现都满足,且保证向后兼容; 非Stable...
  • SpringMVC Controller接收参数总结

    千次阅读 2017-01-15 17:03:42
    在这篇文章中,总结SprinMVC中Controller接收ajax请求,所能支持的参数
  • Java基础总结篇---泛型&参数

    千次阅读 2018-12-09 21:01:00
    在我初学java的时候泛型我是没咋看的,直到后面做了安卓开发后才回过头来了解泛型。后来才渐渐体会到泛型的作用。至于参数,我现在才清楚,以前瞄过眼,但是真的只是眼。
  • 在mybatis中写了一个简单的sql并使用了注解的方式进行传值,代码如下: mapper.java中 void update(@Param("usercode") String usercode); mapper.xml 文件中 update reward set 1=1 where usercode=#{user...
  • Java编程】参数写法

    千次阅读 2012-05-09 22:56:30
    当你在做项目时,有一个计算传入参数的和,但参数多少确定,面对这样的情况要如何解决呢? 参数的写法请参考下面的例子 package com.ycao.argsTest; public class VarArgs { public static void main...
  • 1 java返回多参数方法 在编写程序时经常遇到从一个方法中返回多有用信息的情况。例如查找一个数组中最大值与最小值,一般的做法是通过一个for循环,两if判断找出最值。但是在找到有用信息后需要通过函数返回的...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 286,865
精华内容 114,746
关键字:

java接受参数可不可以不接收一个参数

java 订阅