热门标签 | HotTags
当前位置:  开发笔记 > 编程语言 > 正文

Integeri=newInteger(0);的打印结果?

大家探讨一下这个啊,为什么add3(i);改变不了i的值?publicclasstest{publicstaticintadd3(Integeri){intvali.i
大家探讨一下这个啊,为什么add3(i);改变不了i的值?
public class test {
public static int add3(Integer i){
int val = i.intValue();
val+=3;
i = new Integer(val);
return i;
}
public static void main(String[] args){
Integer i = new Integer(0);
add3(i);
System.out.println(i.intValue());//结果还是0
}
}

30 个解决方案

#1


改不了就对了。
public class test {
    public static int add3(Integer i){
        int val = i.intValue();
        val+=3;     //你改是的val的值。这个val是方法变量。方法变量生命期到方法运行结束。
        i = new Integer(val); //你改的是参数i的值,参数也是方法变量,
        return i;
    }
    public static void main(String[] args){
        Integer i = new Integer(0);
        add3(i);
        System.out.println(i.intValue());//结果还是0
    }
}

#2


  public static void main(String[] args){
//i是一个对象你没执行方法直接输出i.intValue()
       Integer i = new Integer(0);
        i= add3(i);
        System.out.println(i.intValue());//结果还是0
    }

按LZ的意思
 static Integer i = new Integer(0);
 public static void main(String[] args){
       i= add3(i);
        System.out.println(i.intValue());//结果还是0
    }

#3



public class test {
    public static int add3(Integer i){
        Integer j = i;//多声明一个变量,调用该方法同时引用传进来的对象.
        int val = i.intValue();
        val+=3;
        i = new Integer(val);//这里i引用了一个新创建的对象,后边操作的就不再外边传进来的对象.所以返回的就是一新对象.并没有改变传进来的那个对象(j)
        return i;
    }
    public static void main(String[] args){
        Integer i = new Integer(0);
        add3(i);
        System.out.println(i.intValue());//结果还是0
    }
}



理解add3(Integer i)函数:
    我的名字叫add3,如果你想要调用我,请你给我一个Integer对象放到我的i里去,我将取出这个Integer的int值,并+3后重新创建一个新的Intger,它将由i引用(此时我的i将不再引用你的传进来的对象),我会将i返回.

由此可见,并没有修改传进来的Integer对象.

对比:

public static void addString(StringBuffer bf)
{
    bf.append("调用我的话将会增加字符串");
}
理解:addString(StringBuffer bf)函数:
   我的名字叫addString,如果你想调用我,请给我传一个StringBuffer对象,放到我的bf变量(引用)里,我将会给这个bf对象增加字符串:"调用我的话将会增加字符串".

上边的这个函数,每调用一次就会增加一次,如果我们多次调用它,并且传同个对象进去,那么就会有很多的:"调用我的话将会增加字符串"


public staic void main(String[]args)
{
  StringBuffer bf = new StringBuffer("");//创建好StringBuffer对象
   addString(bf);//将创建好的对象,传进去
   System.out.println(bf.toString());
  addString(bf);//再调用一次,传的同一个对象,会在上次调用的基础再增加字符串
  System.out.println(bf.toString());
}

#4


pass by value值传递!

#5


答案是0啊!你一直都没改变过main函数中i的值啊!

#6


形参和实参,局部变量

#7


看清变量作用域

#8


在add3()里你只是改变了i的引用,让其指向了另一个对象new Integer(3),i原来引用的对象的内容没有改变

#9


引用 1 楼 bigbug9002 的回复:
改不了就对了。 

Java codepublic class test {
    public static int add3(Integer i){
        int val = i.intValue();
        val+=3;     //你改是的val的值。这个val是方法变量。方法变量生命期到方法运行结束。
        i = new Integer(val); //你改的是参数i的值,参数也是方法变量,
        return i;
    }
    public static void main(String[] args){
        Integer i = new Integer(0);
       …

正解
public int add3(Integer i){
        int val = i.intValue();
        val+=3;
        i = new Integer(val);
        return i;
    }
    public static void main(String[] args){
        Integer i = new Integer(0);
        int a = new test().add3(i);
        //System.out.println(i.intValue());//结果还是0
        System.out.println(a);
    }

这样就行了
还有你的命名不符合规则,建议还是要养成习惯的好!

#10




public class Test {

    public static int add3(Integer i){
        Integer j = i;
        int val = i.intValue();
        return val+=3;
    }
    public static void main(String[] args){
        Integer i = new Integer(0);
        System.out.println(add3(i));
    }
}

原因楼上诸位回答过了~

#11


楼主问的是

为什么用 int 和Integer传进去结果还是一样的

意思就是为什么包装类也是值传递,

我也想问,这是为什么呢?

一个个不懂就别回答了!这个问题我也没查过,我确实也不明白

也就是说


    Integer i = new Integer(10);
    XXXXX(i);//这里的方法怎么写可以使下边打印出来的值不为10
    System.out.println(i);




#12


楼主的程序如果改成下面这样就可以得到期望的结果:
public class Test {
    public static Integer add3(Integer i){  //(1)返回值类型改成Integer
        int val = i.intValue();
        val+=3;
        i = new Integer(val);
        return i;
    }
    public static void main(String[] args){
        Integer i = new Integer(0);
        i = add3(i);                       //(2)把返回的Integer对象赋给i
        System.out.println(i.intValue());//结果还是0
    }
}

个人的解释有两点,楼主可以参考一下:
1.对于Integer这种包装类实际上是一种只读类,一旦生成是没有办法改变包装的int型数据的值,如果想利用原来的句柄,如main中的i,就只能让i指向另外一个Integer类,正如(2)中将返回值赋给了i。
2.在add3(Integer i)中传递的也是句柄,从另外一种意义上,句柄传递也是一种值传递。个人认为,由于在Java中没有了指针的概念,所以一些关于参数传递的问题不太好理解。下一个回复中我会说一下对于add3()中参数的传递过程(个人观点,仅供参考)

#13


add3()方法中参数的传递过程(个人观点,仅供参考):
(1)对于add3(i)的执行实际上是将  Integer(0) 这个对象的句柄传进add(3)方法,也就是说这是参数传递方法中的句柄传递方式。
(2)这是进入add3()方法调用,首先完成的工作是在栈区分配新的空间给Integer i(这里的i是形参,是局部变量),并将传进来的句柄赋给i,完成i的初始化,这时i指向的是外部的对象Integer(0);然后开始进入方法体执行实际的操作,其中i = new Integer(val); 这步操作又将一个新的对象Integer(val)的句柄赋给了i,这时i不仅与main方法里的i存储空间不一样,而且它们指向的对象也不一样,是两个完全没有关系的变量了……

                    

#14


return 回去又没赋值。

#15


引用 13 楼 leng017 的回复:
add3()方法中参数的传递过程(个人观点,仅供参考): 
(1)对于add3(i)的执行实际上是将  Integer(0) 这个对象的句柄传进add(3)方法,也就是说这是参数传递方法中的句柄传递方式。 
(2)这是进入add3()方法调用,首先完成的工作是在栈区分配新的空间给Integer i(这里的i是形参,是局部变量),并将传进来的句柄赋给i,完成i的初始化,这时i指向的是外部的对象Integer(0);然后开始进入方法体执行实际的操作,其中i = new…


有点类似值拷贝传递啊

#16


引用 11 楼 blliy117 的回复:
楼主问的是 

为什么用 int 和Integer传进去结果还是一样的 

意思就是为什么包装类也是值传递, 

我也想问,这是为什么呢? 

一个个不懂就别回答了!这个问题我也没查过,我确实也不明白 

也就是说 


Java code
    Integer i = new Integer(10);
    XXXXX(i);//这里的方法怎么写可以使下边打印出来的值不为10
    System.out.println(i);

首先Java中的参数传递都是值传递的,即给一个对象重新指向地址是不可以的,只能改变对象的内部状态
而Integer类的值域状态是private final的所以一定要改的话可以通过反射的方法

import java.lang.reflect.Field;

public class Test {
    public static void main(String[] args) throws Exception{
        Integer i = new Integer(10);
        changeIntegerValue(i);
        System.out.println(i);

    }
    
    public static Integer changeIntegerValue(Integer i) throws Exception {
        Field[] fields = i.getClass().getDeclaredFields();
        for(int j = 0; j < fields.length; j++) {
            //System.out.println(fields[j]);
        }
        fields[7].setAccessible(true);
        fields[7].setInt(i, 100);
        return i;
    }
}

#17


多看看函数的传值。

#18


引用 16 楼 zhuzhusany 的回复:
引用 11 楼 blliy117 的回复:
楼主问的是 

为什么用 int 和Integer传进去结果还是一样的 

意思就是为什么包装类也是值传递, 

我也想问,这是为什么呢? 

一个个不懂就别回答了!这个问题我也没查过,我确实也不明白 

也就是说 


Java code 
    Integer i = new Integer(10); 
    XXXXX(i);//这里的方法怎么写可以使下边打印出来的值不为10 
    System.out.println(i); 


首先Java中的参数传递都是…


总算有高人来了,谢谢啊

#19


3楼说得很详细了。

add3(Integer i)完成加3动作,但他传递出来的是它方法内的局部变量,而不是类中的实例变量Integer i = new Integer(0);

如果将实例变量Integer i = new Integer(0);为便于理解,将i改为Integer a = new Integer(0),
则add3(Integer i)的传值过程如下:
   1.add3(Integer i)中Integer i = a; //i 指向a所指向的Integer(0)对象,设为x。i为一个引用,相当于个指针
   2.int val = i.intValue();         // val = 0
   3.val+=3;                         // val = 3
   4.i = new Integer(val);           //i重新指向new Integer(val) 对象,设为y
   5.return i;                       //返回y对象,而不是最先传进来的x对象            

#20


形参跟实参的问题,对于非基本类型,形参相当于实参的副本,你只改变了形参的内容,但是实参并没有改变

public class test {
    public static int add3(Integer i){
        int val = i.intValue();
        val+=3;
        i = new Integer(val);
        return i;
    }
    public static void main(String[] args){
        Integer i = new Integer(0);
        int k = add3(i);
        System.out.println(i.intValue());//结果还是0
        System.out.println(K);//结果为3
    }
}

#21


有意思。

#22


2楼说的对

#23





public class test {
    public static int add3(Integer i){
        int val = i.intValue();
        val+=3;
        i = new Integer(val);
        return i;
    }
    public static void main(String[] args){
        Integer i = new Integer(0);
        i=add3(i);
        System.out.println(i.intValue());//结果还是0
    }
}


这样就把值改变了

#24


函数add3()中的引用i和main方法中的i不是同一个,虽然指向同一个Integer对象
参数传递,只是简单的把main中的i的值(即对象的地址)赋给add3中的i,从这个意义上来说就是值传递
所以i = new Integer(val);只是让add3中的i指向了新的对象,而main中的i不变
结果自然就是0
add3(i)的返回值再赋给i就可以了
代码这样就可以了

public class test {
    public static int add3(Integer i){
        i+=3;
        return i;
    }
    public static void main(String[] args){
        Integer i = new Integer(0);
        i=add3(i);                      //add3(i)的返回值赋给i
        System.out.println(i);//结果就是3了
    }
}

#25



public class test {
    public static int add3(Integer i){
        i+=3;
        return i;
    }
    public static void main(String[] args){
        Integer i = new Integer(0);
        i=add3(i);                      //add3(i)的返回值赋给i
        System.out.println(i);//结果就是3了
    }



不让编辑挺烦人

#26


楼主思维有点混乱啊,haha
public class test {
    public static int add3(Integer i){
        int val = i.intValue(); 
        val+=3;
        i = new Integer(val);
        return i;
    }
    public static void main(String[] args){
        Integer i = new Integer(0);
        add3(i);      //返回给谁????
        System.out.println(i.intValue());//结果还是0
    }
}
方法调用的5大步骤:1、开辟一个方法栈;2、参数传递;3、方法计算;4、返回值;5、消除这个方法栈
在该过程中,出现的所有临时变量都将随栈消除而等待回收;只有返回只有用!!你那个main()中的add3(i)返回给谁啊??这样就是一句没有用的语句。
看哈25楼。

#27


楼主:

查看Integer类的源码,可以发现

//Integer的属性
private final int value;

//Integer的构造器
public Integer(int value) {
this.value = value;
    }

value不可修改

传递的虽然是引用,但是,其中的value是不可修改类型

#28


说错了,我觉得是包装类,如:Integer,Double都是按值传递的

#29


Integer i = new Integer(0);
写成这样是对象啊,传参数的时候 传递的是 对象引用的副本,i 指向的对象并没有受到任何改变。
add3(i)这句是迷惑你的吧。程序里面 又没有接受他的返回值啊。
个人认为 add3(Integer i) 方法里的参数 因为也是i (同名) 可能影响了楼主的判断,如果改成其他的 比如 x y 可能更清楚一点。
另外建议 再看看 java基本类型的装箱 和拆箱。这到题目主要就是考这个的吧。

#30


java的参数传递都是值传递的,当一个变量作为参数传递给方法时,
java会拷贝变量的一个副本作为参数传递给方法
方法内部对该副本的一切修改不影响该变量

你在此传入了一个引用类型的Integer变量,所以java拷贝了该引用
传递给方法,此时该副本也和变量一样指向Integer(0)这个对象,
而方法内部对该参数做了更改,使他指向了一个新的对象Integer(3)
但此更改只是更改了原变量的副本,没有改变原变量,原变量依然指向Integer(0)

推荐阅读
  • Java太阳系小游戏分析和源码详解
    本文介绍了一个基于Java的太阳系小游戏的分析和源码详解。通过对面向对象的知识的学习和实践,作者实现了太阳系各行星绕太阳转的效果。文章详细介绍了游戏的设计思路和源码结构,包括工具类、常量、图片加载、面板等。通过这个小游戏的制作,读者可以巩固和应用所学的知识,如类的继承、方法的重载与重写、多态和封装等。 ... [详细]
  • Java容器中的compareto方法排序原理解析
    本文从源码解析Java容器中的compareto方法的排序原理,讲解了在使用数组存储数据时的限制以及存储效率的问题。同时提到了Redis的五大数据结构和list、set等知识点,回忆了作者大学时代的Java学习经历。文章以作者做的思维导图作为目录,展示了整个讲解过程。 ... [详细]
  • 个人学习使用:谨慎参考1Client类importcom.thoughtworks.gauge.Step;importcom.thoughtworks.gauge.T ... [详细]
  • 本文介绍了Swing组件的用法,重点讲解了图标接口的定义和创建方法。图标接口用来将图标与各种组件相关联,可以是简单的绘画或使用磁盘上的GIF格式图像。文章详细介绍了图标接口的属性和绘制方法,并给出了一个菱形图标的实现示例。该示例可以配置图标的尺寸、颜色和填充状态。 ... [详细]
  • 开发笔记:加密&json&StringIO模块&BytesIO模块
    篇首语:本文由编程笔记#小编为大家整理,主要介绍了加密&json&StringIO模块&BytesIO模块相关的知识,希望对你有一定的参考价值。一、加密加密 ... [详细]
  • JavaSE笔试题-接口、抽象类、多态等问题解答
    本文解答了JavaSE笔试题中关于接口、抽象类、多态等问题。包括Math类的取整数方法、接口是否可继承、抽象类是否可实现接口、抽象类是否可继承具体类、抽象类中是否可以有静态main方法等问题。同时介绍了面向对象的特征,以及Java中实现多态的机制。 ... [详细]
  • 本文讨论了一个关于cuowu类的问题,作者在使用cuowu类时遇到了错误提示和使用AdjustmentListener的问题。文章提供了16个解决方案,并给出了两个可能导致错误的原因。 ... [详细]
  • importjava.util.ArrayList;publicclassPageIndex{privateintpageSize;每页要显示的行privateintpageNum ... [详细]
  • 自动轮播,反转播放的ViewPagerAdapter的使用方法和效果展示
    本文介绍了如何使用自动轮播、反转播放的ViewPagerAdapter,并展示了其效果。该ViewPagerAdapter支持无限循环、触摸暂停、切换缩放等功能。同时提供了使用GIF.gif的示例和github地址。通过LoopFragmentPagerAdapter类的getActualCount、getActualItem和getActualPagerTitle方法可以实现自定义的循环效果和标题展示。 ... [详细]
  • 本文详细介绍了Java中vector的使用方法和相关知识,包括vector类的功能、构造方法和使用注意事项。通过使用vector类,可以方便地实现动态数组的功能,并且可以随意插入不同类型的对象,进行查找、插入和删除操作。这篇文章对于需要频繁进行查找、插入和删除操作的情况下,使用vector类是一个很好的选择。 ... [详细]
  • JDK源码学习之HashTable(附带面试题)的学习笔记
    本文介绍了JDK源码学习之HashTable(附带面试题)的学习笔记,包括HashTable的定义、数据类型、与HashMap的关系和区别。文章提供了干货,并附带了其他相关主题的学习笔记。 ... [详细]
  • 基于Socket的多个客户端之间的聊天功能实现方法
    本文介绍了基于Socket的多个客户端之间实现聊天功能的方法,包括服务器端的实现和客户端的实现。服务器端通过每个用户的输出流向特定用户发送消息,而客户端通过输入流接收消息。同时,还介绍了相关的实体类和Socket的基本概念。 ... [详细]
  • 重入锁(ReentrantLock)学习及实现原理
    本文介绍了重入锁(ReentrantLock)的学习及实现原理。在学习synchronized的基础上,重入锁提供了更多的灵活性和功能。文章详细介绍了重入锁的特性、使用方法和实现原理,并提供了类图和测试代码供读者参考。重入锁支持重入和公平与非公平两种实现方式,通过对比和分析,读者可以更好地理解和应用重入锁。 ... [详细]
  • 本文讨论了在VMWARE5.1的虚拟服务器Windows Server 2008R2上安装oracle 10g客户端时出现的问题,并提供了解决方法。错误日志显示了异常访问违例,通过分析日志中的问题帧,找到了解决问题的线索。文章详细介绍了解决方法,帮助读者顺利安装oracle 10g客户端。 ... [详细]
  • 本文整理了Java面试中常见的问题及相关概念的解析,包括HashMap中为什么重写equals还要重写hashcode、map的分类和常见情况、final关键字的用法、Synchronized和lock的区别、volatile的介绍、Syncronized锁的作用、构造函数和构造函数重载的概念、方法覆盖和方法重载的区别、反射获取和设置对象私有字段的值的方法、通过反射创建对象的方式以及内部类的详解。 ... [详细]
author-avatar
欧毅儒
这个家伙很懒,什么也没留下!
PHP1.CN | 中国最专业的PHP中文社区 | DevBox开发工具箱 | json解析格式化 |PHP资讯 | PHP教程 | 数据库技术 | 服务器技术 | 前端开发技术 | PHP框架 | 开发工具 | 在线工具
Copyright © 1998 - 2020 PHP1.CN. All Rights Reserved | 京公网安备 11010802041100号 | 京ICP备19059560号-4 | PHP1.CN 第一PHP社区 版权所有