精华内容
下载资源
问答
  • c++引用特点
    万次阅读
    2020-08-24 01:26:41

     1.将“引用”作为函数参数有哪些特点?
       (1)传递引用给函数与传递指针的效果是一样的。
       (2)使用引用传递函数的参数,在内存中并没有产生是实参的副本,它是直接对实参操作
       (3)使用指针作为函数的参数虽然也能达到使用引用的效果,但是,在被调函数中同样要给形参分配存储单元,且需要重复使用”*指针变量名”的形式进行运算,这很容易产生错误且程序的阅读性较差;另一方面,在主调函数的调用点处,必须用变量的地址作为实参。而引用更容易使用,更清晰。

    2.将“引用”作为函数返回值类型的格式、好处和需要遵守的规则?
       好处:在内存中不产生被返回值的副本
     注意:
       1.不能返回局部变量的引用,主要是局部变量会在函数返回后被销毁,因此被返回的引用就成了无所指的引用,程序会进入未知状态
       2.不能返回函数内部new分配的内存的引用(容易造成内存泄漏)
       3.可以返回类成员的引用,但最好是const

    更多相关内容
  • 问题:将“引用”作为函数的参数有哪些特点? 分析: 这道题不仅考查了对引用的理解和应用,同时考查了对函数的三种传递参数方式基本概念的理解。总结起来,有如下特点: • 传递引用给函数与指针的效果是一样的...

     

    问题:将“引用”作为函数的参数有哪些特点?

    分析:

    这道题不仅考查了对引用的理解和应用,同时考查了对函数的三种传递参数方式基本概念的理解。总结起来,有如下特点:

    •  传递引用给函数与指针的效果是一样的。这时,被调函数的形参就被当成原来主调函数中实参变量或对象的一个别名来使用,所以在被调函数中对形参变量的操作就是对其相应目标对象的操作。

    •  使用引用传递函数的参数,在内存中并没有产生实参的副本,它是直接对实参操作,而使用一般变量传递函数的参数,当发生函数调用时,需要给形参分配存储单元,形参变量是实参变量的副本,如果传递的是对象,还要调用拷贝构造函数。因此,当参数传递的数据较大时,用引用比用一般变量传递参数的效率更高,所占空间也更少。

    •  使用指针作为函数的参数虽然也能达到跟使用引用相同的效果。但是,一方面,再被调函数中同样要给形参分配存储单元,在使用时需要重复使用以“指针变量名”的形式进行运算,这很容易产生错误且程序的可读性较差,另一方面,在主调函数的调用点处,必须用变量的地址作为实参。因而引用更容易使用更清晰。

    展开全文
  • JAVA中的引用四种引用类型

    千次阅读 2020-08-30 10:09:38
    关于值类型和引用类型的话题,C++、JAVA、python、go、C#等等高级语言都有相关的概念,只要理解了其底层工作原理,可以说即使是不同的语言,在面试学习工作实践中都可以信手拈来(不要太纠集语言),当然此处我选择了...

    关于值类型和引用类型的话题,C++、JAVA、python、go、C#等等高级语言都有相关的概念,只要理解了其底层工作原理,可以说即使是不同的语言,在面试学习工作实践中都可以信手拈来(不要太纠集语言),当然此处我选择了JAVA,虽然我是搞C++的,具体原因都懂就不废话了。

    一、值类型与引用类型

      1、变量初始化

    int num=10;
    String str="hello"

      

      2、变量赋值
       从上图可以显而易见,num是int基本类型变量,值就直接保存在变量中。str是String引用类型变量,变量中保存的只是实际对象对应的地址信息,而不是实际对象数据。对于而这特性,如下:

    num=20;
    str="java";

      对于基本类型变量num,赋值运算符将会直接修改变量的值,原来的数据将被覆盖掉,被替换为新的值。对于引用类型变量str,赋值运算符只会改变变量中所保存的对象的地址信息,原来对象的地址被覆盖掉,重新写入新对象的地址数据。但原来的对象本身并不会被改变,只是不再被任何引用所指向的对象,即“垃圾对象”,后续会被垃圾回收器回收。

      3、函数传参

     

    // 基本类型参数,原始value不会被更改
        public void func(int value) {
            value = 100;
        }
    
        // 对于没有提供修改自身的成员方法引用类型,原始str不会被更改
        public void func(String str) {
            str = "hello";
        }
    
        StringBuilder sb = new StringBuilder("test");
    
        // 对于提供修改自身的成员方法引用类型,原始的sBuilder会被更改
        public void func(StringBuilder sBuilder) {
            sBuilder.append("aa");
        }
    
        // 原始的sBuilder不会被更改
        public void test(StringBuilder sBuilder) {
            sBuilder = new StringBuilder("111");
        }

     

    说明:对于第三种情况:

    对于第四种情况:

     

     

    二、数据存储方式

      1、局部变量/方法参数

      对于局部变量和方法传递的参数在jvm中的存储方式是相同的,都是存储在栈上开辟的空间中。方法参数空间在进入方法时开辟,方法退出时进行回收。以32为JVM为例,boolean、byte、short、char、int、float以及对应的引用类型都是分配4字节大小的空间,long、double分配8字节大小空间。对于每一个方法来说,最多占用空间大小是固定的,在编译时就已经确定了。当在方法中声明一个int变量i=0或Object变量obj=null时,此时仅仅在栈上分配空间,不影响到堆空间。当new Object()时,将会在堆中开辟一段内存空间并初始化Object对象。

      2、数组类型引用和对象

      当声明数组时,int[]  arr=new int[2];数组也是对象,arr实际上是引用,栈上占用4个字节大小的存储空间,而是会在堆中开辟相应大小空间进行存储,然后arr变量指向它。当声明一个二维数组时,如:int[][]  arr2=new int[2][4],arr2同样在栈中占用4个字节,在堆内存中开辟长度为2,类型为int[]的数组对象,然后arr2指向这个数组。这个数组内部有两个引用类型(大小为4个字节),分别指向两个长度为4类型为int的数组。内存分布如图:

    所以当传递一个数组给一个方法时,数组的元素在方法内部是可以被修改的,但是无法让数组引用指向新的数组。其实,还可以声明:int [][]  arr3=new int[3][],内存分布如下:

      3、String类型数据

      对于String类型,其对象内部需要维护三个成员变量,char[]  chars,int  startIndex,  int  length。chars是存储字符串数据的真正位置,在某些情况下是可以共用的,实际上String类型是不可变类型。例如:String  str=new String("hello"),内存分布如下:

     

    三、JAVA引用类型

      在JAVA中提供了四种引用类型:强引用、软引用、软引用和虚引用。在四种引用类型中,只有强引用FinalReference类型变量是包内可见的,其他三种引用类型均为public,可以在程序中直接使用。

      1、强引用

      强引用是使用最普遍的引用。如果一个对象具有强引用,那么垃圾回收器绝不会回收它。例如:StringBuilder sb = new StringBuilder("test");变量str指向StringBuffer实例所在的堆空间,通过str可以操作该对象。如下:

      强引用特点:

      • 强引用可以直接访问目标对象
      • 只要有引用变量存在,垃圾回收器永远不会回收。JVM即使抛出OOM异常,也不会回收强引用所指向的对象。
      • 强引用可能导致内存泄漏问

       2、软引用

      软引用是除了强引用外,最强的引用类型。可以通过java.lang.ref.SoftReference使用软引用。一个持有软引用的对象,不会被JVM很快回收,JVM会根据当前堆的使用情况来判断何时回收。当堆使用率临近阈值时,才会去回收软引用的对象。因此,软引用可以用于实现对内存敏感的高速缓存。SoftReference的特点是它的一个实例保存对一个Java对象的软引用,该软引用的存在不妨碍垃圾收集线程对该Java对象的回收。也就是说,一旦SoftReference保存了对一个Java对象的软引用后,在垃圾线程对 这个Java对象回收前,SoftReference类所提供的get()方法返回Java对象的强引用。一旦垃圾线程回收该Java对象之后,get()方法将返回null。

    Object obj = new Object();
    SoftReference<Object> sf = new SoftReference<Object>(obj);
    obj = null;
    sf.get();//有时候会返回null
    sf是对obj的一个软引用,通过sf.get()方法可以取到这个对象,当这个对象被标记为需要回收的对象时,则返回null;

      软引用主要用户实现类似缓存的功能,在内存足够的情况下直接通过软引用取值,无需从繁忙的真实来源查询数据,提升速度;当内存不足时,自动删除这部分缓存数据,从真正的来源查询这些数据。使用软引用能防止内存泄露,增强程序的健壮性。软引用可以和一个引用队列(ReferenceQueue)联合使用,如果软引用所引用的对象被垃圾回收器回收,Java虚拟机就会把这个软引用加入到与之关联的引用队列中。也就是说,ReferenceQueue中保存的对象是Reference对象,而且是已经失去了它所软引用的对象的Reference对象。当调用它的poll()方法的时候,如果这个队列中不是空队列,那么将返回队列前面的那个Reference对象。在任何时候,都可以调用ReferenceQueue的poll()方法来检查是否有它所关心的非强可及对象被回收。如果队列为空,将返回一个null,否则该方法返回队列中前面的一个Reference对象。利用这个方法,可以检查哪个SoftReference所软引用的对象已经被回收,于是可以把这些失去所软引用的对象的SoftReference对象清除掉。

      3、弱引用

      弱引用是一种比软引用较弱的引用类型。在系统GC时,只要发现弱引用,不管系统堆空间是否足够,都会将对象进行回收。在java中,可以用java.lang.ref.WeakReference实例来保存对一个Java对象的弱引用。弱引用与软引用的区别在于:只具有弱引用的对象拥有更短暂的生命周期。不过,由于垃圾回收器是一个优先级很低的线程,因此不一定会很快发现那些只具有弱引用的对象。弱引用主要用于监控对象是否已经被垃圾回收器标记为即将回收的垃圾,可以通过弱引用的isEnQueued方法返回对象是否被垃圾回收器标记。弱引用可以和一个引用队列(ReferenceQueue)联合使用,如果弱引用所引用的对象被垃圾回收,Java虚拟机就会把这个弱引用加入到与之关联的引用队列中。

    Object obj = new Object();
    WeakReference<Object> wf = new WeakReference<Object>(obj);
    obj = null;
    wf.get();//有时候会返回null
    wf.isEnQueued();//返回是否被垃圾回收器标记为即将回收的垃圾

      4、虚引用

      虚引用是所有类型中最弱的一个。一个持有虚引用的对象和没有引用几乎是一样的,随时可能被垃圾回收器回收,当试图通过虚引用的get()方法取得强引用时,总是会失败。并且虚引用必须和引用队列一起使用,它的作用在于检测对象是否已经从内存中删除,跟踪垃圾回收过程。当垃圾回收器准备回收一个对象时,如果发现它还有虚引用,就会在垃圾回收后,销毁这个对象,将这个虚引用加入引用队列。程序可以通过判断引用队列中是否已经加入了虚引用,来了解被引用的对象是否将要被垃圾回收。如果程序发现某个虚引用已经被加入到引用队列,那么就可以在所引用的对象的内存被回收之前采取必要的行动。

    Object obj = new Object();
    PhantomReference<Object> pf = new PhantomReference<Object>(obj);
    obj=null;
    pf.get();//永远返回null
    pf.isEnQueued();//返回是否从内存中已经删除

     

     

    @Test
        public void test(){
            Map map;
            map = new WeakHashMap<String,Object>();
            for (int i =0;i<10000;i++){
                map.put("key"+i,new byte[i]);
            }
    //        map = new HashMap<String,Object>();
    //        for (int i =0;i<10000;i++){
    //            map.put("key"+i,new byte[i]);
    //        }
        }

     

      使用-Xmx2M限定堆内存,使用WeakHashMap的代码正常运行结束,而使用HashMap的代码段抛出异常:java.lang.OutOfMemoryError: Java heap space。由此可见,WeakHashMap会在系统内存紧张时使用弱引用,自动释放掉持有弱引用的内存数据。但如果WeakHashMap的key都在系统内持有强引用,那么WeakHashMap就退化为普通的HashMap,因为所有的数据项都无法被自动清理。

    展开全文
  • 引用引用是使用最普遍的引用。如果一个对象具有强引用,那垃圾收器绝不会回收它。当内存空间不足,Java虚拟机宁愿抛出OutOfM moryError错误,使程序异常终止,也不会靠随意回收具有强引用 对象来解决内存不足...
    • 强引用

    强引用是使用最普遍的引用。如果一个对象具有强引用,那垃圾收器绝不会回收它。当内存空间不足,Java虚拟机宁愿抛出OutOfM moryError错误,使程序异常终止,也不会靠随意回收具有强引用 对象来解决内存不足的问题。

    • 软引用

    软引用是用来描述一些还有用但并非必须的对象。对于软引用关联着的对象,在系统将要发生内存溢出异常之前,将会把这些对象列进回收范围进行第二次回收。如果这次回收还没有足够的内存,才会抛出内存溢出异常。

     

    /**
     * 软引用何时被收集
     * 运行参数 -Xmx200m -XX:+PrintGC
     * Created by ccr at 2018/7/14.
     */
    public class SoftReferenceDemo {
    
        public static void main(String[] args) throws InterruptedException {
            //100M的缓存数据
            byte[] cacheData = new byte[100 * 1024 * 1024];
            //将缓存数据用软引用持有
            SoftReference<byte[]> cacheRef = new SoftReference<>(cacheData);
            //将缓存数据的强引用去除
            cacheData = null;
            System.out.println("第一次GC前" + cacheData);
            System.out.println("第一次GC前" + cacheRef.get());
            //进行一次GC后查看对象的回收情况
            System.gc();
            //等待GC
            Thread.sleep(500);
            System.out.println("第一次GC后" + cacheData);
            System.out.println("第一次GC后" + cacheRef.get());
    
            //在分配一个120M的对象,看看缓存对象的回收情况
            byte[] newData = new byte[120 * 1024 * 1024];
            System.out.println("分配后" + cacheData);
            System.out.println("分配后" + cacheRef.get());
        }
    
    }
    
    第一次GC前null
    第一次GC前[B@7d4991ad
    [GC (System.gc())  105728K->103248K(175104K), 0.0009623 secs]
    [Full GC (System.gc())  103248K->103139K(175104K), 0.0049909 secs]
    第一次GC后null
    第一次GC后[B@7d4991ad
    [GC (Allocation Failure)  103805K->103171K(175104K), 0.0027889 secs]
    [GC (Allocation Failure)  103171K->103171K(175104K), 0.0016018 secs]
    [Full GC (Allocation Failure)  103171K->103136K(175104K), 0.0089988 secs]
    [GC (Allocation Failure)  103136K->103136K(199680K), 0.0009408 secs]
    [Full GC (Allocation Failure)  103136K->719K(128512K), 0.0082685 secs]
    分配后null
    分配后null
    

    从上面的示例中就能看出,软引用关联的对象不会被GC回收。JVM在分配空间时,若果Heap空间不足,就会进行相应的GC,但是这次GC并不会收集软引用关联的对象,但是在JVM发现就算进行了一次回收后还是不足(Allocation Failure),JVM会尝试第二次GC,回收软引用关联的对象。

    像这种如果内存充足,GC时就保留,内存不够,GC再来收集的功能很适合用在缓存的引用场景中。在使用缓存时有一个原则,如果缓存中有就从缓存获取,如果没有就从数据库中获取,缓存的存在是为了加快计算速度,如果因为缓存导致了内存不足进而整个程序崩溃,那就得不偿失了。

    • 弱引用

    弱引用也是用来描述非必须对象的,他的强度比软引用更弱一些,被弱引用关联的对象,在垃圾回收时,如果这个对象只被弱引用关联(没有任何强引用关联他),那么这个对象就会被回收。

     

    /**
     * 弱引用关联对象何时被回收
     * Created by ccr at 2018/7/14.
     */
    public class WeakReferenceDemo {
        public static void main(String[] args) throws InterruptedException {
            //100M的缓存数据
            byte[] cacheData = new byte[100 * 1024 * 1024];
            //将缓存数据用软引用持有
            WeakReference<byte[]> cacheRef = new WeakReference<>(cacheData);
            System.out.println("第一次GC前" + cacheData);
            System.out.println("第一次GC前" + cacheRef.get());
            //进行一次GC后查看对象的回收情况
            System.gc();
            //等待GC
            Thread.sleep(500);
            System.out.println("第一次GC后" + cacheData);
            System.out.println("第一次GC后" + cacheRef.get());
    
            //将缓存数据的强引用去除
            cacheData = null;
            System.gc();
            //等待GC
            Thread.sleep(500);
            System.out.println("第二次GC后" + cacheData);
            System.out.println("第二次GC后" + cacheRef.get());
        }
    }
    第一次GC前[B@7d4991ad
    第一次GC前[B@7d4991ad
    第一次GC后[B@7d4991ad
    第一次GC后[B@7d4991ad
    第二次GC后null
    第二次GC后null
    

    从上面的代码中可以看出,弱引用关联的对象是否回收取决于这个对象有没有其他强引用指向它。这个确实很难理解,既然弱引用关联对象的存活周期和强引用差不多,那直接用强引用好了,干嘛费用弄出个弱引用呢?其实弱引用存在必然有他的应用场景。

     

    static Map<Object,Object> container = new HashMap<>();
    public static void putToContainer(Object key,Object value){
        container.put(key,value);
    }
    
    public static void main(String[] args) {
        //某个类中有这样一段代码
        Object key = new Object();
        Object value = new Object();
        putToContainer(key,value);
    
        //..........
        /**
         * 若干调用层次后程序员发现这个key指向的对象没有用了,
         * 为了节省内存打算把这个对象抛弃,然而下面这个方式真的能把对象回收掉吗?
         * 由于container对象中包含了这个对象的引用,所以这个对象不能按照程序员的意向进行回收.
         * 并且由于在程序中的任何部分没有再出现这个键,所以,这个键 / 值 对无法从映射中删除。
         * 很可能会造成内存泄漏。
         */
        key = null;
    }
    

    下面一段话摘自《Java核心技术卷1》:

    设计 WeakHashMap类是为了解决一个有趣的问题。如果有一个值,对应的键已经不再 使用了, 将会出现什么情况呢? 假定对某个键的最后一次引用已经消亡,不再有任何途径引 用这个值的对象了。但是,由于在程序中的任何部分没有再出现这个键,所以,这个键 / 值 对无法从映射中删除。为什么垃圾回收器不能够删除它呢? 难道删除无用的对象不是垃圾回 收器的工作吗?

    遗憾的是,事情没有这样简单。垃圾回收器跟踪活动的对象。只要映射对象是活动的, 其中的所有桶也是活动的, 它们不能被回收。因此,需要由程序负责从长期存活的映射表中 删除那些无用的值。 或者使用 WeakHashMap完成这件事情。当对键的唯一引用来自散列条
    目时, 这一数据结构将与垃圾回收器协同工作一起删除键 / 值对。

    下面是这种机制的内部运行情况。WeakHashMap 使用弱引用(weak references) 保存键。 WeakReference 对象将引用保存到另外一个对象中,在这里,就是散列键。对于这种类型的 对象,垃圾回收器用一种特有的方式进行处理。通常,如果垃圾回收器发现某个特定的对象 已经没有他人引用了,就将其回收。然而, 如果某个对象只能由 WeakReference 引用, 垃圾 回收器仍然回收它,但要将引用这个对象的弱引用放人队列中。WeakHashMap将周期性地检 查队列, 以便找出新添加的弱引用。一个弱引用进人队列意味着这个键不再被他人使用, 并 且已经被收集起来。于是, WeakHashMap将删除对应的条目。

    除了WeakHashMap使用了弱引用,ThreadLocal类中也是用了弱引用。

    • 虚引用

    一个对象是否有虚引用的存在,完全不会对其生存时间构成影响,也无法通过虚引用来获取一个对象的实例。为一个对象设置虚引用关联的唯一目的就是能在这个对象被收集器回收时收到一个系统通知。虚引用和弱引用对关联对象的回收都不会产生影响,如果只有虚引用活着弱引用关联着对象,那么这个对象就会被回收。它们的不同之处在于弱引用的get方法,虚引用的get方法始终返回null,弱引用可以使用ReferenceQueue,虚引用必须配合ReferenceQueue使用。

    jdk中直接内存的回收就用到虚引用,由于jvm自动内存管理的范围是堆内存,而直接内存是在堆内存之外(其实是内存映射文件,自行去理解虚拟内存空间的相关概念),所以直接内存的分配和回收都是有Unsafe类去操作,java在申请一块直接内存之后,会在堆内存分配一个对象保存这个堆外内存的引用,这个对象被垃圾收集器管理,一旦这个对象被回收,相应的用户线程会收到通知并对直接内存进行清理工作。

     

    展开全文
  • 两者之间的关系特点:一、从概念方面来说基本数据类型:变量名指向具体的数值引用数据类型:变量名指向存数据对象的内存地址,即变量名指向hash值二、从内存构建方面来说基本数据类型:变量在声明之后java就会立刻分配给...
  •  引用传递的特点:方法内部对传进去的参数作的改变也会影响方法外部的变量的值  那么哪些是值传递,哪些是引用传递呢?  1、基本类型(8种)的传递都是值传递  2、引用类型(除String外)都是引用传递 ...
  • 特点: 一、从概念方面来说 基本数据类型:变量名指向具体的数值引用数据类型:变量名指向存数据对象的内存地址,即变量名指向hash值 二、从内存构建方面来说 基本数据类型:变量在声明之后java就会立刻分配...
  • 背景:收到公众投稿,《从面试题中看Java的Reference(引用)》,分析的很不错,总感觉少了实际的例子和应用场景。于是结合自己工作中场景,小总结一下。看下Agenda如下: 1、强引用 2、软引用 3、弱引用 4、什么时候...
  • CSS的四种引入方式与特点

    千次阅读 2017-08-30 16:59:51
    link元素是XHMTL中的标签,当HTML页面被渲染时,link引用的CSS文件会被同时加载,我们也可以通过JavaScript控制DOM去改变link元素的CSS内容,如 < div id = "test" > div > < script type = "text/...
  • 我总结了一下,将引用作为函数参数有如下特点(就不上代码了):  1,传递引用和传递指针的作用其实是一样的。这时,被调函数的形参就被当成原来的主调函数实参变量或对象的一个别名来使用,所以在被调函数中对...
  • 引用类型主要有4种

    千次阅读 2021-03-14 22:16:49
    java中基本数据类型和引用数据类型各有什么特点两者之间的关系 特点: 一、从概念方面来说 基本数据类型:变量名指向具体的数值引用数据类型:变量名指向存数据对象的内存地址,即变量名指向hash值 二、从内存构建方面...
  • JavaScript中的弱引用和强引用

    万次阅读 2021-12-04 14:48:54
    JavaScript中的弱引用和强引用什么是弱引用和强引用举例说明弱引用和强引用在JavaScript中演示弱引用和强引用引用的特性总结 什么是弱引用和强引用 JavaScript 中强引用:对象的引用在 JavaScript 中是强引用,也...
  • (1)传递引用给函数与传递指针的效果是一样的。这时,被调函数的形参就成为原来主调函数中的实参变量或对象的一个别名来使用,所以在被调函数中对形参变量的操作就是对其相应的目标对象(在主调函数中)的操作。 ...
  • C++ 引用 什么是引用

    千次阅读 多人点赞 2019-04-15 02:00:36
    先举几个栗子:“及时雨”宋江、“卧龙”诸葛亮...概念:引用是为已存在的变量取了一个别名,引用引用的变量共用同一块内存空间 格式:类型& 引用变量名(对象名) = 引用实体; int& ra = a; ra为a的引用 ...
  • 1. 对基本数据类型,不同的变量会分配不同...对引用数据类型,赋值是把原对象的引用传递给另外一个引用。对数组而言,当一个数组引用赋值给另外一个数组引用后, 这两个引用指向同一个数组,也就是指向同一块内存空间。
  • 传递引用给函数与传递指针的效果是一样的。这时,被调函数的形参就成为原来主调函数中的实参变量或对象的一个别名来使用,所以在被调函数中对形参变量的操作就是对其相应的目标对象(在主调函数中)的操作。 ②使用...
  • Biblatex 引用样式

    千次阅读 2020-11-25 18:15:05
    Biblatex提供了许多标准的引用样式。如果没有指定引用样式,那么 LaTeX 会使用与参考文献样式对应的样式。
  • 这四种级别由高到低依次为:强引用、软引用、弱引用和虚引用。但是平时我们的代码中似乎很少出现这些, 而之前还看到过一份代码中, 一个Activity中有一个静态变量持有对自己的弱引用,来达到类似的singleTas
  • 这四种级别由高到低依次为:强引用、软引用、弱引用和虚引用。 1、强引用(Strong Reference) 强引用就是我们经常使用的引用,其写法如下: Object&nbsp;o&nbsp;=&nbsp;new&nbsp;Object(); 只要...
  • 用了Java怎么长时间一直不知道原来Java还有四种引用类型,这个引用类型和我们平常说的可不一样。这里的引用类型不是指数据类型的一种,而是指Java中的引用所分的四种类型。强引用: Java中的引用,有点像C++的指针。...
  • C++中的“引用”详解

    千次阅读 多人点赞 2019-11-22 11:45:06
    前言:在面向对象的程序设计语言中,我们经常听见一些名词,引用,地址,在函数传递参数的时候,我们又经常说值传递,引用传递,最容易让人搞混淆的就是“引用”和“地址”这两个概念了,对于C++和C#来说,引用一词...
  • 特点:(1)创建一个对象,并将对这个对象的引用赋值给o,这样就是强引用了(2)当内存空间不足的时候,虚拟机宁愿抛出错误,也不愿意回收内存(3)可以使用 o = null;的方式来弱化引用(4)如果一个对象,没有一个引用来...
  • 右值引用特点 右值引用独立于左值和右值。意思是右值引用类型的变量可能是左值也可能是右值。比如: int&& val1 = x; var1类型为右值引用,但var1本身是左值,因为具名变量都是左值。 T&& 并不一定...
  • 可能看起来有点枯燥,但引用是在JNI中最容易出错的一个点,如果使用不当,容易使程序造成内存溢出,程序崩溃等现象。所以讲得比较细,有些地方看起来可能比较啰嗦,还请轻啪!下一篇文章会写一个在Andro
  • 指针与引用总结

    千次阅读 多人点赞 2018-10-15 22:58:07
    //这里b是一个引用,它是变量i的引用引用是什么?它的本质是什么?下面会具体讲述 int * &c = a;//这里c是一个引用,它是指针a的引用 int & *d;//这里d是一个指针,它指向引用,但引用不是实体,所以这是错误的 ...
  • 在Excel中,公式和函数...在Excel中引用数据主要有两种方式:相对引用和绝对引用。这里就来说说这两种常用的引用方式的区别。 相对引用:相对引用是Excel中常用的一种引用方式。相对引用的格式为:列号行号,如...
  • Java 存在四种引用,分别是强引用(StrongReference)、软引用(SoftReference)、弱引用(WeakReference)和虚引用(PhantomReference)。
  • Java中“引用”的特点4. Java的参数传递5.参考 前言 在学习Java中变量的数据类型时,发现其分为2大类:基本数据类型、引用数据类型。 其中,属于“引用数据类型”的有:String、数组、类、接口。 相比C语言,Java中...
  • Java的四种引用类型有哪些?

    千次阅读 2021-02-12 11:01:54
    说到引用引用是Java面向对象的一个特点,如果一个对象不曾被任何变量应用的话,那么整个程序也就无法再使用这一对象。因此四种引用类型可以说是大家在学习Java的过程中经常会接触到的。那么...
  • 什么是Java的对象引用? Java中都有哪些类型的对象引用? Java中提供的Java对象引用主要有什么目的? 通过本文,你就能很清楚得了解Java的对象引用

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 456,477
精华内容 182,590
关键字:

引用的特点