精华内容
下载资源
问答
  • Java四种引用类型

    万次阅读 多人点赞 2019-05-12 19:01:34
    文章目录引用类型简介对象可达性判断GC Roots对象可达性判断可达性状态类型可达性判断规则状态转换Reference类定义状态变化四种引用类型实现强引用FinalReference软引用SoftReference弱引用WeakReference虚引用...

    引用类型简介

    Java开发者肯定都很熟悉java中的4种引用类型,它们从强到弱分别是:

    引用类型对象是否可引用回收时间使用场景
    强引用可以从不回收普遍对象的状态
    软引用可以内存不足时内存敏感的高速缓存
    弱引用可以下一次GC对象缓存
    虚引用不可以下一次GC,不影响对象生命周期必须和引用队列(ReferenceQueue)一起使用,一般用于追踪垃圾收集器的回收动作。相比对象的finalize方法,虚引用的方式更加灵活和安全。

    但可能大多数对4种引用类型的理解都只停留在概念的记忆上,而并不了解四种引用的实现原理。下面我们结合源代码了解下四种引用的实现原理。当然在了解四种引用的实现原理之前,首先得了解下JVM中实现对象可达性判断的原理。

    对象可达性判断

    目前,大多数JVM都是使用可达性分析算法来判断对象的是否可达。可达性分析算法以GC Roots对象作为起始点进行搜索。当一个对象与GC Roots对象没有任何引用链相连时(也即引用有向图中从GC Roots对象到这个对象是不连通的),则表明该对象是不可用的(不可用的对象不一定被判定为可以回收的对象)。当对象与GC Roots对象有引用链相连时,则需要根据引用链的类型来判断对象是否可达。

    不可用的对象不一定被判定为可以回收的对象:判定对象为”死亡”至少需要经历两次标记的过程。第一次标记:对象可达性分析,如果发现对象没有与GC Roots相连接的引用链,且对象需要执行finalize方法,将会被加入F-Queue队列中。第二次标记:由一个优先级低的Finalizer线程去取F-Queue队列的对象,“尝试执行”对象的finalize方法。

    JVM会保证触发满足条件的对象的finalize方法,但是并不承诺会等待方法执行结束。finalize方法是对象逃脱死亡命运的最后一次机会。

    GC Roots对象

    GC Roots对象包含以下四类:

    • 虚拟机栈(栈桢中的本地变量表)中的引用的对象;
    • 方法区中的类静态属性引用的对象;
    • 方法区中的常量引用的对象;
    • 本地方法栈中JNI(Native方法)引用的对象;

    可达性判断

    可达性状态类型

    Java有5种类型的可达性状态:

    • 强可达(Strongly Reachable):与GC Roots对象之间有强引用相连通,则为强可达的;
    • 软可达(Soft Reachable):与GC Roots对象之间没有强引用相连通,但有软引用相连通,则为软可达的;
    • 弱可达(Weak Reachable):与GC Roots对象之间没有强引用或软引用相连通,但有弱引用相连通,则为弱可达的;
    • 虚可达(Phantom Reachable):与GC Roots对象之间没有强引用、软引用或弱引用相连通,然后该对象finalize方法已执行,并且有虚引用相连通,则为虚可达的;
    • 不可达(Unreachable):如果对象finalize方法已执行并且没有任何引用相连通,则对象是不可达的,可以被回收。

    可达性判断规则

    从GC Roots对象到一个对象的引用链可能存在多条,那么此时会依据两个原则来判断对象的可达性:

    • 单个引用链中,以最弱的引用类型为准;
    • 多引用链联合看时,以最强的引用类型为准;

    可达性判断

    首先,单个引用链中,以最弱的引用类型为准:则GC Roots->Obj1->Obj4是软引用连通的,GC Roots->Obj2->Obj4是弱引用连通的,GC Roots->Obj3->Obj5是弱引用连通的。然后多引用链联合看时,以最强的引用类型为准:则GC Roots到Obj4对象的引用联合来看是弱引用连通的。

    状态转换

    对象可达性状态是随着程序运行而不断变化的,对象可达性状态转换图可参考下图。

    • 对象创建后一般是强可达的。
    • 当GC Roots对象到该对象的强引用被清除后:如果剩余引用链最高为软引用,则状态转换为软可达的;反之如果最高为弱引用,则状态转换为弱可达的,反之则把对象标记为可执行finalize方法状态。
    • 当软可达对象重新被强引用连接时,则转换为强可达状态;当软可达对象的软引用被清除后,如果剩余引用链最高为弱引用,则状态转换为弱可达;反之则把对象标记为可执行finalize方法状态。
    • 当弱可达对象重新被强引用或者软引用连接时,则可转换为强可达或者软可达;当弱可达对象的弱引用被清除后,则把对象标记为可执行finalize方法状态。
    • 可对象被标记为可执行finalize方法状态,如果对象finalize从未被执行,则执行finalize方法,并标记对象的finalize方法已经被执行(在finalize方法可能会重新生成强/软/弱引用等,对象状态会重新转换为强/软/弱可达,不过并不推荐这么做,因为可能会导致对象状态紊乱,无法被正常回收);反之当对象有虚引用连接时,则转换为虚可达状态,否则转换为不可达状态。
    • 虚可达对象在垃圾回收后状态转换为不可达(不能通过虚引用获取对象引用,所以对象状态不会再转换为强/软/弱可达);

    可达性状态转换图

    Reference

    Reference类是所有引用类型的基类,定义了reference对象的通用操作,用来保存对象引用及引用的内部状态。Reference抽象类初始化时,会启动一个ReferenceHandler线程。Reference的referent被回收前,垃圾回收器会把reference添加到pending这个链表里(如果注册了ReferenceQueue),然后ReferenceHandler线程不断的读取pending中的reference,把它加入到对应的ReferenceQueue中(如果Reference是Cleaner类的实例,即虚引用对象,则调用其注册的预处理钩子方法)。

    ReferenceQueue提供了两个静态字段NULL,ENQUEUED。这两个字段的主要功能:NULL是当我们构造Reference实例时queue传入null时,会默认使用NULL,这样在enqueue时判断queue是否为NULL,如果为NULL直接返回,入队失败。ENQUEUED的作用是防止重复入队,reference后会把其queue字段赋值为ENQUEUED,当再次入队时会直接返回失败。

    类定义

    Reference对象的基类。该类定义了reference对象的通用操作。因为reference对象是和垃圾回收器密切配合实现的,因此该类不能直接进行子类化。

    public abstract class Reference<T> {
    	// 用于保存对象的引用,GC会特别对待该变量
        private T referent; 
    	// 如果注册了ReferenceQueue(需要通知机制),用来保存对象引用的队列,
        volatile ReferenceQueue<? super T> queue;
    
        // 保存需要由ReferenceHandler处理的引用
        volatile Reference next;
    
    	// 被JVM使用,保存需要被JVM处理的下一个引用
        transient private Reference<T> discovered;
    
        // 同步锁,用于同步pending队列的进队和出队
        static private class Lock { }
        private static Lock lock = new Lock();
    
        // 一个PENDING队列,配合上述next一起使用,实现类单向循环链表的操作
        private static Reference<Object> pending = null;
    
    	// 高优先级线程,用于将pending队列里面的Reference实例依次添加到不同的ReferenceQueue中
    	private static class ReferenceHandler extends Thread {...}
    	...
    }
    

    状态变化

    一个对象引用有四种内部状态:

    • Active: 新创建的实例的状态,当对象引用被垃圾回收器回收前:如果Reference注册了ReferenceQueue,则会切换为Pending,并且Reference会加入pending链表中,如果没有注册ReferenceQueue,会切换为Inactive。
    • Pending: 在pending链表中的Reference的状态,这些Reference等待被ReferenceHandler内部线程加入ReferenceQueue中。
    • Enqueued: 在ReferenceQueue队列中的Reference的状态,如果Reference从队列中移除,会进入Inactive状态。未注册ReferenceQueue的实例不会到达该状态。
    • Inactive: Reference的最终状态,该状态不会再改变。

    其状态转换图如下:

    Reference内部状态转换图

    四种引用类型实现

    不同引用类型的UML类图如下:

    Reference UML类图

    强引用FinalReference

    对象新建后默认为强引用类型的,是普遍对象引用的类型。查看FinalReference在JDK中的源码发现其只有一个空实现,这也说明强引用是“默认引用类型”。

    /**
     * Final references, used to implement finalization
     */
    class FinalReference<T> extends Reference<T> {
        public FinalReference(T referent, ReferenceQueue<? super T> q) {
            super(referent, q);
        }
    }
    

    软引用SoftReference

    软引用是用来描述一些“还有用但是非必须”的对象。软引用的回收策略在不同的JVM实现会略有不同,JVM不仅仅只会考虑当前内存情况,还会考虑软引用所指向的referent最近的使用情况和创建时间来综合决定是否回收该referent。软引用保存了两个变量:

    • timestamp:每次调用get方法都会更新时间戳。JVM可以利用该字段来选择要清除的软引用,但不是必须要这样做。
    • clock:时间锁,由垃圾收集器更新。

    因此,任何GC都可以使用这些字段并定义清除软引用的策略,例如:最后清除最近创建的或最近使用的软引用。

    /**
     * 软引用对象由垃圾收集器根据内存需要决定是否清除。软引用经常用于实现内存敏感的缓存。
     *
     * 假如垃圾收集器在某个时间确定对象是软可达的,此时它可以选择原子地清除
     * 指向该对象的所有软引用,以及从该对象通过强引用链连接的其他软可达对象的所有软引用。
     * 与时同时或者之后的某个时间,它会将注册了reference queues的新清除的软引用加入队列。
     *
     * 在虚拟机抛出OutOfMemoryError异常之前,将保证清除对软可达对象的所有软引用。
     * 不过,并没有对清除软引用的时间以及清除顺序施加强制约束。
     * 但是,鼓励虚拟机实现偏向不清除最近创建或最近使用的软引用。
     *
     * 该类的直接实例可用于实现简单的缓存。
     * 该类或其派生子类也可用于更大的数据结构以实现更复杂的高速缓存。
     * 只要软引用的引用对象还是强可达的,即还在实际使用中,软引用就不会被清除。
     * 因此,复杂的高速缓存可以通过持有对最近使用缓存对象的强引用来防止其被清除,
     * 而不常使用的剩余缓存对象由垃圾收集器决定是否清除。
     */
    public class SoftReference<T> extends Reference<T> {
    
    	// 时间锁,由垃圾收集器更新。
        static private long clock;
    
    	// 每次调用get方法都会更新该时间戳。JVM可能会在选择要清除的软引用时使用该字段,
    	// 但这不是强制必须的。
        private long timestamp;
    	
    	// 返回对象的引用。如果该引用对象已经被程序或者垃圾收集器清除,则返回null。
    	// 把最近一次垃圾回收时间赋值给timestamp
        public T get() {
            T o = super.get();
            if (o != null && this.timestamp != clock)
                this.timestamp = clock;
            return o;
        }
    
    }
    

    弱引用WeakReference

    当一个对象没有被强引用或者软引用连接,但被弱引用连接时,则处于弱可达状态。只要发生GC,弱可达的对象就会被清除,同时会把弱引用加入到注册的引用队列中(如果存在的话)。弱引用对GC几乎是没有影响的,它不影响对应的referent被终结(finalized)和回收(reclaimed)。因此,弱引用最常用于实现规范化映射(canonicalizing mappings),例如哈希表,如果它们在程序中未被引用,则其键和值将从映射中删除。

    /**
     * 弱引用对象不能阻止自身的引用被回收。
     * 弱引用常用于实现规范化映射(对象实例可以在程序的多个地方同时使用)。
     *
     * 假如垃圾收集器在某个时间点确定对象是弱可达的。那时它将原子地清除对该对象的所有弱引用
     * 以及该引用通过强引用或者软引用连接的所有其他弱可达对象的所有弱引用。
     * 同时,它将表明前面所指的所有弱可达对象都可以执行finalize方法。
     * 与此同时或之后某一个时间,它将注册了reference queues的那些新清除弱引用加入队列。
     */
    public class WeakReference<T> extends Reference<T> {
    
    	// 创建没有注册ReferenceQueue的弱引用
        public WeakReference(T referent) {
            super(referent);
        }
    
    	// 创建注册了ReferenceQueue的弱引用
        public WeakReference(T referent, ReferenceQueue<? super T> q) {
            super(referent, q);
        }
    }
    

    虚引用PhantomReference

    虚引用是所有引用类型中最弱的一种。一个对象是否关联到虚引用,完全不会影响该对象的生命周期,也无法通过虚引用来获取一个对象的实例。为对象设置一个虚引用的唯一目的是:能在此对象被垃圾收集器回收的时候收到一个系统通知,它就是利用ReferenceQueue实现的。当referent被gc回收时,JVM自动把虚引用对象本身加入到ReferenceQueue中,表明该reference指向的referent被回收。然后可以通过去queue中取到reference,可以通过这个来做额外的清理工作。可以用虚引用代替对象finalize方法来实现资源释放,这样更加灵活和安全。

    /**
     * 虚引用对象在被垃圾收集器检查到后加入reference queues队列,否则会被回收。
     * 虚引用最常用于实现比Java finalization机制更灵活的安排额外的清理工作。
     *
     * 如果垃圾收集器在某个时间点确定虚引用对象是虚可达的,那么在那个时间或之后某个时间它会将引用加入reference queues队列。
     *
     * 为了确保可回收对象保持不变,虚引用的引用无法使用:虚引用对象的get方法始终返回null。
     *
     * 与软引用和弱引用不同,当虚引用加入reference queues队列后垃圾收集器不会被自动清除。
     * 只通过虚引用可达的对象将保持不变,直到所有此类引用都被清除或自已变为不可达。
     */
    public class PhantomReference<T> extends Reference<T> {
    
        // 由于不能通过虚引用访问对象,因此此方法始终返回null。
        public T get() {
            return null;
        }
    
        // 使用空ReferenceQueue队列创建一个虚引用没有意义:它的get方法总是返回null,
    	// 并且由于它没有注册队列,所以也不会被加入队列有任何清理前的预处理操作。
        public PhantomReference(T referent, ReferenceQueue<? super T> q) {
            super(referent, q);
        }
    }
    
    展开全文
  • java变量的两种类型

    千次阅读 2019-01-24 16:09:59
    首先要明白为什么需要数据类型? 数据类型在计算机语言中,是对内存位置的一个抽象的表达方式。...java中的变量分为两种类型 - 基本类型 int、float、double、boolean、char… 不具备对象的特性(不...

    首先要明白为什么需要数据类型?
    数据类型在计算机语言中,是对内存位置的一个抽象的表达方式。不同类型的变量在内存中分配的字节数不同,同时存储方式也是不同的。所以给变量赋值前需要先确定变量的类型,即确定了数据需分配内存空间的大小,数据在内存的存储方式
    JAVA是强类型语言。

    java中的变量分为两种类型

    - 基本类型

    int、float、double、boolean、char…
    不具备对象的特性(不能调用方法、功能简单)
    直接存储在内存中的内存栈上的,数据本身的值就是存储在栈空间里面

    为了让基本数据类型也具备对象的特性,JAVA为每个基本数据类型都提供了一个包装类,这样我们就可以像操作对象那样来操作基本数据类型。

    基本类型和包装类之间的对应关系
    在这里插入图片描述
    可以这么记:
    int——>Integer
    char——>Character
    其他——>字母不变(首字母小写变大写)

    包装类主要提供了两大类方法

    • 将本类型和其他基本类型进行转换的方法
    • 将字符串和本类型及包装类互相转换的方法

    Integer包装类的常用方法
    包装类——>基本数据类型在这里插入图片描述

    基本类型和包装类之间的转换

    在 JDK1.5 引入自动装箱和拆箱的机制后,包装类和基本类型之间的转换就更加轻松便利了。

    Integer a = new Integer(3);     //定义Integer包装类对象,值为3
    int b = a + 5;            //将对象和基本类型进行运算
    

    装箱:把基本类型转换成包装类,使其具有对象的性质,又可分为手动装箱和自动装箱

    int i = 10;           //定义一个int基本类型值
    Integer x = new Integer(i);                //手动装箱
    Integer y = i;                        //自动装箱
    

    拆箱:和装箱相反,把包装类对象转换成基本类型的值,又可分为手动拆箱和自动拆箱

    Integer j = new Integer(8);           //定义一个Integer包装类对象,值为8
    int m = j.intValue();          //手动拆箱为int类型
    int n = j;                        //自动拆箱为int类型
    

    基本类型和字符串之间的转换

    基本类型转换为字符串有三种方法:
    1.使用包装类的toString()方法
    2.使用String类的valueOf()方法
    3.用一个空字符串加上基本类型

    int c =10;            //基本数据类型
    String str1 = Integer.toString(c);           //方法1
    String str2 = String.valueOf(c);            //方法2
    String str3 = c + " ";                             //方法3
    

    字符串转换成基本类型有两种方法
    1.调用包装类的parseXXX静态方法
    2.调用包装类的valueOf()方法转换为基本类型的包装类,会自动拆箱

    String str = "8";
    int d  = Integer.parseInt(str);            //方法1
    int  e = Integer.valueOf(str);            //方法2
    

    注意:
    parseInt(String s) 是把字符串——>基本数据类型 (返回int(以整型为例))
    valueOf(String s) 是把字符串——>包装类对象 (返回Integer(以整型为例))

    int  e = Integer.valueOf(str); 
    

    虽然valueOf(str)将字符串——>包装类对象,但是JAVA会自动拆箱,使其转换为基本类型。

    .valueOf前面是什么就转成什么类型

    - 引用类型

    继承于Object类, 是一个对象类型。
    按照Java里面存储对象的内存模型来进行数据存储的,使用内存堆和内存栈进行数据存储。
    引用存储在有序的内存栈上的
    对象本身的值存储在内存堆上的

    基本数据类型和引用类型的主要区别
    基本数据类型只有一块存储空间(分配在stack中)
    引用类型有两块存储空间(一块在stack中,一块在heap中)

    在这里插入图片描述
     在上图中引用类型在传参时不是在heap中再分配一块内存来存变量c 所指向的A(),而是让a 指向同一个A 的实例,这就与C++ 中的指针一样,先声明指针变量a,b,c,d 在传参的时候让a 指向c所指向的内存,让 d 指向 b 所指向的内存。很明显Java中的引用与C++中的指针在原理上是相类似的,但记住Java没有指针,只有引用。

    • 简单类型是按值传递
      Java 方法的参数是简单类型的时候,是按值传递的 。
      以参数形式传递简单类型的变量时,实际上是将参数的值作了一个拷贝传进方法函数的,那么在方法函数里再怎么改变值,其结果都只是改变了拷贝的值,而不是原值
      所以像swap(a,b)的例子,传进简单类型是不会交换的,只是把参数的副本进行了交换,原值还是不变。

    • 引用
      引用其实就像是一个对象的名字或者别名。
      一个对象在内存中会请求一块空间来保存数据,根据对象的大小,它可能需要占用的空间大小也不等。访问对象的时候,我们不会直接是访问对象在内存中的数据,而是通过引用去访问引用也是一种数据类型,我们可以把它想象为类似 C++ 语言中指针的东西,它指示了对象在内存中的地址——只不过我们不能够观察到这个地址究竟是什么。
      如果我们定义了不止一个引用指向同一个对象,那么这些引用是不相同的,因为引用也是一种数据类型,需要一定的内存空间(stack,栈空间)来保存。但是它们的值是相同的,都指示同一个对象在内存(heap,堆空间)的中位置。比如:

      String a=“This is a Text!”;

      String b=a;

    在这里插入图片描述
     通过上面的代码和图形示例不难看出,a 和 b 是不同的两个引用,我们使用了两个定义语句来定义它们。但它们的值是一样的,都指向同一个对象 “This is a Text!”。
    注意:String 对象的值本身是不可更改的 (像 b = “World”; b = a; 这种情况不是改变了 “World” 这一对象的值,而是改变了它的引用 b 的值使之指向了另一个 String 对象 a)。

    两个要点

    (1) 引用是一种数据类型(保存在stack中),保存了对象在内存(heap,堆空间)中的地址,这种类型即不是我们平时所说的简单数据类型也不是类实例(对象);

    *(引用类型变量存储在栈内存中,保存的是实际对象在堆内存中的地址,实际对象中保存着内容)

    (2) 不同的引用可能指向同一个对象,换句话说,一个对象可以有多个引用,即该类类型的变量。

    本人原创,如转载请告知,如有问题,请交流!

    展开全文
  • java中的五种引用数据类型(对象类型

    万次阅读 多人点赞 2019-01-20 14:38:23
    Java有 5种引用类型(对象类型):类 接口 数组 枚举 标注 引用类型:底层结构和基本类型差别较大 JVM的内存空间: (1). Heap 堆空间:分配对象 new Student() (2). Stack 栈空间:临时变量 Student stu (3)...

    注意,不是JVM中的四种引用类型:强、软、弱、虚引用。
    详见我的另一篇文章《JVM中的四种引用类型》

    Java有 5种引用类型(对象类型):类 接口 数组 枚举 标注

    引用类型:底层结构和基本类型差别较大

    JVM的内存空间:
    (1). Heap 堆空间:分配对象 new Student()
    (2). Stack 栈空间:临时变量 Student stu
    (3).Code 代码区 :类的定义,静态资源 Student.class

    Student stu = new Student(); //new 在内存的堆空间创建对象
    stu.study();                   //把对象的地址赋给stu引用变量
    

    上例实现步骤:
    a.JVM加载Student.class 到Code区
    b.new Student()在堆空间分配空间并创建一个Student实例
    c.将此实例的地址赋值给引用stu, 栈空间

    基本数据类类型存的是数值本身,而引用类型变量在内存放的是数据的引用,并不是数据的本身,引用类型变量是以间接方式去获取数据。引用类型变量都属于对象类型,如:数组、类、字符串等都属于引用类型变量。所以,引用类型变量里面存放的是数据的地址。

    对于 引用变量的比较一般是有两个不同的方法
    1)比较两个变量是不是指向同一个对象,此时,需要比较 a b 中的地址是不是执行同一个值 ,因为此时比较的是 a b 中的地址值,要用 ==
    2)比较 a b 分别对应不同的对象,此时 a b 中的地址 一定是不同的了 ,此时比较的是对象的值 ,因此这里的比较只能用equals

    展开全文
  • JS有六大数据类型: Number、String、Boolean、Null、Undefined、Object ​ 这些数据类型可以通过 typeof关键字 进行检测 typeof 123 //number typeof 'abc' //string typeof true //boolean typeof ...

    JS有六大数据类型:

    Number、String、Boolean、Null、Undefined、Object

    这些数据类型可以通过 typeof关键字 进行检测

    typeof 123			//number
    
    typeof 'abc'		//string
    
    typeof true			//boolean
    
    typeof undefined	//undefined
    
    typeof null			//object
    
    typeof { }			//object
    
    typeof [ ]			//object
    
    typeof function(){}	//function
    

    null类型进行typeof操作符后,结果是object,原因在于,null类型被当做一个空对象引用。

    JS的这些数据类型又分为两大类:

    一种存在堆中,叫做引用数据类型,做等号赋值操作进行的是址传递

    一种存在栈中,叫做基本数据类型,做等号赋值操作进行的是值传递

    存在堆中:引用数据类型(object、function)

    存在栈中:基本数据类型(number、string、boolean、null、unedfined)

    数组Array被归为object类型,用typeof 检测不出来,需要用到 instanceof

    var arr = [];
    console.log(arr instanceof Array);        //true 
    
    展开全文
  • js变量存在的两种类型(原始值,引用值) 由于最近面试问到过这个问题,所以特定补一下这里面的知识: 原始值类型:Undefined、Null、Boolean、Number 和 String 型;存储在栈(stack)中的简单数据段,也就是说,...
  • golang中的值类型引用类型

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

    万次阅读 2019-07-05 16:48:32
    Java类型一般有两种,即基本数据类型引用数据类型。其中,引用数据类型在存储堆中对需要引用的对象进行引用引用是Java面向对象的一个特点,在Java入门中,我们会接触到四种Java的引用类型,接下来就说说这四种...
  • 我们都知道,c#的大数据类型分别为值类型(int,float,double,char,DataTime)和引用类型(类、托管、数组和接口)。很多人或许闭着眼睛都能说出值类型包括简单类型、结构体类型和枚举类型引用类型包括自定义类、数组...
  •   JS1997年标准化以后,定义了六内置类型,包括五原始(Primitive)类型以及一种引用类型,ES6又新增了一原始类型-----symbol,接下来咱们一一来分析下这七内置类型: 六原始类型 分别是: number string ...
  • java数据类型(八基本数据类型+三种引用类型

    万次阅读 多人点赞 2017-02-08 11:05:32
    一:java中数据类型分为大数据类型: 1基本数据类型;2引用数据类型 二:注意事项: 1:java开发过程中整型用int、小数用double、布尔用boolean; 2:类型转换都是小范围向大范围转换,大范围往小范围转化...
  • java基本类型引用类型

    万次阅读 多人点赞 2018-01-04 17:30:32
    java基本类型引用类型 目录 java基本类型引用类型 ...一基本数据类型引用类型 三基本类型引用类型的区别 ...java中一共分为8基本数据类型:byte、short、int、long、float、double、char、b
  • Java 的8基本类型和3种引用类型

    千次阅读 2017-05-18 11:21:51
    1、计算机的内存单位 计算机中的数据都是以 0 和 1 来表示的,其中一个 0 或者一个 1 称之为一位 (bit)。 8位称为一个字节 (Byte),个字节称为一个字 (Word) ,四个字节...2、Java 有四类8基本类型 a、4...
  • Java 基本数据类型引用类型 变量就是申请内存来存储值。也就是说,当创建变量的时候,需要在...Java中有类型 内置数据类型(基本数据类型引用数据类型   内置数据类型(基本数据类型) Java语...
  • Java中的四种引用类型是哪些?

    千次阅读 2020-07-01 23:10:51
    从一开始学习Java我们就知道Java的数据类型一般有两种,一种是基本数据类型,另一种是引用数据类型。其中,基本数据类型的值通常储存在栈内存中,用于对该类型的对象进行存储;而引用数据类型则在存储堆中对需要引用...
  • 引用类型数组

    千次阅读 2019-03-11 19:48:26
    两种类型数组的图解 基本类型数组:arr是引用,放在栈内存中,new的部分属于对象,在堆内存中。arr里存的是对象的地址。 引用类型数组: 第一句话:stus是引用类型数组的变量(简称引用),存在栈内存,里面放的...
  • 什么是Java的对象引用? Java中都有哪些类型的对象引用? Java中提供的Java对象引用主要有什么目的? 通过本文,你就能很清楚得了解Java的对象引用
  • 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基础知识面试题(2020最新版)

    万次阅读 多人点赞 2020-02-19 12:11:27
    文章目录Java概述何为编程什么是Javajdk1.5之后的三大版本JVM、JRE和JDK的关系什么是跨平台性?原理是什么Java语言有哪些...Java和C++的区别Oracle JDK 和 OpenJDK 的对比基础语法数据类型Java有哪些数据类型switc...
  • Java的数据类型分为(大类):基本数据类型引用类型 一、基本数据类型:是进行内容的操作,而不是进行内存的操作; Java数据类型(八大基本数据类型):六数字类型(四个整数型,个浮点型),一 字符类型...
  • C#详解值类型引用类型区别

    万次阅读 多人点赞 2016-04-20 17:59:42
    首先,什么是值类型,什么是引用类型? 在C#中值类型的变量直接存储数据,而引用类型的变量持有的是数据的引用,数据存储在数据堆中。 值类型(value type):byte,short,int,long,float,double,decimal,...
  • 一、基本数据类型: byte:Java中最小的数据类型,在内存中占8位(bit),即1个字节,取值范围-128~127,默认值0 short:短整型,在内存中占16位,即2个字节,取值范围-32768~32717,默认值0 int:整型,用于存储...
  • java四种引用类型

    万次阅读 2020-05-11 10:04:53
    编程语言都有自己操作内存中元素的方式,例如在 C 和 C++ 里是通过指针,而在 Java 中则是通过“引用”。 java不同于c/c++,它不需要程序员自已来管理内存(分配,释放内存),java 会自己来管理内存,比如销毁...
  • Java资源共享 2017-12-14 09:53:56 ...这四种引用的强度按照上面的顺序依次减弱,下面通过几个例子简单了解一下这四种引用类型。 StrongReference 这个不用多讲了,这是 java 默认的引用类型,如果不特意
  • 一个变量可以存放两种类型的值,基本类型的值(primitive values)和引用类型的值(reference values)。 ES6 引入了一种新的原始数据类型 Symbol,表示独一无二的值。它是 JavaScript 语言的第七种数据类型,前六...
  • java中引用数据类型有哪些?

    万次阅读 多人点赞 2016-07-18 09:45:37
    Java中有俩数据类型,其中主要有8中基本数据类型引用数据类型,除了8中基本数据类型以外都是引用数据类型,8中基本数据类型分别是byte,short,int,long,char,boolean,float,double,具体如下:1、boolean:数据值...
  • 基本类型,或者叫做内置类型,是JAVA中不同于类的特殊类型。它们是我们编程中使用最...Java基本类型共有八,基本类型可以分为三类,字符类型char,布尔类型boolean以及数值类型byte、short、int、long、float、double
  • java 值类型引用类型

    千次阅读 2017-09-11 16:34:21
    java这两种数据类型分别有哪些?java 中的数据类型分为两大类:值类型(基本数据类型)和引用类型(复合数据类型) 一,值类型分为 1,整数类型(byte,short,int,long) 2,浮点类型(float,double) 3,布尔类型...
  • C#中值类型引用类型的区别

    千次阅读 2018-09-28 12:09:01
    值类型是直接存储一个数值,而引用类型是存储对值的引用,这两种类型分别存储在不用的内存区域。而从内存上看,值类型是在栈中的操作,而引用类型是在堆中的操作。值类型是具体的那个数值所占用的空间大小,而引用...
  • 关于String为值类型还是引用类型的讨论一直没有平息,最近一直在研究性能方面的问题,今天再次将此问题进行一次明确。希望能给大家带来点帮助。 如果有错误请指出。 来看下面例子: 复制代码 复制代码 //值类型 int ...
  • 一、什么是值类型,什么是引用类型 概念:值类型直接存储其值,而引用类型存储对其值的引用。部署:托管堆上部署了所有引用类型引用类型:基类为Objcet 值类型:均隐式派生自System.ValueType: 值类型...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,127,102
精华内容 450,840
关键字:

引用的两种类型