精华内容
下载资源
问答
  • java形参有几个
    2021-03-18 11:53:06

    今天阅读了一个写的非常棒的博文,通过此博文再次复习了Java中参数传递的知识(即值传递与引用传递的区别)。参考网站http://www.cnblogs.com/binyue/p/3862276.html。下面我将通过次博文记录自己的理解,还望能够帮助再学Java或者复习Java的朋友们。

    一、基本类型与引用类型在内存中的保存内容

    Java中的变量分为基本类型和引用类型两种。基本类型的变量保存数值本身,而引用类型的变量保存的是引用值,即指向内存空间的地址。

    基本类型包括:byte,char,int short,long,float,double,boolean;

    引用类型包括:类类型,接口类型和数组。

    二、基本类型与引用类型的区别

    *基本类型在声明其变量时就为它分配了空间:

    int value;

    value =10;//正确,因为声明a时就分配了空间

    *而引用不同,在进行引用的声明时只给变量声明了引用空间,而不分配数据空间:

    Date date;

    //执行实例化,开辟数据空间存放Date对象,然后把空间的首地址传给today变量

    //date=new Date();

    //如果注释掉上一步操作

    //The local variable date may not have been initialized

    //也就是说对象的数据空间没有分配

    date.getDate();

    *初始化过程如下:

    Date a,b;//在内存开辟两个引用空间

    a =new Date();//开辟存储Date对象的数据空间,并把该空间的首地址赋给a

    b = a;//将a存储空间中的地址写到b的存储空间中

    ##:注意:引用也是占用空间,一个空对象的引用大小大概是4byte。

    三、引用传递和值传递

    *值传递:方法调用时,实际参数将它的值传递给对应的形式参数,函数接收到的是原始值的副本,此时内存中存在两个相等的基本类型,若方法中对形参执行处理操作,并不会影响实际参数的值。

    *引用传递:方法调用时,实际参数的引用(是指地址,而不是参数的值)被传递给方法中相应的形式参数,函数接收到的是原始值的内存地址,在方法中,形参与实参的内容相同,方法中对形参的处理会影响实参的值。

    具体代码如下:

    public class ReferencePkValue2 {

    public static void main(String[] args) {

    ReferencePkValue2 t =new ReferencePkValue2();

    int a=99;

    t.test1(a);//这里传递的参数a就是按值传递

    System.out.println(a);

    MyObj obj=new MyObj();

    t.test2(obj);//这里传递的参数obj就是引用传递

    System.out.println(obj.b);

    }

    public void test1(int a){

    a=a++;

    System.out.println(a);

    }

    public void test2(MyObj obj){

    obj.b=100;

    System.out.println(obj.b);

    }

    }

    输出的结果是:

    100

    90

    100

    100

    * 这里要特殊考虑String,以及Integer、Double等几个基本类型包装类,它们都是immutable类型,

    因为没有提供自身修改的函数,每次操作都是新生成一个对象,所以要特殊对待,可以认为是和基本数据类型相似,传值操作。

    四、结论

    1)形参为基本类型时,对形参的处理不会影响实参。

    2)形参为引用类型时,对形参的处理会影响实参。

    3)String,Integer,Double等immutable类型的特殊处理,可以理解为值传递,形参操作不会影响实参对象。

    java 中形参与实参的转换

    java中有两个参数,一个是形参,一个是实参. 形参:在函数定义中,整个函数体内部都可以使用,离开了该函数就不能继续使用. 实参:出现在主函数中,进入被调函数后,实参变量也就不能继续使用. publi ...

    深入理解java的形参和实参

    转载声明:本文转载自公众号「码匠笔记」. 前几天在头条上看到一道经典面试题,引发了一些思考.也是写这篇文章的导火索. 背景 请看题: public    classMain{    publicsta ...

    浅谈对java中传参问题的理解

    之前用的c/c++比较多,在c/c++中对于传参类型,无外乎就是传值.传引用.传指针这几种.但在java中,由于没有指针类型,其传参的方式也发生了相应的变化.在网上找了找,按我之前的理解,java中传 ...

    js 函数中形参与实参的关系

    函数中形参与实参的关系 对于形参和实参的定义,在 权威指南中有着明确的定义.但是,我们更在意的是它们之间的关系,到底形参会不会影响到实参? 形参到底会不会影响到实参? 对于这个问题的答案,请先看以下两 ...

    java中容器的学习与理解

    以前一直对于java中容器的概念不理解,虽然学习过,但始终没有认真理解过,这几天老师提出了这样一个问题,你怎么理解java中的容器.瞬间就蒙了.于是各种搜资料学习了一下,下面是我学习后整理出来的的一些 ...

    java中传值方式的个人理解

    前言 这几天在整理java基础知识方面的内容,对于值传递还不是特别理解,于是查阅了一些资料和网上相关博客,自己进行了归纳总结,最后将其整理成了一篇博客. 值传递 值传递是指在调用函数时将实际参数复制一 ...

    Java中的不可变类理解

    一.Java中的不可变类 不可变类(Immutable Objects):当类的实例一经创建,其内容便不可改变,即无法修改其成员变量. 可变类(Mutable Objects):类的实例创建后,可以修 ...

    java的形参与实参的区别以及java的方法

    package com.lv.study; public class Demo05 { public static void main(String[] args) { //我想要用什么分隔符进行分隔 ...

    一道题带你搞定Python函数中形参和实参问题

    昨天在Python学习群里有位路人甲问了个Python函数中关于形参和实参一个很基础的问题,虽然很基础,但是对于很多小白来说不一定简单,反而会被搞得稀里糊涂.人生苦短,我用Python. 为了解答大家 ...

    随机推荐

    MySQL主从复制中常见的3个错误及填坑方案

    一.问题描述 主从复制错误一直是MySQL DBA一直填不完的坑,如鲠在喉,也有人说mysql主从复制不稳定云云,其实MySQL复制比我们想象中要坚强得多,而绝大部分DBA却认为只要跳过错误继续复制就 ...

    Git Cheat Sheet

    Merge Undo git merge with conflicts $ git merge --abort Archive $ git archive --format zip --output ...

    IOS 线程处理 子线程

    IOS 线程处理 子线程的启动与结束 技术交流新QQ群:414971585   IOS中,如果要在主线程中启动一个子线程,可以又两种方法: [NSThread detachNewThreadSelec ...

    CodeForces 686C-Robbers' watch

    题意: 一个电子手表的示数是7进制的,现在告诉你一天有多少小时和一小时有多少分钟,问你一天里有多少个时刻,这个表上显示的数字各不相同. 分析: 先找出表上有多少位数字,再按位dfs,看最后得到的数是否 ...

    《shell脚本学习指南》学习笔记之入门

    为什么要使用shell脚本? shell脚本能够轻易处理文件与目录之类的对象,而且是各UNIX系统之间经过POSIX标准化的通用的功能,因此Shell脚本只要“用心写”一次,即可应用到很多系统上,因此 ...

    Python-week1,第一周(基于Python3.0以上)

    1,变量 准确来说不是第一周学习了吧,应该是采用博客记录学习的第一周,记录并做个笔记吧,可能做的不好,但我高兴啊,废话不说了,上图. 学习过程中做的一些笔记,当然能面面俱到,只能在写博客的时候又能复习 ...

    npm cnpm yarn

    npm 如何下载指定版本的组件 先确保文件目录下含有 package.json 文件, 没有的话,可以通过 npm init 创建, 然后只需要在组件的后面加上 @2.8.1 版本号即可, 例如:re ...

    一个用JS数组实现的队列

    一个用JS数组实现的队列 /*一个用数组实现的队列*/ function Queue(){ this.dataStore = [];//存放队列的数组,初始化为空 this.enqueue = enq ...

    hololens DEP2220: 无法删除目标计算机“127.0.0.1”上的文件夹

    Hololens开发调试的过程中,可能会出现 “DEP2220: 无法删除目标计算机“127.0.0.1”上的文件夹“ 的错误导致无法部署,解决办法是进入项目属性页——调试——启动选项,勾选“卸载并重 ...

    更多相关内容
  • java形参传递情况

    2021-03-02 19:55:53
    1.当把对象作为方法形参传入时,是传入地址,同时新建另一对象,那么将会新建一方法对象,change()方法将丢失传入的形参地址。 2.当新建一对象保存形参时,得以保存 3.当时如果改变转入形参的地址,...

    1.当把对象作为方法形参传入时,是传入地址,同时新建另一个对象,那么将会新建一个方法对象,change()方法将丢失传入的形参地址。

     

    2.当新建一个对象保存形参时,得以保存

     

    3.当时如果改变转入形参的地址,改变了其地址的属性(成员变量),那么将会影响到实参的属性。

     

    解释:

    说白了,Java只有值传递,网上说的什么两种传递方式:值传递和引用传递的都不是很准确。要知道所谓的引用传递,传递的也是指向堆内存中对象的“地址值”。都是“值”而已。也就涉及到4个东西——实际参数、形式参数、基本数据类型、引用数据类型。

    简单的说,

    ①实参是基本数据的时候,复制一份值给形参。因为这个基本数据类型的值不指向堆内存中的对象,所以不会改变实参的值。

    ②实参是引用类型时,也复制一份“地址值”给形参,这时实参和形参都指向堆内存中的同一个对象,所以当形参通过这个地址值改变了堆中对象的属性时,实参也会改变。而当文中的形参s=s+"edf"时,堆内存中会创建另一个新对象,形参指向的对象和实参指向的对象已经不同了(即地址值不同了),所以实参不会改变。

    展开全文
  • 天在头条上看到一道经典面试题,引发了一些思考。也是写这篇文章的导火索。背景请看题:publicclassMain{publicstaticvoidmain(String[]args){Integera=1;Integerb=2;System.out.println("a="+a+",b="+b);swap(a,b...

    转载声明:本文转载自公众号「码匠笔记」。

    前几天在头条上看到一道经典面试题,引发了一些思考。也是写这篇文章的导火索。

    背景

    请看题:

    publicclassMain{

    publicstaticvoidmain(String[]args){

    Integera=1;

    Integerb=2;

    System.out.println("a="+a+",b="+b);

    swap(a,b);

    System.out.println("a="+a+",b="+b);

    }

    privatestaticvoidswap(Integernuma,Integernumb){

    //请实现

    }

    }

    看到这个题后 瞬间觉得有坑。也觉得为什么要书写一个 swap方法呢?如下实现不是更简单:

    publicstaticvoidmain(String[]args){

    Integera=1;

    Integerb=2;

    System.out.println("a="+a+",b="+b);

    Integertmp=a;

    a=b;

    b=tmp;

    System.out.println("a="+a+",b="+b);

    }

    输出:

    a=1,b=2

    a=2,b=1

    完美实现交换。但是请注意,这是一道面试题,要的就是考验一些知识点。所以还是老老实实的实现 swap方法吧。 有的同学可能会想, Integer 是一个包装类型,是对Int的装箱和拆箱操作。其实也是一个对象。既然是对象,直接更改对象的引用不就行了?思路没问题,我们首先看看实现:

    privatestaticvoidswap(Integernuma,Integernumb){

    Integertmp=numa;

    numa=numb;

    numb=tmp;

    System.out.println("numa="+numa+",numb="+numb);

    }

    输出:

    a=1,b=2

    numa=2,numb=1

    a=1,b=2

    不出意外,没有成功这是什么原因呢?

    技术老手一看就知道问题出在形参和实参混淆了

    JAVA的形参和实参的区别:

    形参 顾名思义:就是形式参数,用于定义方法的时候使用的参数,是用来接收调用者传递的参数的。

    形参只有在方法被调用的时候,虚拟机才会分配内存单元,在方法调用结束之后便会释放所分配的内存单元。

    因此,形参只在方法内部有效,所以针对引用对象的改动也无法影响到方法外。

    实参 顾名思义:就是实际参数,用于调用时传递给方法的参数。实参在传递给别的方法之前是要被预先赋值的。

    在本例中 swap 方法 的numa, numb 就是形参,传递给 swap 方法的 a,b 就是实参

    注意:在 值传递调用过程中,只能把实参传递给形参,而不能把形参的值反向作用到实参上。在函数调用过程中,形参的值发生改变,而实参的值不会发生改变。而在 引用传递调用的机制中,实际上是将实参引用的地址传递给了形参,所以任何发生在形参上的改变也会发生在实参变量上。那么问题来了,什么是 值传递和 引用传递

    值传递和引用传递

    在谈 值传递和 引用传递之前先了解下 Java的数据类型有哪些

    JAVA的数据类型

    Java 中的数据类型分为两大类, 基本类型和 对象类型。相应的,变量也有两种类型: 基本类型和 引用类型 基本类型的变量保存 原始值,即它代表的值就是数值本身, 原始值一般对应在内存上的 栈区而 引用类型的变量保存 引用值, 引用值指向内存空间的地址。代表了某个对象的引用,而不是对象本身。对象本身存放在这个引用值所表示的地址的位置。 被引用的对象对应内存上的 堆内存区。基本类型包括: byte, short, int, long, char, float, double, boolean 这八大基本数据类型

    引用类型包括: 类类型, 接口类型和 数组

    变量的基本类型和引用类型的区别

    基本数据类型在声明时系统就给它分配空间

    inta;

    //虽然没有赋值,但声明的时候虚拟机就会 分配 4字节 的内存区域,

    //而引用数据类型不同,它声明时只给变量分配了引用空间,而不分配数据空间:

    Stringstr;

    //声明的时候没有分配数据空间,只有 4byte 的引用大小,

    //在栈区,而在堆内存区域没有任何分配

    str.length();

    //这个操作就会报错,因为堆内存上还没有分配内存区域,而 a = 1; 这个操作就不会报错。

    好了,Java的数据类型说完了,继续我们的 值传递和 引用传递的话题。 先背住一个概念: 基本类型的变量是 值传递; 引用类型的变量 结合前面说的 形参和 实参。

    值传递

    方法调用时,实际参数把它的值传递给对应的形式参数,函数接收的是原始值的一个copy, 此时内存中存在两个相等的基本类型,即实际参数和形式参数,后面方法中的操作都是对形参这个值的修改,不影响实际参数的值

    引用传递

    也称为 地址传递, 址传递。方法调用时,实际参数的引用(地址,而不是参数的值)被传递给方法中相对应的形式参数,函数接收的是原始值的内存地址 在方法执行中,形参和实参内容相同,指向同一块内存地址,方法执行中对引用的操作将会影响到实际对象 通过例子来说话:

    staticclassPerson{

    intage;

    Person(intage){

    this.age=age;

    }

    }

    privatestaticvoidtest(){

    inta=100;

    testValueT(a);

    System.out.println("a="+a);

    Personperson=newPerson(20);

    testReference(person);

    System.out.println("person.age="+person.age);

    }

    privatestaticvoidtestValueT(inta){

    a=200;

    System.out.println("int testValueT a="+a);

    }

    privatestaticvoidtestReference(Personperson){

    person.age=10;

    }

    输出:

    inttestValueT a=200

    a=100

    person.age=10

    看见 值传递 a的值并没有改变,而 引用传递的 persion.age已经改变了 有人说

    privatestaticvoidtestReference(Personperson){

    person=newPerson(100);

    }

    为什么 输出的 person.age 还是20呢?我想说 了解一下什么是 引用类型吧? 方法内把 形参的地址引用换成了另一个对象,并没有改变这个对象,并不能影响 外边 实参还引用原来的对象,因为 形参只在方法内有效哦。

    有人或许还有疑问,按照文章开头的例子, Integer也是 引用类型该当如何呢?

    其实 类似的 String, Integer, Float, Double, Short, Byte, Long, Character等等基本包装类型类。因为他们本身没有提供方法去改变内部的值,例如 Integer内部有一个 value 来记录 int基本类型的值,但是没有提供修改它的方法,而且 也是 final类型的,无法通过 常规手段更改。所以虽然他们是 引用类型的,但是我们可以认为它是 值传递,这个也只是 认为,事实上还是 引用传递, 址传递。

    好了,基础知识补充完毕,然我们回到面试题吧

    回归正题

    privatestaticvoidswap(Integernuma,Integernumb){

    Integertmp=numa;

    numa=numb;

    numb=tmp;

    System.out.println("numa="+numa+",numb="+numb);

    }

    通过补习基础知识,我们很明显知道 上面这个方法实现替换 是不可行的。因为 Interger虽然是 引用类型但是上述操作只是改变了 形参的引用,而没有改变 实参对应的 对象。

    那么思路来了,我们 通过特殊手段改变 Integer内部的 value属性

    privatestaticvoidswap(Integernuma,Integernumb){

    Integertmp=numa;

    try{

    Fieldfield=Integer.class.getDeclaredField("value");

    field.setAccessible(true);

    field.set(numa,numb);//成功的将numa 引用的 1的对象 值改为 2

    field.set(numb,tmp);//由于 tmp 也是指向 numa 未改变前指向的堆 即对象1 ,经过前一步,已经将对象1的值改为了2,自然 numb 也是2,所以改动失效

    }catch(Exceptione){

    e.printStackTrace();

    }

    }

    输出结果:java a=1,b=2a=2,b=2又来疑问了?为何 a的值改变成功,而 b的改变失败呢?

    见代码注释 所以其实 field.set(numb,tmp); 是更改成功的,只是 tmp 经过前一行代码的执行,已经变成了 2。 那么如何破呢? 我们有了一个思路,既然是 tmp的引用的对象值变量,那么我让 tmp不引用 numa了

    privatestaticvoidswap(Integernuma,Integernumb){

    inttmp=numa.intValue();//tmp 定义为基本数据类型

    try{

    Fieldfield=Integer.class.getDeclaredField("value");

    field.setAccessible(true);

    field.set(numa,numb);//这个时候并不改变 tmp 的值

    field.set(numb,tmp);

    }catch(Exceptione){

    e.printStackTrace();

    }

    }

    这种情况下 对 numa 这个对象的修改就不会导致 tmp 的值变化了,看一下运行结果

    a=1,b=2

    a=2,b=2

    这是为啥?有没有 快疯啦? 难道我们的思路错了? 先别着急,我们看看这个例子: 仅仅是将前面的例子 a的值改为 129, b的值改为130

    publicstaticvoidmain(String[]args){

    Integera=129;

    Integerb=130;

    System.out.println("a="+a+",b="+b);

    swap(a,b);

    System.out.println("a="+a+",b="+b);

    }

    privatestaticvoidswap(Integernuma,Integernumb){

    inttmp=numa.intValue();

    try{

    Fieldfield=Integer.class.getDeclaredField("value");

    field.setAccessible(true);

    field.set(numa,numb);

    field.set(numb,tmp);

    }catch(Exceptione){

    e.printStackTrace();

    }

    }

    运行结果:

    a=129,b=130

    a=130,b=129

    有没有 怀疑人生?我们的思路没有问题啊?为什么 换个数值就行了呢? 我们稍微修改一下程序

    publicstaticvoidmain(String[]args){

    Integera=newInteger(1);

    Integerb=newInteger(2);

    System.out.println("a="+a+",b="+b);

    swap(a,b);

    System.out.println("a="+a+",b="+b);

    }

    privatestaticvoidswap(Integernuma,Integernumb){

    inttmp=numa.intValue();

    try{

    Fieldfield=Integer.class.getDeclaredField("value");

    field.setAccessible(true);

    field.set(numa,numb);

    field.set(numb,tmp);

    }catch(Exceptione){

    e.printStackTrace();

    }

    }

    运行结果:

    a=1,b=2

    a=2,b=1

    哎?为啥 1 和 2 也可以了?我们这时肯定猜想和 Integer的装箱 拆箱有关

    装箱,拆箱 概念

    Integer的装箱操作

    为什么 Integera=1 和 Integera=newInteger(1) 效果不一样

    那就瞅瞅源码吧?

    publicInteger(intvalue){

    this.value=value;

    }

    /**

    * Returns an {@code Integer} instance representing the specified

    * {@code int} value.  If a new {@code Integer} instance is not

    * required, this method should generally be used in preference to

    * the constructor {@link #Integer(int)}, as this method is likely

    * to yield significantly better space and time performance by

    * caching frequently requested values.

    *

    * This method will always cache values in the range -128 to 127,

    * inclusive, and may cache other values outside of this range.

    *

    * @param  i an {@code int} value.

    * @return an {@code Integer} instance representing {@code i}.

    * @since  1.5

    */

    publicstaticIntegervalueOf(inti){

    if(i>=IntegerCache.low&&i<=IntegerCache.high)

    returnIntegerCache.cache[i+(-IntegerCache.low)];

    returnnewInteger(i);

    }

    通过注释知道,java推荐 Integer.valueOf 方式初始化一个 Interger因为有 缓存了 -128-127的数字 我们直接定义 Integera=1 具有这个功能,所以 Jvm 底层实现 是通过 Integer.valueOf这个方法 再看 field.set(numb,tmp); 我们打断点,发现通过反射设置 value时 竟然走了 Integer.valueOf 方法 下面是 我们调用 swap前后的 IntegerCache.cache 值得变化

    反射修改前:

    c53f697ad0b7c317d807427f31588712.png

    反射修改后

    778a6b6e8f38045023717d5fbe3ab042.png

    在反射修改前

    IntegerCache.cache[128]=0

    IntegerCache.cache[129]=1

    IntegerCache.cache[130]=2

    通过反射修改后

    IntegerCache.cache[128]=0

    IntegerCache.cache[129]=2

    IntegerCache.cache[130]=2

    再调用 field.set(numb,tmp) tmp这时等于1 对应的 角标 129 ,但是这个值已经变成了2 所以出现了刚才 奇怪的结果原来都是 缓存的锅下面趁机再看个例子 加深理解

    IntegertestA=1;

    IntegertestB=1;

    IntegertestC=128;

    IntegertestD=128;

    System.out.println("testA=testB "+(testA==testB)+",\ntestC=testD "+(testC==testD));

    输出结果:

    java testA=testBtrue,testC=testDfalse通过这小示例,在 -128 到 127的数字都走了缓存,这样 testA 和 testB引用的是同一片内存区域的同一个对象。 而 testC testD 数值大于127 所以 没有走缓存,相当于两个 Integer对象,在堆内存区域有两个对象。 两个对象自如不相等。在前面的示例中 我们 通过

    Integera=newInteger(1);

    Integerb=newInteger(2);

    方式初始化 a, b 我们的交换算法没有问题,也是这个原因。

    那么到目前为止我们的 swap 方法可以完善啦

    privatestaticvoidswap(Integernuma,Integernumb){

    inttmp=numa.intValue();

    try{

    Fieldfield=Integer.class.getDeclaredField("value");

    field.setAccessible(true);

    field.set(numa,numb);

    field.set(numb,newInteger(tmp));

    }catch(Exceptione){

    e.printStackTrace();

    }

    }

    只需将之前的 field.set(numb,tmp) 改为 field.set(numb,newInteger(tmp))

    到此, 这个面试我们已经通过了,还有一个疑问我没有解答。 为什么 field.set(numb,tmp) 会执行 Integer.valueOf() 而 field.set(numb,newInteger(tmp)) 不会执行。 这就是 Integer的装箱操作,当 给 Integer.value 赋值 int时,JVM 检测到 int不是Integer类型,需要装箱,才执行了 Integer.valueOf()方法。而 field.set(numb,newInteger(tmp)) 设置的 是Integer类型了,就不会再拆箱后再装箱。

    Over Thanks

    展开全文
  • 3.传入形参的个数可以是0 1 。。。无穷 4.一旦用了。。。作为形参定义,使用的时候可以往()里面 ①直接放数组名 ②在()内new一数组 ③直接把实参输入到()里 我们知道MySQL软件是由Java语言...

    总结:

    1. public void 方法( 数据类型 ... 形参名 , 类型 有限个数形参名 ){  }

            可变个数的形参定义在()的最后

    2.尽可能定义使用形参为数组的方法,因为形参为。。。的包含的重载更多更灵活

    3.传入形参的个数可以是0个 1个 。。。无穷个

    4.一旦用了。。。作为形参定义,使用的时候可以往()里面

        ①直接放数组名

        ②在()内new一个数组

        ③直接把实参输入到()里

    我们知道MySQL软件是由Java语言开发的,在SQL的查询语句中,SELECT XX FORM XXX WHERE XX1=xx1 XX2=xx2 ......这种筛选条件个数不确定,可由用户决定个数,在Java层面的实现原理就是“参数个数可变的方法”

    第一种是用数组作为形参的老版本方法:

    1.定义show方法,形参为 数组

    public class StringTest{
    ......
    }
    
    public void show (String [] str){
    	System.out.println("show");
    	for (int j = 0; j < str.length; j++) {
    		System.out.print(str[j]+'\t');
    	}
    	System.out.println();
    	}

    2.在main中写执行语句:

    	StringTest test = new StringTest ();
    //在StringTest类中声明的方法,要使用的话必须实例化一个StringTest的对象
    	test.show(new String[]{"aa","bb","cc"});
    	
    	String [] arr = new String [] {"dd","ee","ff"};
    	test.show(arr);
    		
    //错误写法:	test.show("qq","ww","ee");
    //因为形参只能放数组

    3.结果:

     

    public class StringTest {
    	public static void main(String[] args) {
    		
    		StringTest test = new StringTest ();
    //在StringTest类中声明的方法,要使用的话必须实例化一个StringTest的对象
    		test.show(new String[]{"aa","bb","cc"});
    	
    		String [] arr = new String [] {"dd","ee","ff"};
    		test.show(arr);
    }
    }

    第二种是以 。。。为形参的新版本万金油用法

    1.下面定义了用。。。表示 0~∞个String参数的方法

    public void Show(String... str) {
    	System.out.println("Show");
    	for (int j = 0; j < str.length; j++) {
    		System.out.print(str[j]+'\t');
    	}
    	System.out.println();
    	}
    
    public void Show(int i, String... str) {
    	System.out.println("Show");
    	for (int j = 0; j < str.length; j++) {
    		System.out.print(str[j] + '\t' + i+'\t');
    	}
    	System.out.println();
    	}
    	
    不确定个	// public void show (String ... str , int i ){
    数的。。	// for(int j = 0 ; j<str.length ; j++){
    。必须放	// System.out.println(str[i]);
    在形参最	// }
    后	// }错误写法

    2.mian中写执行语句

    test.Show(arr);
    test.Show("ee","ff","gg");
    test.Show(6,"hh","ii","jj");

    3.结果:

     

    展开全文
  • Java可变形参

    2021-08-27 00:00:58
    Java可变个数形参 目录Java可变个数形参一、何谓可个数形参二、由来三...其实,就是方法的定义的时候不确定调用时的实参会传进来几个参数,所以定义为可变个数的形参,调用时传进来多少我都可以处理。 二、由来 Java
  • 1.采用数组形参来定义方法 public static void test(int a,String[] books); 如果没有参数,就要定义一空数组,或null student.test(null); 2.用JAVA中特有的...的方式来传递可变数量的参数 public static...
  • 关于Java形参 值传递 深浅Copy引言基本变量自定义对象String Integer特别的自定义变量以上的结果验证 引言 对本题目的思考源于很早之前从C转到Java的时候,老师给我们讲形参 和 java的值的传递的时候还有面向对象时 ...
  • 1. 背景从JDK1.5开始,Java支持数可变的形参,类似:public class ParamDemo {public static void main(String[] args) {String basketball = "篮球";String football = "足球";showSports(basketball, football);...
  • 实参与形参在jvm底层存放的的位置
  • Java里方法的参数传递方式只有一种:值...从JDK 1.5之后,Java允许定义形参个数可变的参数。如果在定义方法时,在最后一个形参的类型后增加三点(…),则表明该形参可以接受多参数值,多参数值被当成数组传入。
  • 我们知道如果创建方法时知道有几个参数,我们就可以直接定义好,假如我们创建方法的时候不知道具体有几个参数,只知道很多参数,这种方式怎么表示呢?
  • eg,Dog对象,我们要告诉它需要叫声:Dog(3); 我们可以这样说 方法会运用形参,调用的一方会调用实参 Dog d = new Dog(); d.bark(3);//这里的3就是我们定义的实参 void bark(int numOfBarks){//把3赋给...
  • Java 形参与实参

    千次阅读 多人点赞 2017-12-01 18:55:17
    转自:https://dailycast.github.io/Java-形参与实参/  前天在头条上看到一道经典面试题,引发了一些思考。也是写这篇文章的导火索。 背景 请看题: 1 2 3 4 5 6 7 8 9 10 11 12 13 public class Main...
  • 首先Java里面都是值传递,也就是形参的值改变是不会改变实参的值的。
  • 如题,方法里两个形参,我另一文件类中一方法想要那个方法的返回值,可是第二参数在这里用不到,能否只传第一参数 如何实现,前提这类不能继承后重写方法,因为多人合同写的。
  • 个Java方法能使用多少参数?

    千次阅读 2020-08-03 07:50:53
    }这让非常好奇一方法能够多少类型参数呢?据我所知,Java的语言规范并没有提到这问题。1 关于在实现上这阈值的定义,我有两猜测: 编译器会强制一可预测的阈值,例如255或者65535。 由于实现细节的...
  • 工程的流程是基于C/C++语言进行底层的算法开发,再通过JNI获取结果,并拿到Java层运用。那么这里就要涉及到三层数据或值得传递了...在不改变已的接口形式的前提下,如何增加一个形参然后通过形参将值传递到Java层呢。
  • Java 方法的使用(方法重载、形参和实参调用关系、方法递归)前言一、方法重载二、实参和形参的传递三、方法递归 前言 提示: 本文介绍了方法的三种实际的使用 方法重载、实参与形参传递的形式(画内存图)方法...
  • 函数实参和函数形参可以同名

    千次阅读 2021-03-07 21:38:37
    (4.0分)【其它】设计一一维数组的排序函数p_sort,并调用它对10整数进行排序。p_sort函数原型如下: void p_sort(int *p,int n) 其中,p是指向int型一维数组的指针变量,n是数组长度。 (16.0分)【单选题】如下...
  • package com.atguigu.java1;... 当调用可变形参的方法时,传入的参数数可以是:0,1,2... > 可变形参的方法,与本类中方法名相同、参数列表不同的方法,也构成重载 > 可变数...
  • 个有元素,一个没有元素。 让Optional作为一个接口并让两个不同的实现代替实现该接口不是更好的选择吗? 毕竟,这就是我们通常被教导要使用的一种面向对象的语言。 在本文中,我们将了解当前Optional实现的一些...
  • java中的形参为引用类型的问题

    千次阅读 2016-12-22 00:07:54
    前几天课堂上的一个程序,看了好久始终还是没明白,课堂上老师也测试了很多,今天时间看,我也来了几个程序测试了一下,但是然而没有发现什么不对,后面只能依靠百度了落,也查了比较久吧,终于还是明白了,今天...
  • Java实参和形参与传值和传引用

    千次阅读 2017-02-18 09:25:14
    实参和形参的定义: 形参出现函数定义中,在整个函数体内都可以使用,离开函数则不能使用。 实参出现在主函数中,进入被调函数后,实参变量也不能使用。 形参和实参的功能是做数据传送。...因此,形参只有在函数内部
  • 形参:方法声明时包含的参数声明实参:调用方法时,实际传给形参的参数值Java方法的参数传递机制:Java方法的参数传递只有一种:值传递。所谓值传递,就是将实际参数值的副本,传入方法内,而参数本身不会收到任何...
  • 今天阅读了一写的非常棒的博文,通过此博文再次复习了Java中参数传递的知识(即值传递与引用传递的区别)。参考网站http://www.cnblogs.com/binyue/p/3862276.html。下面我将通过次博文记录自己的理解,还望能够...
  • 今天写红黑树的时候碰到基础问题,涉及到引用对象,形参和内存空间之间的联系 操作流程 Node节点类 class Node{ private Node parentNode; private Node leftNode; private Node rightNode; private int val; ...
  • Java可变形参是jdk 5.0新增的内容,熟练使用可以方便我们的编程 下面我来详细介绍一些可变形参的注意事项及使用方法。
  • java如何实现不固定数传参

    千次阅读 2021-02-28 12:03:55
    Marydonjava如何实现不固定数传参(定义实参数可变的方法)参考链接:原文链接传统方法:为这方法定义一数组型的参数,将不确定的参数放到数组中,把这数组作为一实参传递过去举例://定义带数组型参数...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 40,581
精华内容 16,232
关键字:

java形参有几个