java语言基础（二）——java变量传值

最新推荐文章于 2023-02-25 11:12:58 发布
最新推荐文章于 2023-02-25 11:12:58 发布
阅读量619 收藏
点赞数
分类专栏： Java语言 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/YongYu_IT/article/details/44559101
版权

一、先介绍一个查看变量内存信息的的方法： int java.lang.System.identityHashCode(Object arg0)

        这个方法是System类中的静态方法，用于根据对象内存地址来计算哈希值。

        identityHashCode是用稳定算法根据对象的物理地址计算得到的，所以任何两个不同的对象identityHashCode值一定不等。任何相同的对象identityHashCode值一定相等。

二、传值问题从本质上说是赋值问题。例如，函数调用时的传值问题，实际上就是实参为形参赋值的问题。函数返回值的传值问题实际上就是return变量为接收函数返回值的变量赋值的问题。

三、变量间传值问题。

1、回顾一下java里的数据类型：

java里面的数据类型分为两种：基本类型（primitive types）；引用类型（reference types）

java语言提供了八种基本类型。其中，六种属于数字类型（四个整数型，两个浮点型），一种字符类型，一种布尔类型。

除了上述八种基本类型以外的所有数据类型均属于引用类型。

归纳见下表：


1、基本类型

java语言提供了八种基本类型。其中，六种属于数字类型（四个整数型，两个浮点型），一种字符类型，一种布尔类型。详见下表：

基本类型是构成引用类型的基础。基本类型没有父类，不是继承自Object类。基本类型的值一般称之为简单对象。简单对象的创建无需借助于new关键字。简单对象存放于栈区，具有更高的存取效率。

引用数据类型均是Object类的子类。除了上述八种基本类型外，其他java数据类型均为引用类型。引用类型的对象（实例）一般称之为复杂对象。复杂对象的实例化必须借助于new关键字。复杂对象均存放于堆区。

* 注意：有些复杂对象，如基本类型对应的包装类的对象，其创建虽然也可以不借助new关键字，但是这只是表象。从本质上讲这些对象是先由new关键字创建，然后再为复杂对象的属性赋值。

4、基本类型变量间传值的问题：

public class PrimitiveTypesTest
{
    public static void main(String[] args)
    {
        int a = 0;
        int b = a;
        System.out.println("a=" + a + " --> " + System.identityHashCode(a));
        System.out.println("b=" + b + " --> " + System.identityHashCode(b));
        b++;
        System.out.println("a=" + a + " --> " + System.identityHashCode(a));
        System.out.println("b=" + b + " --> " + System.identityHashCode(b));
        a++;
        System.out.println("a=" + a + " --> " + System.identityHashCode(a));
        System.out.println("b=" + b + " --> " + System.identityHashCode(b));
        System.out
                .println("-------------------------------------------------------");
        char cha_a = 'A';
        char cha_b = cha_a;
        System.out.println("cha_a=" + cha_a + " --> "
                + System.identityHashCode(cha_a));
        System.out.println("cha_b=" + cha_b + " --> "
                + System.identityHashCode(cha_b));
        cha_b++;
        System.out.println("cha_a=" + cha_a + " --> "
                + System.identityHashCode(cha_a));
        System.out.println("cha_b=" + cha_b + " --> "
                + System.identityHashCode(cha_b));
        cha_a++;
        System.out.println("cha_a=" + cha_a + " --> "
                + System.identityHashCode(cha_a));
        System.out.println("cha_b=" + cha_b + " --> "
                + System.identityHashCode(cha_b));
        System.out
                .println("-------------------------------------------------------");
        double c = 0;
        double d = c;
        System.out.println("c=" + c + " --> " + System.identityHashCode(c));
        System.out.println("d=" + d + " --> " + System.identityHashCode(d));
        d++;
        System.out.println("c=" + c + " --> " + System.identityHashCode(c));
        System.out.println("d=" + d + " --> " + System.identityHashCode(d));
        c++;
        System.out.println("c=" + c + " --> " + System.identityHashCode(c));
        System.out.println("d=" + d + " --> " + System.identityHashCode(d));
    }
}

运行结果：

a=0 --> 366712642
b=0 --> 366712642
a=0 --> 366712642
b=1 --> 1829164700
a=1 --> 1829164700
b=1 --> 1829164700
-------------------------------------------------------
cha_a=A --> 2018699554
cha_b=A --> 2018699554
cha_a=A --> 2018699554
cha_b=B --> 1311053135
cha_a=B --> 1311053135
cha_b=B --> 1311053135
-------------------------------------------------------
c=0.0 --> 118352462
d=0.0 --> 1550089733
c=0.0 --> 865113938
d=1.0 --> 1442407170
c=1.0 --> 1028566121
d=1.0 --> 1118140819

我们可以得出结论：两个基本类型变量传值发生之后，对其中任何一个变量的修改不会影响另外一个变量。

5、引用类型变量间传值的问题

public class ReferenceTypesTest
{
    public static void main(String[] args)
    {
        TestObj a = new TestObj();
        a.name = "aaa";
        TestObj b = a;
        System.out.println("a.name=" + a.name + " --> "
                + System.identityHashCode(a));
        System.out.println("b.name=" + b.name + " --> "
                + System.identityHashCode(b));
        b.name = "bbb";
        System.out.println("a.name=" + a.name + " --> "
                + System.identityHashCode(a));
        System.out.println("b.name=" + b.name + " --> "
                + System.identityHashCode(b));
        a.name = "aaaaaa";
        System.out.println("a.name=" + a.name + " --> "
                + System.identityHashCode(a));
        System.out.println("b.name=" + b.name + " --> "
                + System.identityHashCode(b));
        System.out
                .println("-------------------------------------------------------");
        int[] array_a = new int[] { 0 };
        int[] array_b = array_a;
        System.out.println("array_a=" + array_a[0] + " --> "
                + System.identityHashCode(array_a));
        System.out.println("array_b=" + array_b[0] + " --> "
                + System.identityHashCode(array_b));
        array_b[0]++;
        System.out.println("array_a=" + array_a[0] + " --> "
                + System.identityHashCode(array_a));
        System.out.println("array_b=" + array_b[0] + " --> "
                + System.identityHashCode(array_b));
        array_a[0]++;
        System.out.println("array_a=" + array_a[0] + " --> "
                + System.identityHashCode(array_a));
        System.out.println("array_b=" + array_b[0] + " --> "
                + System.identityHashCode(array_b));
    }
}
class TestObj
{
    public String name;
}

运行结果：

a.name=aaa --> 366712642
b.name=aaa --> 366712642
a.name=bbb --> 366712642
b.name=bbb --> 366712642
a.name=aaaaaa --> 366712642
b.name=aaaaaa --> 366712642
-------------------------------------------------------
array_a=0 --> 1829164700
array_b=0 --> 1829164700
array_a=1 --> 1829164700
array_b=1 --> 1829164700
array_a=2 --> 1829164700
array_b=2 --> 1829164700

我们可以得出结论：两个引用类型变量传值发生之后，对其中任何一个变量的修改等价于对另一个变量的修改。

 6、特殊的引用类型——包装类（Wrapper Class）

public class WrapperClassTest
{
    public static void main(String[] args)
    {
        Integer a = 0;
        Integer b = a;
        System.out.println("a=" + a + " --> " + System.identityHashCode(a));
        System.out.println("b=" + b + " --> " + System.identityHashCode(b));
        b++;
        System.out.println("a=" + a + " --> " + System.identityHashCode(a));
        System.out.println("b=" + b + " --> " + System.identityHashCode(b));
        a++;
        System.out.println("a=" + a + " --> " + System.identityHashCode(a));
        System.out.println("b=" + b + " --> " + System.identityHashCode(b));
        System.out
                .println("-------------------------------------------------------");
        Character cha_a = 'A';
        Character cha_b = cha_a;
        System.out.println("cha_a=" + cha_a + " --> "
                + System.identityHashCode(cha_a));
        System.out.println("cha_b=" + cha_b + " --> "
                + System.identityHashCode(cha_b));
        cha_b++;
        System.out.println("cha_a=" + cha_a + " --> "
                + System.identityHashCode(cha_a));
        System.out.println("cha_b=" + cha_b + " --> "
                + System.identityHashCode(cha_b));
        cha_a++;
        System.out.println("cha_a=" + cha_a + " --> "
                + System.identityHashCode(cha_a));
        System.out.println("cha_b=" + cha_b + " --> "
                + System.identityHashCode(cha_b));
        System.out
                .println("-------------------------------------------------------");
        Double c = 0.0;
        Double d = c;
        System.out.println("c=" + c + " --> " + System.identityHashCode(c));
        System.out.println("d=" + d + " --> " + System.identityHashCode(d));
        d++;
        System.out.println("c=" + c + " --> " + System.identityHashCode(c));
        System.out.println("d=" + d + " --> " + System.identityHashCode(d));
        c++;
        System.out.println("c=" + c + " --> " + System.identityHashCode(c));
        System.out.println("d=" + d + " --> " + System.identityHashCode(d));
    }
}

运行结果：

a=0 --> 366712642
b=0 --> 366712642
a=0 --> 366712642
b=1 --> 1829164700
a=1 --> 1829164700
b=1 --> 1829164700
-------------------------------------------------------
cha_a=A --> 2018699554
cha_b=A --> 2018699554
cha_a=A --> 2018699554
cha_b=B --> 1311053135
cha_a=B --> 1311053135
cha_b=B --> 1311053135
-------------------------------------------------------
c=0.0 --> 118352462
d=0.0 --> 118352462
c=0.0 --> 118352462
d=1.0 --> 1550089733
c=1.0 --> 865113938
d=1.0 --> 1550089733

这说明：包装类变量间传值的特性与基本数据类型类似

7、由此我们总结可以得出如下结论：

两个基本类型变量传值发生之后，对其中任何一个变量的修改不会影响另外一个变量。

两个引用类型变量传值发生之后，对其中任何一个变量的修改等价于对另一个变量的修改。

其中，包装类变量间传值例外，它遵守基本类型变量间传值的规则。






YongYu_IT
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java SE学习笔记——局部变量和成员变量在内存中的存放
weixin_46012586的博客
07-09 919
java SE学习笔记——局部变量和成员变量在内存中的存放 本文记录了关于变量和内存使用的一些笔记，主要有局部变量和成员变量的区别，在内存中的存放，以及Java中基本类型和引用类型的变量的区别，以及其在内存中的存放。 JVM内存区域划分 而这其中的本地方法栈和程序计数器与我们的开发关系不大，此处先将其省略，本文中需要用到的是下图中的三块内容（下图中的栈即为上图中的虚拟机栈）。 基本类型和引用类型 基本类型 Java语言提供了八种基本类型。六种数字类型（四个整数型，两个浮点型），一种字符类型，还有一
Java学习（四）—— 方法操作实例变量
North_City_的博客
07-10 912
系列文章目录 一：上手 二：类和对象 三：primitive主数据类型和引用 四：方法操作实例变量 文章目录系列文章目录前言1、方法操作实例变量2、传值给方法3、封装4、实例变量4、变量的比较 前言 行百里者半九十 1、方法操作实例变量 同一类型的不同对象能有不同的行为方法吗？ 答案是可以的。 任一类的每个实例都带有相同的方法，但方法可以根据实例变量的值来表现不同的行为。比如说，不同体型的狗子会有不同的叫声。 class Dog { int size; void bark() { if
Java变量之间传值- 值传递还是引用传递的讨论
matricer的博客
09-17 3181
Java变量之间传值时可分为值传递和引用传递, 那么它们有何区别？   1. 简单类型是按值传递的     Java 方法的参数是简单类型的时候，是按值传递的(pass by value)，需要注意的是，对于基本类型的包装类型，因为JVM的自动拆箱操作，包装类型变成基本类型后也会按基本类型来进行操作，那么也是按值进行传递。这一点我们可以通过一个简单的例子来说明：  
java中变量的传递_在Java中如何将变量从一个类传递到另一个类?
weixin_31125161的博客
02-13 1281
我试图将变量从一个类传递到另一个类。我有三门课,如下所示。public class OvalPanel extends JPanel {//declare variablespublic OvalPanel() {//create panel hereovalShape = new OvalShape();ovalShape.setMyColor(255, 255, 255);//set layo...
java程序中执行maven_java – 将一个enviornment变量传递给Maven中的已执行进程
weixin_33045961的博客
02-26 153
我一直在墙上撞了大约一个小时：我正试图将一个简单的属性(java.library.path)传递给exec-maven-plugin.目标是将其与Netbeans右键单击文件集成>运行文件过程.所以我把我的POM设置成这样：org.codehaus.mojoexec-maven-plugin1.1.1native/win32-x86(我使用旧版本,所以我可以看到执行参数,但它完全可以重现1....
java基础深入_java编程基础之方法深入
weixin_42537499的博客
02-15 110
大纲方法入门概述前讲解的循环操作，可以解决的是代码重复的问题，但是此时的重复的代码必须是有规律的。那循环操作，能解决所有的代码重复吗?答案肯定是不行的，比如针对于某一种功能的重复操作，循环就无法实现,我们可以使用方法.编写一个飞机大战游戏，程序在运行过程中，需要不断地发射子弹。假设发射子弹功能需要编写200行代码，那么，每次发射子弹都需要重复地编写这200行代码，这样的程序太low了。在开发中我们...
java void传参_Java方法传参
weixin_29479879的博客
02-16 404
1、创建students类-----//主要构造对象2、创建calc类---------//主要构造方法publicclasscalc{publicvoidcalc1(intnum){num=num+1;}publicvoidcalc2(studentsstu){stu.setAge(stu.getAge()+1);}}3、创建calcDemo类-----//传参publ...
第02章 Java编程基础 01 变量与标识符
最新发布
09-13
在Java中，还有一种特殊的变量——常量，它们一旦被赋值后就不能改变。可以使用关键字final来声明常量，例如`final int PI = 3.14159;`。 除了变量和标识符，Java的访问修饰符也是编程基础的一部分。public、...
JAVA基础语法——方法的定义与使用
m0_58421666的博客
04-12 2868
一、方法的基本用法 1.什么是方法（method） 2.方法的定义语法 3.方法的调用执行过程 4.实参和形参的关系（重要） 5.没有返回值的方法 二、方法的重载 三、方法递归 1.什么是方法递归 2.什么场景下能用方法递归 3.如何写出递归代码 4.递归的执行过程
Java学习笔记03——类与对象
qq_45033269的博客
02-25 462
Java是一个面向对象的编程语言，基本类型并不具有对象的性质，为了让基本类型也具有对象的特征，就出现了包装类型。重载（Overload）是Java中多态的一种，重载的意思是，一个类中可以有多个同名的方法，但这些方法的参数必须不同。类体由两部分组成，一部分是变量的声明，另一部分是方法的定义，对成员变量的操作只能放在方法中，但可以在声明时对成员变量赋值。数组除了可以存放基本类型，也可以直接存放引用类型，需要注意的时，数组中存放引用类型时，存放的也不是实体，而是实体的引用。类声明的变量被称为对象变量，简称。
java 传递void,关于java：将参数从父级传递到public void run()
weixin_29035405的博客
03-20 426
我有50％的绝望：P。我尝试(在一开始)从线程的代码更新GUI，并得到了NullException。阅读一段时间后，我了解到该线程淹没了JavaFX应用程序窗口，并且为了使我能够从线程更新GUI，我需要使用以下代码：Platform.runLater(new Runnable() {@Override public void run() {//Update UI herefor (int i=0;...
Java中常用数据类型的父类
1 Byte 的博客
09-21 3731
1.1基本数据类型没有 父类。 System.out.println(int.class.getSuperclass()); System.out.println(double.class.getSuperclass()); System.out.println(char.class.getSuperclass()); System.out.println(byte.class.getSupe...
Java中变量的传值和传引用
HNUTheMao的博客
07-18 1150
Java中变量的传值和传引用 1.Java中变量的基本类型   为了了解Java中参数的传值和传引用，我们需要先知道Java中参数的基本类型，Java中数据类型分为两大类，基本类型和对象类型。相应的，变量也有两种类型：基本类型和引用类型。 基本类型的变量保存原始值，即它代表的值就是数值本身；而引用类型的变量保存引用值，"引用值"指向内存空间的地址，代表了某个对象的引用，而不是对象本身，对象本身存放...
在java方法中改变传递的参数的值
热门推荐
Maxwell_7
04-14 3万+
刚在写一个用例，需要在方法中改变传递的参数的值，可是java中只有传值调用，没有传址调用。所以在java方法中改变参数的值是行不通的。但是可以改变引用变量的属性值。 可以仔细理解一下下面几句话： 1、对于基本类型参数，在方法体内对参数进行重新赋值，并不会改变原有变量的值。 2、对于引用类型参数，在方法体内对参数进行重新赋予引用，并不会改变原有变量所持有的引用。  3、方法体内对参数进行
Java里的按值传递与引用传递
wan_xie2009的专栏
07-30 2196
这个在Java里面是经常被提起的问题，也有一些争论，似乎最后还有一个所谓的结论：“在Java里面参数传递都是按值传递”。事实上，这很容易让人迷惑，下面先分别看看什么是按值传递，什么是按引用传递，只要能正确理解，至于称作按什么传递就不是个大问题了。 1：按值传递是什么 指的是在方法调用时，传递的参数是按值的拷贝传递。示例如下： public class TempTest {
java void传参_java 方法传参方式: 按值调用
weixin_39801356的博客
02-13 593
程序设计语言中将参数传递给方法的几种方式:按名调用(call by name): Algol 语言采用此方式, 已成为历史;按值调用(call by value): 方法接收到的是调用者提供的 变量值;按引用调用(call by reference): 方法接受到的是调用者低筒的 变量地址;C++ 支持 按值调用 和 按引用调用:void func(int arg); // 按值调用;void f...
快速入门：Java基础02——关键字与main方法详解
第二章“标识符”介绍了如何在Java中命名变量、类和方法。标识符由26个英文字母（包括大小写）、数字0-9以及下划线(_)组成，但需要注意的是，标识符的命名不能以数字开头，也不能与Java的关键字相同。合法标识符的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值