Java形参和实参的实例之Integer类型与Int类型用法说明

经常会有这样一道面试题,有两个整形变量分别是a = 1 ,b = 2。编写一个方法swap互换他们的值。


class
 
Main
 
{




   
public
 
static
 
void
 main
(
String
[]
 args
)
 
{




      
Integer
 a 
=
 
1
;




      
Integer
 b 
=
 
2
;




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




      swap
(
a
,
 b
);




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


  
}




 
private
 
static
 
void
 swap
(
Integer
 numa
,
 
Integer
 numb
)
 
{




     
//请实现




    
}




  }




1、首先大家看到这到题目后,仔细看后,在main方法中变量a和b的类型是Integer,而不是Int类型,因为这里涉及到了java的基本类型,Int是属于Java的基本类型,基本类型在调用swap的方法时,是修改不了变量a和b的值,说到这里涉及到另一个知识点了,那就是形参和实参的区别,值传递和引用传递的区别,下面慢慢说啊。

2、形参和实参的区别

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

形参顾名思义:就是形式参数,用于定义方法的时候使用的参数,是用来接收调用者传递的参数的,形参只有在方法被调用的时候,虚拟机才会分配内存单元,在方法调用结束之后便会释放所分配的内存单元。因此,形参只在方法内部有效,所以针对引用对象的改动也无法影响到方法外。

以这到题目为例,方法swap
(
Integer
 numa
,
 
Integer
 numb
)中的numa和numb是形参,
而在main方法中 传递给swap
(
a
,
 b
)中的a和b是实参。

3、值传递和引用传递的区别

值传递调用过程只能把实参传递给形参,而不能把形参的值反向作用到实参上。在函数调用过程中,形参的值发生改变,而实参的值不会发生改变,函数接收的是原始值的一个copy,此时内存中存在两个相等的基本类型,即实际参数和形式参数,后面方法中的操作都是对形参这个值的修改,不影响实际参数的值。说到这里就明白了题目中声明a和b的数据类型不为Int的原因了吧。

引用传递也称为 地址传递, 址传递,引用传递调用的机制中,实际参数的引用(地址,而不是参数的值)被传递给方法中相对应的形式参数,函数接收的是原始值的内存地址在方法执行中,形参和实参内容相同,指向同一块内存地址,方法执行中对引用的操作将会影响到实际对象。说到这里就明白了题目中声明a和b的数据类型为Integer的原因了吧。

4、完成swap
方法实现


 
static
 
void
 swap
(
Integer
 numa
,
 
Integer
 numb
)
 
{




  
Integer
 tmp 
=
 numa
;




  numa 
=
 numb
;




  numb 
=
 tmp
;




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




  
}




是不是感觉挺简单,但是运行后main方法中的a和b的值没有互换,分别还是a = 1 ,b = 2。那这是为什么呢?因为Interger虽然是引用类型,但是Integer在方法中没有提供value的get和set方法,也是对对象的安全保护,也就是传递过程中在Integer里面copy了一个副本指向值,而不是引用地址,是不是没有办法了,这就涉及到反射的用法,我们用反射改变Integer内部的value属性值。

static
 
void
 swap
(
Integer
 numa
,
 
Integer
 numb
)
 
{




     
Integer
 tmp 
=
 numa
;




      
try
 
{




          
Field
 field 
=
 
Integer
.
class
.
getDeclaredField
(
"value"
);




          field
.
setAccessible
(
true
);




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




          field
.
set
(
numb
,
 tmp
);
 


         
}
 
catch
 
(
Exception
 e
)
 
{




         e
.
printStackTrace
();




         
}




 
}




是不是感觉大功告成了,但是运行以后,a 和b的值都变为2。难道
Integer
 tmp 
=
 numa
;


 是这句话的问题吗,因为numa对象的值已经是2了,那这样的话tmp对象也是2,所以a 和b的值都变为2,那咱们把这句话改一下试试对不对。

static
 
void
 swap
(
Integer
 numa
,
 
Integer
 numb
)
 
{




     int tmp = numa.intValue();

      
try
 
{




          
Field
 field 
=
 
Integer
.
class
.
getDeclaredField
(
"value"
);




          field
.
setAccessible
(
true
);




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




          field
.
set
(
numb
,
 tmp
);
 


         
}
 
catch
 
(
Exception
 e
)
 
{




         e
.
printStackTrace
();




         
}




 
}




这是应该没有问题,但是运行后,a 和b的值还都是2。我真想说真二,这是为什么呢?这样试一下,咱们把a和b的初始改为a = 199,b = 299,再试一下。经过运行后发现a 和b的值成功互换。这是为什么呢?难道和数值的大小有关系吗?我们再变一种写法试试。


static
 
void
 main
(
String
[]
 args
)
 
{




  
  Integer
 a 
=
 
new
 
Integer
(
1
);




   
Integer
 b 
=
 
new
 
Integer
(
2
);




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




   swap
(
a
,
 b
);




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




   
}




   
 private
 
static
 
void
 swap
(
Integer
 numa
,
 
Integer
 numb
)
 
{




    
int
 tmp 
=
 numa
.
intValue
();




     
try
 
{




          
Field
 field 
=
 
Integer
.
class
.
getDeclaredField
(
"value"
);




         field
.
setAccessible
(
true
);




         field
.
set
(
numa
,
 numb
);




         field
.
set
(
numb
,
 tmp
);




         
}
 
catch
 
(
Exception
 e
)
 
{




         e
.
printStackTrace
();




   
}




  
}




运行以后,a 和b的值成功互换,a = 2, b = 1。那这又是为什么呢?难道和装箱和拆箱有关系吗,为什么 Integer a = 1 和 Integer a = new Integer(1) 效果不一样了,当Integer a = 1;时,编译器会将其转化为Integer a = Integer.valueOf(1); 但是数值分别是199和299 怎么又正常了呢,通过看源码Integer.valueOf 的方法

下面大家可以验证一下,理解默认的Integer缓存int常量值的范围

System.out.println(127==127); //true , int type compare
System.out.println(128==128); //true , int type compare
System.out.println(new Integer(127) == new Integer(127)); //false, object compare
System.out.println(Integer.parseInt("128")==Integer.parseInt("128")); //true, int type compare
System.out.println(Integer.valueOf("127")==Integer.valueOf("127")); //true ,object compare, because IntegerCache return a same object
System.out.println(Integer.valueOf("128")==Integer.valueOf("128")); //false ,object compare, because number beyond the IntegerCache
System.out.println(Integer.parseInt("128")==Integer.valueOf("128")); //true , int type compare

通过阅读源码发现,Integer.valueOf 方式初始化一个 Interger因为有 缓存了 -128-127的数字,再看 field.set(numb,tmp); 我们打断点,发现通过反射设置 value时 竟然走了 Integer.valueOf 方法。

大家可以在代码中验证一下,在 field
.
set
(
numa
,
 numb
);


后增加 System.out.println("tmp3="+new Integer(tmp));

System.out.println("tmp4="+Integer.valueOf(tmp)); 运行后,发现打印的tmp3 = 1 ,tmp4 = 2 , 说到这里大家明白其中的原因了吧。

最后正确的swap方法是:

static
 
void
 swap
(
Integer
 numa
,
 
Integer
 numb
)
 
{




 
int
 tmp 
=
 numa
.
intValue
();




  
try
 
{




      
Field
 field 
=
 
Integer
.
class
.
getDeclaredField
(
"value"
);




      field
.
setAccessible
(
true
);




      field
.
set
(
numa
,
 numb
);




      field
.
set
(
numb
,
 
new
 
Integer
(
tmp
));


//避免从缓冲取值

  
}
 
catch
 
(
Exception
 e
)
 
{




      e
.
printStackTrace
();




     
}




 
}




补充知识:java 传递参数的两种方式讲解

Java中没有指针,所以也没有引用传递了,仅仅有值传递不过可以通过对象的方式来实现引用传递 类似java没有多继承 但可以用多次implements 接口实现多继承的功能

值传递:方法调用时,实际参数把它的值传递给对应的形式参数,方法执行中形式参数值的改变不影响实际参 数的值。

引用传递:也称为传地址。方法调用时,实际参数的引用(地址,而不是参数的值)被传递给方法中相对应的形式参数,在方法执行中,对形式参数的操作实际上就是对实际参数的操作,方法执行中形式参数值的改变将会影响实际参数的值。

a.传递值的数据类型:八种基本数据类型和String(这样理解可以,但是事实上String也是传递的地址,只是string对象和其他对象是不同的,string对象是不能被改变的,内容改变就会产生新对象。那么StringBuffer就可以了,但只是改变其内容。不能改变外部变量所指向的内存地址)。

b.传递地址值的数据类型:除String以外的所有复合数据类型,包括数组、类和接口

值传递的例子:

package com.other.test;

public class Test {
 public static void change(int i, int j) {
 int temp = i;
 i = j;
 j = temp;
 } 

 public static void main(String[] args) {
 int a = 3;
 int b = 4;
 change(a, b);
 System.out.println("a=" + a);
 System.out.println("b=" + b);
 }
}

输出的结果是 a=3 b=4,传递的值并不会改变原值

引用传递的例子:(数组)

package com.other.test;

public class Test {
 public static void change(int[] counts) {
 counts[0] = 6;
 System.out.println(counts[0]);
 } 

 public static void main(String[] args) {
 int[] count = { 1, 2, 3, 4, 5 };
 change(count);
 System.out.println(count[0]);
 }
}

输出结果是6 6 也就是引用的值改变了原来的值

引用传递的例子:(对象)

定义一个A对象:

package com.other.test;

public class A {
 int i = 0;
}

对上边对象操作的类:

package com.other.test;

public class Test {
 public static void add(A a) {
 //a = new A();  ①
 a.i++;
 } 

 public static void main(String args[]) {
 A a = new A();
 add(a);
 System.out.println(a.i );
 }
}

当把①注解掉时,输出的结果是1,当①没有注解是是0,原因是 a =new A();构造了新的A对象就不是传递的那个对象了。

看看String的情况:

package com.other.test;

public class Test {
 String str = new String("old");
 char[] ch = { 'a', 'b', 'c' };
 public static void main(String args[]) {
 Test ex = new Test();
 ex.change(ex.str, ex.ch);
 System.out.print(ex.str + " and ");
 System.out.println(ex.ch);
 } 

 public void change(String str, char ch[]) {
 str = "new";
 ch[0] = 'd';
 }
}

输出的结果的是 old and dbc也就是传递String并不会改变原值,而是创建了一个新值。 ch[]就是一个简单的数组的传递。

( 对象包括对象引用即地址和对象的内容)

String 比较特别,看过String 代码的都知道, String 是 final的。所以值是不变的。 函数中String对象引用的副本指向了另外一个新String对象,而数组对象引用的副本没有改变,而是改变对象中数据的内容.

对于对象类型,也就是Object的子类,如果你在方法中修改了它的成员的值,那个修改是生效的,方法调用结束后,它的成员是新的值,但是如果你把它指向一个其它的对象,方法调用结束后,原来对它的引用并没用指向新的对象。

Java参数,不管是原始类型还是引用类型,传递的都是副本(有另外一种说法是传值,但是说传副本更好理解吧,传值通常是相对传址而言)。

如果参数类型是原始类型,那么传过来的就是这个参数的一个副本,也就是这个原始参数的值,这个跟之前所谈的传值是一样的。如果在函数中改变了副本的值不会改变原始的值.

如果参数类型是引用类型,那么传过来的就是这个引用参数的副本,这个副本存放的是参数的地址。如果在函数中没有改变这个副本的地址,而是改变了地址中的值,那么在函数内的改变会影响到传入的参数。如果在函数中改变了副本的地址,如new一个,那么副本就指向了一个新的地址,此时传入的参数还是指向原来的地址,所以不会改变参数的值。

以上这篇Java形参和实参的实例之Integer类型与Int类型用法说明就是小编分享给大家的全部内容了,希望能给大家一个参考,也希望大家多多支持我们。

(0)

相关推荐

  • JAVA8 List<List<Integer>> list中再装一个list转成一个list操作

    我就废话不多说了,大家还是直接看代码吧~ List<Integer> collect = IntStream.range(1, 10).boxed().collect(Collectors.toList()); List<Integer> collect1 = IntStream.range(10, 20).boxed().collect(Collectors.toList()); List<List<Integer>> lists = new ArrayL

  • Java Integer.valueOf()和Integer.parseInt()的区别说明

    前言 大家都知道Integer类中有Integer.valueOf(String s)和Integer.parseInt(String s)两个静态方法,他们都能够将字符串转换为整型.说到这里你肯定会想同一个功能为什么要提供两个不同的方法,这不是浪费吗? 区别 Integer.parseInt(String s)将会返回int常量. Integer.valueOf(String s)将会返回Integer类型,如果存在缓存将会返回缓存中已有的对象. 使用不当将会产生的问题 由于Java的自动拆箱

  • Java Integer及int装箱拆箱对比

    示例代码: class BoxIntInteger { public static void main(String[] args) { Integer a = new Integer(10111); int b = 10111; boolean equal1 = a == b; boolean equal2 = a.equals(b); System.out.println(equal1); System.out.println(equal2); } } 反编译字节码: public stat

  • Java Integer.ValueOf()的一些了解

    本文是对 Integer.ValueOf()的一些了解,分享给大家 这道题有的人或许做过,也可能选对,但是这其中的道理你却不一定理解,在这里大牛走过,小白留下一起学习. 先来分析选型A,Integer i01 = 59,是一个装箱的过程,在进行i01 == i02的比较过程中,因为右边是整型,发生了拆箱的动作,所以进行了值得比较,所以返回true. 在这里拿出Integer a = 59,Integer b = 59,这种又会出现什么状况呢,如果按照装箱和拆箱来看就是true,如果按照对象来看,

  • 关于Java中你所不知道的Integer详解

    前言 本文主要给大家介绍了关于Java中Integer的相关内容,分享出来供大家参考学习,下面话不多说了,来一起看看详细的介绍吧. 实参形参 前些天看到朋友圈分享了一片文章<Java函数的传参机制--你真的了解吗?> 有些触发,之前也研究过Java的Integer,所以写下本文,希望对你有所帮助. 交换 首先来看一个示例. 请用Java完成swap函数,交换两个整数类型的值. public static void test() throws Exception { Integer a = 1,

  • Java AtomicInteger类使用方法实例讲解

    1.java.util.concurrent.atomic 的包里有AtomicBoolean, AtomicInteger,AtomicLong,AtomicLongArray, AtomicReference等原子类的类,主要用于在高并发环境下的高效程序处理,来帮助我们简化同步处理. 在Java语言中,++i和i++操作并不是线程安全的,在使用的时候,不可避免的会用到synchronized关键字.而AtomicInteger则通过一种线程安全的加减操作接口. 2.AtomicInteger

  • JAVA Integer类型自加实例详解

    JAVA语言中有一些基本数据类型,比如int,long,double... 这些数据类型可以支持一些运算操作符,其中对于int类型的++/--操作符 Integer类型是一个对象类型,居然也可以支持++运算,那么问题来了 一个Integer对象执行++操作之后还是原来那个对象吗? 测试代码 public class IntegerTest { @Test public void test() { Integer a = 1; System.out.println(System.identityH

  • Java形参和实参的实例之Integer类型与Int类型用法说明

    经常会有这样一道面试题,有两个整形变量分别是a = 1 ,b = 2.编写一个方法swap互换他们的值. 
class
 
Main
 
{


 
public
 
static
 
void
 main
(
String
[]
 args
)
 
{


 
Integer
 a 
=
 
1
;


 
Integer
 b 
=
 
2
;


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


  • java 实现将Object类型转换为int类型

    如何将Object类型转换为int类型 Object object = null; try { Integer.parseInt(object.toString()); } catch (NumberFormatException e) {} 也可以先判定一下是否是Integer //可以先判定一下是否是Integer Object object = "111"; if (object instanceof Integer) { Integer.parseInt(object.toSt

  • Java必踩的坑之方法中形参、实参传递

    首先亮明Java中方法参数传递的规则,这两点很重要: 如果实参是基本类型(包括包装类型)或者String,则实参不会变(传的是值): 如果实参是对象集合或者数组,则实参会改变(传的是引用). 上面这两条比较简单,笔者就不展开说了,这里只说一点,关于方法中引用的传递,很多人会踩坑,如下: 我们先以数组举例,如下代码,很简单的几行,大家猜一下会最终输出的结果是什么样子的呢? public class PassByValueDemo { public static void main(String[]

  • Java 字节数组类型(byte[])与int类型互转方法

    代码如下: public class CommonUtils { //高位在前,低位在后 public static byte[] int2bytes(int num){ byte[] result = new byte[4]; result[0] = (byte)((num >>> 24) & 0xff);//说明一 result[1] = (byte)((num >>> 16)& 0xff ); result[2] = (byte)((num >

  • java中long数据类型转换为int类型

    由int类型转换为long类型是向上转换,可以直接进行隐式转换,但由long类型转换为int类型是向下转换,可能会出现数据溢出情况: 主要以下几种转换方法,供参考: 一.强制类型转换 long ll = 300000; int ii = (int)ll; 二.调用intValue()方法 long ll = 300000; int ii= new Long(ll).intValue(); 三.先把long转换成字符串String,然后在转行成Integer long ll = 300000; i

  • C++形参与实参的区别实例解析

    本文以实例阐述了C++中形参与实参的区别,有助于读者加深对于C++形参与实参的认识. 形参出现在函数定义中,在整个函数体内都可以使用, 离开该函数则不能使用.实参出现在主调函数中,进入被调函数后,实参变量也不能使用. 形参和实参的功能是作数据传送.发生函数调用时, 主调函数把实参的值传送给被调函数的形参从而实现主调函数向被调函数的数据传送. 1.形参变量只有在被调用时才分配内存单元,在调用结束时, 即刻释放所分配的内存单元.因此,形参只有在函数内部有效. 函数调用结束返回主调函数后则不能再使用该

  • C语言中形参和实参详解及实例代码

    形式参数和实际参数 函数的参数分为形参和实参两种.在本小节中,进一步介绍形参.实参的特点和两者的关系.形参出现在函数定义中,在整个函数体内都可以使用,离开该函数则不能使用.实参出现在主调函数中,进入被调函数后,实参变量也不能使用.形参和实参的功能是作数据传送.发生函数调用时,主调函数把实参的值传送给被调函数的形参从而实现主调函数向被调函数的数据传送. 函数的形参和实参具有以下特点: 1.形参变量只有在被调用时才分配内存单元,在调用结束时,即刻释放所分配的内存单元.因此,形参只有在函数内部有效.函

  • Java方法的参数传递机制实例详解

    本文实例讲述了Java方法的参数传递机制.分享给大家供大家参考,具体如下: 参数传递机制 对于程序设计语言来说,一般方法(函数)的参数传递有两种:按值传递和按引用传递. 按值传递意味着当将一个参数传递给一个方法时,方法接收的是原始值的一个副本.因此,如果方法修改了该参数,仅改变副本,而原始值保持不变.按引用传递意味着当将一个参数传递给一个方法时,方法接收的是原始值的内存地址,而不是值的副本.因此,如果方法修改了该参数,调用代码中的原始值也随之改变. 需要注意的是,方法可以修改按引用传递的参数对应

  • Java游戏俄罗斯方块的实现实例

    Java游戏俄罗斯方块的实现实例 java小游戏主要理解应用java Swing,awt等基础组件的知识,通过本例应当掌握面向对象的知识. 实现代码: package cn.hncu.games; import java.awt.Color; import java.awt.Font; import java.awt.Graphics; import java.awt.event.ActionEvent; import java.awt.event.ActionListener; import

  • Java实现FTP服务器功能实例代码

    FTP(File Transfer Protocol 文件传输协议)是Internet 上用来传送文件的协议.在Internet上通过FTP 服务器可以进行文件的上传(Upload)或下载(Download).FTP是实时联机服务,在使用它之前必须是具有该服务的一个用户(用户名和口令),工作时客户端必须先登录到作为服务器一方的计算机上,用户登录后可以进行文件搜索和文件传送等有关操作,如改变当前工作目录.列文件目录.设置传输参数及传送文件等.使用FTP可以传送所有类型的文件,如文本文件.二进制可执

随机推荐