引用类型 订阅
引用类型 由类型的实际值引用(类似于指针)表示的数据类型。如果为某个变量分配一个引用类型,则该变量将引用(或“指向”)原始值。不创建任何副本。引用类型包括类、接口、委托和装箱值类型。 展开全文
引用类型 由类型的实际值引用(类似于指针)表示的数据类型。如果为某个变量分配一个引用类型,则该变量将引用(或“指向”)原始值。不创建任何副本。引用类型包括类、接口、委托和装箱值类型。
信息
外文名
reference type
作    用
是为变量起一个别名
含    义
是c++的一种新的变量类型
中文名
引用类型
引用类型简介
(reference type)“引用”(reference)是c++的一种新的变量类型,是对C的一个重要补充。它的作用是为变量起一个别名。假如有一个变量a,想给它起一个别名,可以这样写:int a;int &b=a;这就表明了b是a的“引用”,即a的别名。经过这样的声明,使用a或b的作用相同,都代表同一变量。在上述引用中,&是“引用声明符”,并不代表地址。不要理解为“把a的值赋给b的地址”。引用类型的数据存储在内存的堆中,而内存单元中只存放堆中对象的地址。声明引用并不开辟内存单元,b和a都代表同一变量单元。注意:在声明引用变量类型时,必须同时使之初始化,即声明它代表哪一变量。在声明一个变量的引用之后,在本函数执行期间,该引用一直与其代表的变量相联系,不能再作为其他变量的别名。下面的用法不对:int a1,a2;int &b=a1;int &b=a2;//企图使b变成a2的别名(引用)是不行的。这样是错误的。我们可以把a2的值赋给b。b=a2;
收起全文
精华内容
下载资源
问答
  • java基本类型与引用类型

    万次阅读 多人点赞 2018-01-04 17:30:32
    java基本类型与引用类型 目录 java基本类型与引用类型 目录 一基本数据类型 二引用类型 三基本类型与引用类型的区别 默认值 内存分配 自动装箱自动拆箱 自动装箱拆箱带来的问题 程序的性能 空指针异常 ...

    java基本类型与引用类型


    目录

    一、基本数据类型

    java中一共分为8种基本数据类型:byte、short、int、long、float、double、char、boolean,其中byte、short、int、long是整型。float、double是浮点型,char是字符型,boolean是布尔型。

    二、引用类型

    java为每种基本类型都提供了对应的封装类型,分别为:Byte、Short、Integer、Long、Float、Double、Character、Boolean。引用类型是一种对象类型,它的值是指向内存空间的引用,就是地址。

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

    1.默认值

    整型byte、short、int、long的默认值都为0,浮点型float、double的默认值为0.0,boolean默认值为false,char默认值为空。对应的包装类型默认值都为null。

    2.内存分配

    基本数据类型的变量是存储在栈内存中,而引用类型变量存储在栈内存中,保存的是实际对象在堆内存中的地址,实际对象中保存这内容。

    3.自动装箱、自动拆箱

    Java从jdk1.5开始引入自动装箱和拆箱,使得基本数据类型与引用类型之间相互转换变得简单。

    自动装箱: java自动将原始类型转化为引用类型的过程,自动装箱时编译器会调用valueOf方法,将原始类型转化为对象类型。

    自动拆箱: java自动将引用类型转化为原始类型的过程,自动拆箱时编译器会调用intValue(),doubleValue()这类的方法将对象转换成原始类型值。

    自动装箱主要发生在两种情况:一种是赋值时,一种是方法调用时。
    a.赋值

    Integer a = 3; //自动装箱
    int b = a; //自动拆箱

    b.方法调用

    public Integer query(Integer a){
       return a;
    }
    query(3); //自动装箱
    int result = query(3); //自动拆箱

    4.自动装箱、拆箱带来的问题

    1.程序的性能

    由于装箱会隐式地创建对象创建,因此千万不要在一个循环中进行自动装箱的操作,下面就是一个循环中进行自动装箱的例子,会额外创建多余的对象,增加GC的压力,影响程序的性能:

    Integer sum = 0;
     for(int i=0; i<1000; i++){
       sum+=i;
    }

    2.空指针异常

    注意拆箱过程中可能产生的空指针异常,一个简单的例子:

    Object obj = null;
    int i = (Integer)obj;

    3.对象相等比较时

    先来看一个常见的例子:

    Integer a = 120;
    int b= 120;
    Integer c = 120;
    Integer d = new Integer(120);
    System.out.println(a == b);   //true    t1
    System.out.println(a == c);   //true    t2
    System.out.println(a == d);   //false   t3
    
    Integer e = 128;
    Integer f = 128;
    System.out.println(e == f);   //false    t4

    返回结果是不是出乎大家的意料,解释一下每种结果的原因:
    我们先反编译一下生成字节码:

    Integer a = Integer.valueOf(120);
    int b = 120;
    Integer c = Integer.valueOf(120);
    Integer d = new Integer(120);
    System.out.println(a.intValue() == b);
    System.out.println(a == c);
    System.out.println(a == d);
    
    Integer e = Integer.valueOf(127);
    Integer f = Integer.valueOf(127);
    System.out.println(e == f);
    
    Integer e1 = Integer.valueOf(128);
    Integer f1 = Integer.valueOf(128);
    System.out.println(e1 == f1);

    可以看到变量a、c在初始化的时候编译器调用了valueOf进行自动装箱,在a==b时对变量a调用了intValue()方法进行了自动拆箱操作,这就很好解释t1~t4的结果了。

    t1产生的原因是编译器编译时会调用intValue()自动的将a进行了拆箱,结果肯定是true;
    t2跟t4的结果比较难理解:这是因为初始化时,编译器会调用装箱类的valueOf()方法,查看jdk的源码:

    public static Integer valueOf(int i) {
        assert IntegerCache.high >= 127;
        if (i >= IntegerCache.low && i <= IntegerCache.high)
            return IntegerCache.cache[i + (-IntegerCache.low)];
        return new Integer(i);
    }

    发现jdk对-128~127之间的值做了缓存,对于-128~127之间的值会取缓存中的引用,通过缓存经常请求的值而显著提高空间和时间性能。
    这就能解释t2结果返回true,而t4由于128不在缓存区间内,编译器调用valueOf方法会重新创建新的对象,两个不同的对象返回false。

    t3结果无论如何都不会相等的,因为new Integer(120)构造器会创建新的对象。

    Byte、Short、Integer、Long、Char这几个装箱类的valueOf()方法都会做缓存,而Float、Double则不会,原因也很简单,因为byte、Short、integer、long、char在某个范围内的整数个数是有限的,但是float、double这两个浮点数却不是。

    展开全文
  • Java 基本类型与引用类型

    千次阅读 2019-03-27 20:55:51
    Java 基本类型与引用类型 一、基本数据类型 java 中一共分为 8 种基本数据类型:byte、short、int、long、float、double、char、boolean, 其中 byte、short、int、long 是整型。float、double 是浮点型,char 是...

    Java 基本类型与引用类型

    一、基本数据类型

    java 中一共分为 8 种基本数据类型:byte、short、int、long、float、double、char、boolean,
    其中 byte、short、int、long 是整型。float、double 是浮点型,char 是字符型,boolean 是布尔型。

    二、引用类型

    java 为每种基本类型都提供了对应的封装类型,分别为:Byte、Short、Integer、Long、Float、Double、Character、Boolean。引用类型是一种对象类型,它的值是指向内存空间的引用,就是地址。

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

    1. 默认值

    整型 byte、short、int、long 的默认值都为 0,浮点型 float、double 的默认值为 0.0,boolean 默认值为 false,char 默认值为空。对应的包装类型默认值都为 null。

    2. 内存分配

    基本数据类型的变量是存储在栈内存中,而引用类型变量存储在栈内存中,保存的是实际对象在堆内存中的地址,实际对象中保存这内容。

    3. 自动装箱、自动拆箱

    Java 从 jdk1.5 开始引入自动装箱和拆箱,使得基本数据类型与引用类型之间相互转换变得简单。

    自动装箱: java 自动将原始类型转化为引用类型的过程,自动装箱时编译器会调用 valueOf 方法,将原始类型转化为对象类型。

    自动拆箱: java 自动将引用类型转化为原始类型的过程,自动拆箱时编译器会调用 intValue(),doubleValue() 这类的方法将对象转换成原始类型值。

    自动装箱主要发生在两种情况:一种是赋值时,一种是方法调用时。

    a.赋值

    Integer a = 3; //自动装箱
    int b = a; //自动拆箱
    

    b.方法调用

    public Integer query(Integer a){
       return a;
    }
    query(3); //自动装箱
    int result = query(3); //自动拆箱
    

    4. 自动装箱、拆箱带来的问题

    (1)程序的性能
    由于装箱会隐式地创建对象创建,因此千万不要在一个循环中进行自动装箱的操作,下面就是一个循环中进行自动装箱的例子,会额外创建多余的对象,增加 GC 的压力,影响程序的性能:

    Integer sum = 0;
     for(int i=0; i<1000; i++){
       sum+=i;
    }
    

    (2)空指针异常
    注意拆箱过程中可能产生的空指针异常,一个简单的例子:

    Object obj = null;
    int i = (Integer)obj;
    

    (3)对象相等比较时
    先来看一个常见的例子:

    Integer a = 120;
    int b = 120;
    Integer c = 120;
    Integer d = new Integer(120);
    System.out.println(a == b);   //true    t1
    System.out.println(a == c);   //true    t2
    System.out.println(a == d);   //false   t3
    
    Integer e = 128;
    Integer f = 128;
    System.out.println(e == f);   //false    t4
    

    返回结果是不是出乎大家的意料,解释一下每种结果的原因:
    我们先反编译一下生成字节码:

    Integer a = Integer.valueOf(120);
    int b = 120;
    Integer c = Integer.valueOf(120);
    Integer d = new Integer(120);
    System.out.println(a.intValue() == b);
    System.out.println(a == c);
    System.out.println(a == d);
    
    Integer e = Integer.valueOf(127);
    Integer f = Integer.valueOf(127);
    System.out.println(e == f);
    
    Integer e1 = Integer.valueOf(128);
    Integer f1 = Integer.valueOf(128);
    System.out.println(e1 == f1);
    

    可以看到变量 a、c 在初始化的时候编译器调用了 valueOf 进行自动装箱,在 a==b 时对变量 a 调用了 intValue() 方法进行了自动拆箱操作,这就很好解释 t1~t4 的结果了。

    t1 产生的原因是编译器编译时会调用 intValue() 自动的将 a 进行了拆箱,结果肯定是 true;
    t2 跟 t4 的结果比较难理解:这是因为初始化时,编译器会调用装箱类的 valueOf() 方法,查看 jdk 的源码:

    public static Integer valueOf(int i) {
        assert IntegerCache.high >= 127;
        if (i >= IntegerCache.low && i <= IntegerCache.high)
            return IntegerCache.cache[i + (-IntegerCache.low)];
        return new Integer(i);
    }
    

    发现 jdk 对 -128 ~ 127 之间的值做了缓存,对于 -128~127 之间的值会取缓存中的引用,通过缓存经常请求的值而显著提高空间和时间性能。

    这就能解释 t2 结果返回 true,而 t4 由于 128 不在缓存区间内,编译器调用 valueOf 方法会重新创建新的对象,两个不同的对象返回 false。

    t3 结果无论如何都不会相等的,因为 new Integer(120) 构造器会创建新的对象。

    Byte、Short、Integer、Long、Char 这几个装箱类的 valueOf() 方法都会做缓存,而 Float、Double 则不会,原因也很简单,因为 byte、Short、integer、long、char 在某个范围内的整数个数是有限的,但是 float、double 这两个浮点数却不是。

    展开全文
  • Java引用类型

    千次阅读 2018-09-04 14:31:34
    Java引用类型的知识点详解。 引用类型:强引用、软引用、弱引用、虚引用 对像生命周期和可达性状态 引用队列 reachability fench(可达性栏杆) 引用类型 版本:2018/9/4-1(13:13) 引用类型 面试题 引用...

    转载请注明链接:https://blog.csdn.net/feather_wch/article/details/82383183

    Java引用类型的知识点详解。
    1. 引用类型:强引用、软引用、弱引用、虚引用
    1. 对像生命周期和可达性状态
    1. 引用队列
    1>. reachability fench(可达性栏杆)

    引用类型

    版本:2018/9/4-1(13:13)


    问题汇总

    1. 强引用、软引用、弱引用、幻想/虚引用有什么区别?具体的应用场景有哪些?
    2. 不同引用类型的体现的本质区别是什么?
    3. 强引用是什么?
    4. 什么时候具有引用的对象可以被回收?
    5. 软引用是什么?
    6. 软引用有什么用?软引用的使用场景?
    7. 弱引用是什么?
    8. 弱引用有什么用?
    9. 幻象引用/虚引用是什么?
    10. 虚引用有什么用?虚引用的使用场景?
    11. cleaner机制的特点
    12. Java中5种可达性的级别
    13. 强可达是什么?强引用状态?
    14. 软可达是什么?软引用状态?
    15. 弱可达是什么?弱引用状态?
    16. 幻象可达/虚可达是什么?幻想引用状态?
    17. 不可达状态?
    18. 有哪些方法能达到强引用效果?
    19. 【☆】Java对象会在该对象的方法执行完毕前被释放吗?何时会出现这种情况?
    20. Reference.reachabilityFence(object)方法是干什么的?
    21. 为什么需要Reachability Fence这种机制?
    22. 直接只运行这个代码会出错吗?为什么?:Executors.newSingleThreadExecutor().submit()
    23. reachabilityFence()方法的使用场景
    24. 如何使用reachabilityFence()?

    引用类型

    1、不同引用类型的体现的本质区别是什么?

    1. 体现的是对象不同的可达性状态
    2. 以及对垃圾回收的影响。

    3、强引用是什么?

    1. 常见的对象引用
    2. 只要对象有强引用,就表示该对象依然存活着。

    4、什么时候具有引用的对象可以被回收?

    1. 超过了引用的作用域
    2. 强引用 = null

    5、软引用是什么?

    1. SoftReference
    2. 相比于强引用要软一些,会去避免gc
    3. 在内存不足时,出现oom前,会将软引用对象回收。

    6、软引用有什么用?软引用的使用场景?

    1. 常用于缓存
    2. 内存足时能直接获取缓存;内存不足时会被释放。

    7、弱引用是什么?

    1. WeakReference
    2. 不能豁免GC,提供了一种没有特殊约束的关系
    3. 一个对象只有弱引用,会被直接GC。

    8、弱引用有什么用?

    1. 用于解决内存泄露

    9、幻象引用/虚引用是什么?

    1. PhantomReference
    2. 不能通过该引用来访问对象。
    3. 在对象finalize后,通过虚引用能做一些额外的工作。

    10、虚引用有什么用?虚引用的使用场景?

    1. 用于Java后来推出的Cleaner机制

    11、cleaner机制的特点

    1. 能作为清理工作的最后一道防线
    2. 没有finalize的区别
    3. 不建议去使用cleaner机制

    生命周期和可达性状态

    1、对象的生命周期以及可达性状态流程图。

    graph TD;
        1(对象创建);
        2(对象初始化);
        3(强引用状态);
        4(软引用状态);
        5(弱引用状态);
        6(finalize);
        7(幻象引用状态);
        8(unreachable);
        1-->2;
        2-->3;
        3-->4;
        3-->5;
        4-->3;
        5-->3;
        4-->5;
        6-->7;
        7-->8;
        4-->6;
        5-->6;

    2、Java中5种可达性的级别

    1. 强可达(Strong Reachable)
    2. 软可达(Soft Reachable)
    3. 弱可达(Weak Reachable)
    4. 幻象/虚可达(Phantom Reachable)
    5. 不可达(unreachable)

    3、强可达、强引用状态?

    对象有一个或者多个线程可以通过强引用就可以访问到

    4、软可达、软引用状态?

    只有通过软引用才可以访问到对象的状态

    5、弱可达、弱引用状态?

    1. 只能通过弱引用才可以访问到对象的状态
    2. 无法通过软引用或者强引用访问到的状态
    3. 弱引用一旦清除,就符合了finalize的条件

    6、幻象可达/虚可达、幻想引用状态?

    1. 没有强引用、软引用、弱引用
    2. 并且已经finalize过后,只有虚引用指向该对象。

    7、不可达状态?

    对象可以被清除了

    可达性状态的改变

    8、Reference的get方法

    1. 都是抽象类:java.lang.ref.Reference的子类
    2. 提供了get方法。
    3. 弱引用获取对象: weakReference.get()
    4. 软引用获取对象: softReference.get()
    5. 虚引用: get()无法获得原有地向,永远返回null

    9、可达性状态可以改变吗?

    可以!
    1. 通过软引用、虚引用获得对象后,重新赋予强引用,此时就强行进入到了强引用状态

    10、JVM垃圾回收会根据可达性状态进行回收

    因为可能会更改可达性状态,所以JVM会进行二次确认。

    11、为什么使用了弱引用还是出现了内存泄露?

    1. 需要检查是否错误的保持了强引用
    2. 比如赋值给static 变量

    引用队列

    1、引用队列是什么?有什么用?

    1. ReferenceQueue, 引用队列
    2. 在将各种类型的引用(如: 虚引用、弱引用、软引用)关联到对象时,可以选择是否关联引用队列
    3. JVM会在特定时间将引用加入到引用队列中(不需要我们关心)
    4. 作用:可以从队列中获取引用,并且执行后续的逻辑。

    2、幻象引用/虚引用为什么一定要使用引用队列?

    1. 虚引用在对象被finalize后,get方法只会返回null
    2. 如果不使用引用队列,会导致虚引用完全没有用了。

    3、引用队列的使用?(配合虚引用)

    Object object = new Object();
    ReferenceQueue queue = new ReferenceQueue();
    // 1. 创建虚引用。关联上引用队列。
    PhantomReference reference = new PhantomReference(object, queue);
    // 2. 去除强引用
    object = null;
    // 3. 触发GC
    System.gc();
    
    try {
        // 4. 从队列中取出对象的引用(本例中是虚引用)
        Reference ref = queue.remove(1000L);
        if(ref != null){
            // TODO somthing
            System.out.println("finalize后,进行清理工作。");
        }
    } catch (InterruptedException e) {
        e.printStackTrace();
    }

    软引用的垃圾回收

    1、软引用的垃圾回收的原理?

    1. 软引用的垃圾回收,是在内存不足时,进行回收—本质不是这样。
    2. 软引用通常是在最后一次引用后保持一段时间
    3. 保持的时间是根据堆剩余空间计算的。

    2、软引用只要内存充足就不会释放对象?

    错误!
    1. 是在最后一次引用后,保持一段时间,然后清除。

    3、如何改变软引用释放的时间

    1. 设置虚拟机参数
    2. 但是这些行为都取决于JVM的实现,不要过于依赖这些参数。
    -XX:SoftRefLRUPolicyMSPerMB = 3000 // 3秒中
    或者
    -Xmx指定的最大值

    Reachability Fence(可达性栅栏)

    1、有哪些方法能达到强引用效果?

    1. 基本引用类型
    2. 通过底层API—这就是所谓的设置Reachability Fence

    2、为什么需要Reachability Fence这种机制?

    1. 根据规范,一个对象没有强引用,则符合垃圾回收的标准。
    2. 但是!如果有的对象,没有强引用,但是部分属性还需要被使用,就会导致问题。
    3. Reachability Fence就是通过一些方法,在没有强引用时,告知JVM这些对象正在被使用,先不要进行GC。

    3、Reachability Fence应对的问题

    1. 例如:对象实例方法在执行完前,对象就已经被GC!
    2. 例如:线程池-Executors.newSingleThreadExecutor().submit()
    public static void main(String[] args) {
        for (int i = 0; i < 2000; i++) {
            newSingleThreadPool();
        }
    }
    private static void newSingleThreadPool() {
        Executors.newSingleThreadExecutor().submit(new Runnable() {
            @Override
            public void run() {
                byte[] bytes = new byte[1024 * 1024 * 4];
                System.out.println(Thread.currentThread().getName());
            }
        });
    }

    4、Executors.newSingleThreadExecutor().submit()报错

    Exception in thread "main" java.util.concurrent.RejectedExecutionException: Task java.util.concurrent.FutureTask@543c6f6d rejected from java.util.concurrent.ThreadPoolExecutor@13eb8acf[Terminated, pool size = 0, active threads = 0, queued tasks = 0, completed tasks = 0]
        at java.util.concurrent.ThreadPoolExecutor$AbortPolicy.rejectedExecution(ThreadPoolExecutor.java:2047)
        at java.util.concurrent.ThreadPoolExecutor.reject(ThreadPoolExecutor.java:823)
        at java.util.concurrent.ThreadPoolExecutor.execute(ThreadPoolExecutor.java:1369)
        at java.util.concurrent.AbstractExecutorService.submit(AbstractExecutorService.java:112)
        at java.util.concurrent.Executors$DelegatedExecutorService.submit(Executors.java:678)
        at Main.newSingleThreadPool(Main.java:32)
        at Main.main(Main.java:28)

    5、reachabilityFence()方法的使用场景

    1. JDK中常用于Excutors、HTTP2客户端等经常会异步调用的情况。

    6、如何使用reachabilityFence()?

    1-Excutor的问题:

    Executors.newSingleThreadExecutor().submit(xxx);
    // 调用这个方法,用于通知JVM,Excutor对象还不能回收
    Reference.reachabilityFence(executor);

    2-一般对象的设置

    Reference.reachabilityFence(object);

    参考资料

    1. 为什么一个对象的实例方法在执行完成之前其对象可以被GC回收?
    展开全文
  • 引用类型数组

    千次阅读 2019-03-11 19:48:26
    什么叫引用类型数组? 基本类型数组的元素中放的都是基本数据类型(int等)。 引用类型数组的元素中放的是从基本类型构造而来的类和其他复杂数据类型的地址。 两种类型数组的图解 基本类型数组:arr是引用,放在栈...

    什么叫引用类型数组
    基本类型数组的元素中放的都是基本数据类型(int等)。
    引用类型数组的元素中放的是从基本类型构造而来的类和其他复杂数据类型的地址

    两种类型数组的图解

    • 基本类型数组:arr是引用,放在栈内存中,new的部分属于对象,在堆内存中。arr里存的是对象的地址。
      在这里插入图片描述
    • 引用类型数组:
    1. 第一句话:stus是引用类型数组的变量(简称引用),存在栈内存,里面放的是对象实体的地址,new Student[3]在堆内存建立了一个Student[]数组对象实体,内部的元素都是存放的一个Student对象的引用,也就是对象的地址。
    2. 第二句话:在此之前仅仅是建立的一个由Student对象的引用所组成的数组,这些引用并没有指向某个地址,值为空,第二句话是在新建了一个Student对象,并把它的地址赋给stus[0]。

    在这里插入图片描述

    • 引用类型数组的赋值:
      类似基本类型数组的赋值方法,只是代码较多,看起来有些复杂
    //第一种:先定义数组,然后分别赋值
    Student[] stus = new Student[3]; //创建Student数组对象
    stus[0] = new Student("zhangsan",25,"LF"); //创建Student对象
    stus[1] = new Student("lisi",26,"JMS");
    stus[2] = new Student("wangwu",27,"SD");
    System.out.println(stus[0].name); //输出第1个学生的名字
    stus[1].age = 22; //给第2个学生的年龄赋值为22
    stus[2].sayHi();	//第3个学生和大家问好
    //第二种方法,声明的同时并赋值,注意中间是逗号
    Student[] stus = new Student[]{
          new Student("zhangsan",25,"LF"),
          new Student("lisi",26,"JMS"),
          new Student("wangwu",27,"SD")
        };
    
    展开全文
  • 值类型与引用类型

    千次阅读 2019-09-03 23:10:58
    C#的数据类型分为两类:值类型(基本的数据类型)和引用类型值类型:byte,int,float,bool,struct..... 引用类型:string,数组,自定义的类,内置的类..... 二:堆和栈 我们把内存分为堆空间和栈空间 栈空间比较...
  • C# - 值类型与引用类型

    万次阅读 2019-02-28 19:52:35
    分享一个大牛的人工智能教程。...因此,一个值类型变量永远不会影响到其他的值类型变量,而两个引用类型变量则很有可能指向同一地址,从而产生相互影响。 从内存分配上看,值类型分配在线程的栈上,作用...
  • js的值类型和引用类型

    千次阅读 2021-01-08 16:48:39
    js值类型和引用类型 在ES6中js的数据类型分为两种,分别是值类型和引用类型。 常见的值类型:undefined,Boolean,number,String,symbol; 常见的引用类型:Object,Array,null(特殊的引用类型,指针指向空地址...
  • 值类型和引用类型

    千次阅读 热门讨论 2019-01-02 20:18:16
    注:引用类型当声明一个类时,只在栈中分配一小片内存用于容纳一个地址,而此时并没有为其分配堆上的内存空间,当使用new 创建一个类的实例时,分配堆上的空间,并把堆上空间的地址保存到栈上分配的小片空间中。...
  • golang中的值类型和引用类型

    千次阅读 2019-08-20 20:48:29
    值类型与引用类型 值类型 值类型:这些类型的变量直接指向存在内存中的值,值类型的变量的值存储在栈中。当使用等号=将一个变量的值赋给另一个变量时,如 j = i ,实际上是在内存中将 i 的值进行了拷贝。可以通过 &...
  • 基本类型与引用类型

    千次阅读 2016-03-25 13:04:33
    基本类型与引用类型
  • C#详解值类型和引用类型区别

    万次阅读 多人点赞 2016-04-20 17:59:42
    首先,什么是值类型,什么是引用类型? 在C#中值类型的变量直接存储数据,而引用类型的变量持有的是数据的引用,数据存储在数据堆中。 值类型(value type):byte,short,int,long,float,double,decimal,...
  • C# 值类型与引用类型

    千次阅读 2018-07-19 14:31:09
    值类型与引用类型 只所以要提这两个概念,是因为很好得理解这两个概念有助于我们写出比较高效的C#代码。 我们知道,C#中的每一种类型要么是值类型,要么是引用类型。所以每个对象要么是值类型的实例,要么是引用...
  • 基本类型和引用类型区别

    千次阅读 2018-06-01 14:30:53
    1.基本类型和引用类型在内存中的保存 Java中数据类型分为两大类,基本类型和对象类型。相应的,变量也有两种类型:基本类型和引用类型。 基本类型的变量保存原始值,即它代表的值就是数值本身; 而引用类型的变量...
  • C++ 引用类型

    千次阅读 2017-04-13 21:50:48
    引用类型:可以获得指针类型的效果,但是又可以避免指针可读性和可维护性差等问题。 1. 定义  &;  定义时要初始化  可以是除了void以外的任意C++类型。  如: int x=0; int &y=x;y=2;//此时x也是2 2. ...
  • C#基础——值类型和引用类型

    千次阅读 2020-04-07 19:07:18
    1、值类型,引用类型,拆,装箱,常用的引用类型,值类型。 栈:一种先进后出(后进先出)的存储数据的结构体 堆:一块连续的,自由的存储空间。 值类型:变量直接保存其数据。 引用类型:变量保存其数据的引用...
  • java 值类型和引用类型

    千次阅读 2017-09-11 16:34:21
    java 中的数据类型分为两大类:值类型(基本数据类型)和引用类型(复合数据类型) 一,值类型分为 1,整数类型(byte,short,int,long) 2,浮点类型(float,double) 3,布尔类型(boolean) 4,字符类型(char) 二,引用...
  • Golang学习之路—值类型和引用类型

    千次阅读 2021-02-21 18:22:01
    值类型和引用类型值类型和引用类型说明值类型和引用类型特点值类型引用类型栈区和堆区示意图 值类型和引用类型说明 值类型:基本数据类型int系列,float系列,bool,string,数组和结构体struct。 引用类型:指针、...
  • Java基本数据类型和引用类型的区别

    千次阅读 2020-08-27 23:30:52
    新语言Kotlin已经抛弃了Java里的基本数据类型,而是采用引用类型去声明一个变量,那么怎么区分基本数据类型和引用类型呢? 文字概念 基本数据类型:byte、short、int、long、float、double、char、boolean引用类型:...
  • 在java中我们用的最多的是new,但这属于强引用类型,在内存不足时,一定需要牺牲某些对象,我们需要使用其它的引用类型,比如软引用 一图看懂所有引用类型: 相关代码 import java.util.Date; /** * 强引用,...
  • unity中的值类型和引用类型

    千次阅读 2019-08-14 16:32:53
    一、值类型和引用类型概念 值(value)类型 :Unity中的vector3、quaternion是structs,它们是值。 引用(feference)类型 :Unity中的transform、gameobject是类类型,所以它们是引用。引用类型是对数据存储位置...
  • js基本类型与引用类型

    千次阅读 多人点赞 2018-06-15 11:21:22
    引用类型: Object首先了解一个概念:栈内存与堆内存---这是两种不同的内存分配方法一般代码逻辑,简单变量,结构体都是放在栈中;而对象,以及被装箱的数据放在堆中栈内存中存放地址指向堆内存中的对象基本类型就是...
  • Java四种引用类型

    千次阅读 2019-05-12 19:01:34
    文章目录引用类型简介对象可达性判断GC Roots对象可达性判断可达性状态类型可达性判断规则状态转换Reference类定义状态变化四种引用类型实现强引用FinalReference软引用SoftReference弱引用WeakReference虚引用...
  • js基本类型 引用类型 简单赋值 对象引用,两个等号与三个等号的区别
  • 一、什么是值类型,什么是引用类型 概念:值类型直接存储其值,而引用类型存储对其值的引用。部署:托管堆上部署了所有引用类型引用类型:基类为Objcet 值类型:均隐式派生自System.ValueType: 值类型...
  • js 判断数据类型 引用类型

    千次阅读 2018-12-06 09:48:11
    /** * js 判断数据类型 ... * 引用类型 基础类型都可以使用 vue中使用这种方法判断数据类型 * 使用: Object.prototype.toString.call(要判断的数据) * * 判断数组还可以 * arr instanceof Array * */ ...
  • Java引用类型有哪些

    万次阅读 2019-07-05 16:48:32
    其中,引用数据类型在存储堆中对需要引用的对象进行引用,引用是Java面向对象的一个特点,在Java入门中,我们会接触到四种Java的引用类型,接下来就说说这四种Java引用类型有哪些吧: 1、Java中有哪几种引用?...
  • 数组引用类型与基本类型的区别

    千次阅读 2019-04-20 16:49:56
    数组引用类型引用类型和基本类型的区别 引用类型和基本类型的区别 引用类型:赋值,传递的是地址 里面的值都指向了同一个空间,都在堆内存中 基本类型:变量赋值,传递的是值 在栈内存保存数据,在堆内存中的...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 165,111
精华内容 66,044
关键字:

引用类型