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

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

     

    动力节点Java培训最新上线Java实验班,等你来测试自己适不适合学习Java编程哦!

     

    Java类型一般有两种,即基本数据类型与引用数据类型。其中,引用数据类型在存储堆中对需要引用的对象进行引用,引用是Java面向对象的一个特点,在Java入门中,我们会接触到四种Java的引用类型,接下来就说说这四种Java引用类型有哪些吧:

     

     

    1、Java中有哪几种引用?它们的含义和区别是什么?

     

      从JDK1.2开始,Java中的引用类型分为四种,分别是:

     

    ①强引用(StrongReference)

     

    ②软引用(SoftRefernce)

     

    ③弱引用(WeakReference)

     

    ④虚引用(PhantomReference)

     

      强引用-StrongReference

     

      这种引用是平时开发中最常用的,例如Stringstrong=newString("StrongReference"),当一个实例对象具有强引用时,垃圾回收器不会回收该对象,当内存不足时,宁愿抛出OutOfMemeryError异常也不会通过回收强引用的对象,因为JVM认为强引用的对象是用户正在使用的对象,它无法分辨出到底该回收哪个,强行回收有可能导致系统严重错误。

     

      软引用-SoftReference

     

      如果一个对象只有软引用,那么只有当内存不足时,JVM才会去回收该对象,其他情况不会回收。软引用可以结合ReferenceQueue来使用,当由于系统内存不足,导致软引用的对象被回收了,JVM会把这个软引用加入到与之相关联的ReferenceQueue中。

     

    ReferenceQueuereferenceQueue=newReferenceQueue();

     

    SoftReference<Book>softReference=newSoftReference<>(newBook(),referenceQueue);

     

    Bookbook=softReference.get();

     

    Referencereference=referenceQueue.poll();

     

      当系统内存不足时,触发gc,这个Book就会被回收,reference将不为null。

     

      弱引用-WeakReference

     

      只有弱引用的对象,当JVM触发gc时,就会回收该对象。与软引用不同的是,不管是否内存不足,弱引用都会被回收。弱引用可以结合ReferenceQueue来使用,当由于系统触发gc,导致软引用的对象被回收了,JVM会把这个弱引用加入到与之相关联的ReferenceQueue中,不过由于垃圾收集器线程的优先级很低,所以弱引用不一定会被很快回收。下面通过一个主动触发gc的例子来验证此结论。

     

    ReferenceQueuereferenceQueue=newReferenceQueue();

     

    WeakReference<Book>weakReference=newWeakReference(newBook(),referenceQueue);

     

    Bookbook=softReference.get();

     

    System.gc();

     

    //Runtime.getRuntime().gc();

     

    Referencereference=referenceQueue.poll();

     

      当然这不是每次都能复现,因为我们调用System.gc()只是告诉JVM该回收垃圾了,但是它什么时候做还是不一定的,但就我测试来看,只要多写几次System.gc(),复现的概率还是很高的。

     

      虚引用-PhantomReference

     

      如果一个对象只有虚引用在引用它,垃圾回收器是可以在任意时候对其进行回收的,虚引用主要用来跟踪对象被垃圾回收器回收的活动,当被回收时,JVM会把这个弱引用加入到与之相关联的ReferenceQueue中。与软引用和弱引用不同的是,虚引用必须有一个与之关联的ReferenceQueue,通过phantomReference.get()得到的值为null,试想一下,如果没有ReferenceQueue与之关联还有什么存在的价值呢?

     

    PhantomReference<Book>phantomReference=newPhantomReference<>(newBook(),referenceQueue);

     

    Bookbook=phantomReference.get();//此值为null

     

    Referencereference=referenceQueue.poll();

     

     

    展开全文
  • JavaScript数据类型,包括原始类型和引用类型哪些? 原始类型有五个 Number类型 专门保存数字的类型,可用于进行数学计算等的数值 String类型 专门用来保存字符串的类型;” “,用来存储字符串类型的文本. ...

    问题 : http://bbs.daxiangclass.com/?thread-334.htm

    JavaScript数据类型,包括原始类型和引用类型有哪些?

    原始类型有五个
    • Number类型 专门保存数字的类型,可用于进行数学计算等的数值
    • String类型 专门用来保存字符串的类型;” “,用来存储字符串类型的文本.
    • Boolean类型 专门用来保存真或者假的类型,值二选一,true or false
    • Null类型 不知向任何地址,手动赋值,清空内容等….
    • Undefined 表示未定义,这个值的变量不含有值。

    引用类型有一个 object其中object包括

    • Array类型 数组的每一项可以用来保存任何类型的数据
    • Object类型 我们看到的大多数类型值都是Object类型的实例
    • Function 每个函数都是Function类型的实例
    展开全文
  • 值类型和引用类型,是c#比较基础,也必须掌握的知识点,但是也不是那么轻易就能掌握,今天跟着老胡一起来看看吧。  典型类型 首先我们看看这两种不同的类型有哪些比较典型的代表。  典型值类型 int, long, float, ...
  • 一、什么是值类型,什么是引用类型 概念:值类型直接存储其值,而引用类型存储对其值的引用。部署:托管堆上部署了所有引用类型引用类型:基类为Objcet 值类型:均隐式派生自System.ValueType: 值类型...

    一、什么是值类型,什么是引用类型

    概念:值类型直接存储其值,而引用类型存储对其值的引用。部署:托管堆上部署了所有引用类型。

    引用类型:基类为Objcet

    值类型:均隐式派生自System.ValueType:

     

    值类型:

    byte,short,int,long,float,double,decimal,char,bool 和 struct 统称为值类型。

    引用类型:

    string 和 class统称为引用类型。

    • 值类型变量声明后,不管是否已经赋值,编译器为其分配内存。
    • 引用类型当声明一个类时,只在栈中分配一小片内存用于容纳一个地址,而此时并没有为其分配堆上的内存空间。当使用 new 创建一个类的实例时,分配堆上的空间,并把堆上空间的地址保存到栈上分配的小片空间中。
    • 值类型的实例通常是在线程栈上分配的(静态分配),但是在某些情形下可以存储在堆中。
    • 引用类型的对象总是在进程堆中分配(动态分配)。

    我们来看下面一段代码:

     

    /*
     * ---值类型--
     * 主题:结构体
     */
    
    using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.Text;
    
    namespace ObjectAndValueType
    {
        //定义一个结构体
        public struct SomeValue
        {
            //定义一个整数
            public int Number;
    
        }//Struct_end
    }
    /*
     * ---引用类型--
     * 主题:类
     */
    
    using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.Text;
    
    namespace ObjectAndValueType
    {
        //定义一个类
        class SomeClass
        {
            //定义一个整数
            public int Number;
    
        }//Class_end
    }
    
    using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.Text;
    
    namespace ObjectAndValueType
    {
        class Program
        {
            static void Main(string[] args)
            {
                //实例化一个类对象,并且赋值
                SomeClass sc1 = new SomeClass();
                sc1.Number = 10;
    
                SomeClass sc2 = sc1;
                sc2.Number = 11;
                Console.WriteLine("sc1的值为:{0}\t sc2的值为:{1}",sc1.Number,sc2.Number);
    
                //实例化一个结构体对象,并且赋值
                SomeValue sv1 = new SomeValue();
                sv1.Number = 20;
                SomeValue sv2 = sv1;
                sv2.Number = 22;
                Console.WriteLine("sv1的值为:{0}\t sv2的值为:{1}", sv1.Number, sv2.Number);
    
                Console.ReadLine();
    
            }//Class_end
        }
    }
    

    结果:

     

    值类型在栈内分配空间大小因变量类型而异;

    引用类型在栈内的空间大小相同;

    1. 通用类型系统

    C#中,变量是值还是引用仅取决于其数据类型。

    C#的基本数据类型都以平台无关的方式来定义。C#的预定义类型并没有内置于语言中,而是内置于.NET Framework中。.NET使用通用类型系统(CTS)定义了可以在中间语言(IL)中使用的预定义数据类型,所有面向.NET的语言都最终被编译为IL,即编译为基于CTS类型的代码。

    例如,在C#中声明一个int变量时,声明的实际上是CTS中System.Int32的一个实例。这具有重要的意义:

    • 确保IL上的强制类型安全;
    • 实现了不同.NET语言的互操作性;
    • 所有的数据类型都是对象。它们可以有方法,属性,等。例如:

    int i;

    i = 1;

    string s;

    s = i.ToString();

     

    以下关系图(来自MSDN)说明了这几种类型是如何相关的。注意,类型的实例可以只是值类型或自描述类型,即使这些类型有子类别也是如此。

    类型类别:

    2.值类型

    C#的所有值类型均隐式派生自System.ValueType:

    结构体:struct(直接派生于System.ValueType);

    数值类型:

    整型:sbyte(System.SByte的别名),short(System.Int16),int(System.Int32),long(System.Int64),byte(System.Byte),ushort(System.UInt16),uint(System.UInt32),ulong(System.UInt64),char(System.Char);

    浮点型:float(System.Single),double(System.Double);

    用于财务计算的高精度decimal型:decimal(System.Decimal)。

    bool:bool(System.Boolean的别名);

    用户定义的结构体(派生于System.ValueType)。

    枚举:enum(派生于System.Enum);

    可空类型(派生于System.Nullable<T>泛型结构体,T?实际上是System.Nullable<T>的别名)。

    每种值类型均有一个隐式的默认构造函数来初始化该类型的默认值。例如:

    int i = new int();

    等价于:

    Int32 i = new Int32();

    等价于:

    int i = 0;

    等价于:

    Int32 i = 0;

    引用类型和值类型都继承自System.Object类。不同的是,几乎所有的引用类型都直接从System.Object继承,而值类型则继承其子类,即 直接继承System.ValueType。System.ValueType直接派生于System.Object。即System.ValueType本身是一个类类型,而不是值类型。其关键在于ValueType重写了Equals()方法,从而对值类型按照实例的值来比较,而不是引用地址来比较。

    可以用Type.IsValueType属性来判断一个类型是否为值类型:

    TestType testType = new TestType ();

    if (testTypetype.GetType().IsValueType)

    {

         Console.WriteLine("{0} is value type.", testType.ToString());

    }

     

    3.引用类型

    C#有以下一些引用类型:

    数组(派生于System.Array)

    用户用定义的以下类型:

    类:class(派生于System.Object);

    接口:interface(接口不是一个“东西”,所以不存在派生于何处的问题。Anders在《C# Programming Language》中说,接口只是表示一种约定[contract]);

    委托:delegate(派生于System.Delegate)。

    object(System.Object的别名);

    字符串:string(System.String的别名)。

    可以看出:

    引用类型与值类型相同的是,结构体也可以实现接口;

    引用类型可以派生出新的类型,而值类型不能;

    引用类型可以包含null值,值类型不能(可空类型功能允许将 null 赋给值类型);

    引用类型变量的赋值只复制对对象的引用,而不复制对象本身。而将一个值类型变量赋给另一个值类型变量时,将复制包含的值。

    对于最后一条,经常混淆的是string。我曾经在一本书的一个早期版本上看到String变量比string变量效率高;我还经常听说String是引用类型,string是值类型,等等。例如:

    string s1 = "Hello, ";

    string s2 = "world!";

    string s3 = s1 + s2;//s3 is "Hello, world!"

     

    这确实看起来像一个值类型的赋值。再如:

    string s1 = "a";

    string s2 = s1;

    s1 = "b";//s2 is still "a"

     

    改变s1的值对s2没有影响。这更使string看起来像值类型。实际上,这是运算符重载的结果,当s1被改变时,.NET在托管堆上为s1重新分配了内存。这样的目的,是为了将做为引用类型的string实现为通常语义下的字符串。

     

    4. 值类型和引用类型在内存中的部署

    经常听说,并且经常在书上看到:值类型部署在栈上,引用类型部署在托管堆上。实际上并没有这么简单。

    MSDN上说:托管堆上部署了所有引用类型。这很容易理解。当创建一个应用类型变量时:

    object reference = new object();

     

    关键字new将在托管堆上分配内存空间,并返回一个该内存空间的地址。左边的reference位于栈上,是一个引用,存储着一个内存地址;而这个地址指向的内存(位于托管堆)里存储着其内容(一个System.Object的实例)。下面为了方便,简称引用类型部署在托管推上。

    再来看值类型。《C#语言规范》上的措辞是“结构体不要求在堆上分配内存(However, unlike classes, structs are value types and do not require heap allocation)”而不是“结构体在栈上分配内存”。这不免容易让人感到困惑:值类型究竟部署在什么地方?

     

    4.1数组

    考虑数组:

    int[] reference = new int[100];

    根据定义,数组都是引用类型,所以int数组当然是引用类型(即reference.GetType().IsValueType为false)。

    而int数组的元素都是int,根据定义,int是值类型(即reference[i].GetType().IsValueType为true)。那么引用类型数组中的值类型元素究竟位于栈还是堆?

    如果用WinDbg去看reference[i]在内存中的具体位置,就会发现它们并不在栈上,而是在托管堆上。

    实际上,对于数组:

    TestType[] testTypes = new TestType[100];

    如果TestType是值类型,则会一次在托管堆上为100个值类型的元素分配存储空间,并自动初始化这100个元素,将这100个元素存储到这块内存里。

    如果TestType是引用类型,则会先在托管堆为testTypes分配一次空间,并且这时不会自动初始化任何元素(即testTypes[i]均为null)。等到以后有代码初始化某个元素的时候,这个引用类型元素的存储空间才会被分配在托管堆上。

    4.2类型嵌套

     

    引用类型部署在托管堆上;

    值类型总是分配在它声明的地方:作为字段时,跟随其所属的变量(实例)存储;作为局部变量时,存储在栈上。

    从上下文看,mc是一个局部变量,所以部署在托管堆上,并被栈上的一个引用所持有;

    值类型字段_value1属于引用类型实例mc的一部分,所以跟随引用类型实例mc部署在托管堆上(有点类似于数组的情形);

    value2是值类型局部变量,所以部署在栈上。

    而对于值类型实例,即MyStruct

    根据上下文,值类型实例ms本身是一个局部变量而不是字段,所以位于栈上;

    其引用类型字段_object1不存在跟随的问题,必然部署在托管堆上,并被一个引用所持有(该引用是ms的一部分,位于栈);

    其引用类型局部变量_object2显然部署在托管堆上,并被一个位于栈的引用所持有。

    所以,简单地说“值类型存储在栈上,引用类型存储在托管堆上”是不对的。必须具体情况具体分析

     

     

    C#中,我们用struct/class来声明一个类型为值类型/引用类型。考虑下面的例子:

    SomeType[] oneTypes = new SomeType[100];

    如 果SomeType是值类型,则只需要一次分配,大小为SomeType的100倍。而如果SomeType是引用类型,刚开始需要100次分配,分配后 数组的各元素值为null,然后再初始化100个元素,结果总共需要进行101次分配。这将消耗更多的时间,造成更多的内存碎片。所以,如果类型的职责主 要是存储数据,值类型比较合适。

    一般来说,值类型(不支持多态)适合存储供 C#应用程序操作的数据,而引用类型(支持多态)应该用于定义应用程序的行为。通常我们创建的引用类型总是多于值类型。如果满足下面情况,那么我们就应该创建为值类型:

    该类型的主要职责用于数据存储。

    该类型的共有接口完全由一些数据成员存取属性定义。

    该类型永远不可能有子类。

    该类型不具有多态行为。

     

    5. 辨明值类型和引用类型的使用场合

    在C#中,我们用struct/class来声明一个类型为值类型/引用类型。考虑下面的例子:

    SomeType[] oneTypes = new SomeType[100];

    如 果SomeType是值类型,则只需要一次分配,大小为SomeType的100倍。而如果SomeType是引用类型,刚开始需要100次分配,分配后 数组的各元素值为null,然后再初始化100个元素,结果总共需要进行101次分配。这将消耗更多的时间,造成更多的内存碎片。所以,如果类型的职责主 要是存储数据,值类型比较合适。

    一般来说,值类型(不支持多态)适合存储供 C#应用程序操作的数据,而引用类型(支持多态)应该用于定义应用程序的行为。通常我们创建的引用类型总是多于值类型。如果满足下面情况,那么我们就应该创建为值类型:

    该类型的主要职责用于数据存储。

    该类型的共有接口完全由一些数据成员存取属性定义。

    该类型永远不可能有子类。

    该类型不具有多态行为。

     

     

    值类型和引用类型的区别(小结)

    相同点:

    引用类型可以实现接口,值类型当中的结构体也可以实现接口;

    引用类型和值类型都继承自System.Object类。

     

    1)范围方面

    C#的值类型包括:结构体(数值类型、bool型、用户定义的结构体),枚举,可空类型。

    C#的引用类型包括:数组,用户定义的类、接口、委托,object,字符串。

    2)内存分配方面:

    数组的元素不管是引用类型还是值类型,都存储在托管堆上。

    引用类型在栈中存储一个引用,其实际的存储位置位于托管堆。简称引用类型部署在托管推上。而值类型总是分配在它声明的地方:作为字段时,跟随其所属的变量(实 例)存储;作为局部变量时,存储在栈上。(栈的内存是自动释放的,堆内存是.NET中会由GC来自动释放)

    3)适用场合

    值类型在内存管理方面具有更好的效率,并且不支持多态,适合用做存储数据的载体;引用类型支持多态,适合用于定义应用程序的行为。

    引用类型可以派生出新的类型,而值类型不能,因为所有的值类型都是密封(seal)的;

    引用类型可以包含null值,值类型不能(可空类型功能允许将 null 赋给值类型,如   int? a = null;  );

    引用类型变量的赋值只复制对对象的引用,而不复制对象本身。而将一个值类型变量赋给另一个值类型变量时,将复制包含的值。

     

    值得注意的是,引用类型和值类型都继承自System.Object类。不同的是,几乎所有的引用类型都直接从System.Object继承,而值类型则继承其子类,即 直接继承System.ValueType。即System.ValueType本身是一个类类型,而不是值类型。其关键在于ValueType重写了Equals()方法,从而对值类型按照实例的值来比较,而不是引用地址来比较。

    内容来自:C#的两种类据类型:值类型和引用类型

                      通用类型系统概述

                      C#详解值类型和引用类型区别

                      

     

    展开全文
  • 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 值类型和引用类型

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

    千次阅读 2014-08-30 12:11:57
    引用类型与值类型 值类型是个轻量级类型,引用类型是个 '重量级‘类型。 值类型存放的是对象本身,而引用类型存放的对象存放的内存地址 1.内存分配 值类型 的实例一般在线程栈上分配, 引用类型的实例则在托管堆上...
  • golang中的值类型和引用类型

    千次阅读 2019-08-20 20:48:29
    值类型与引用类型 值类型 值类型:这些类型的变量直接指向存在内存中的值,值类型的变量的值存储在栈中。当使用等号=将一个变量的值赋给另一个变量时,如 j = i ,实际上是在内存中将 i 的值进行了拷贝。可以通过 &...
  • 【js中的基本类型和引用类型哪些,有什么区别?】 每篇分享文从 【背景介绍】【知识剖析】【常见问题】【解决方案】【编码实战】【扩展思考】【更多讨论】【参考文献】 八个方面深度解析前端知识/技能,本篇...
  • C#详解值类型和引用类型区别

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

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

    千次阅读 2016-03-02 14:39:17
    1. 值类型和引用类型的区别? 2. 结构和类的区别? 3. delegate是引用类型还是值类型?enum、int[]和string呢? 4. 堆和栈的区别? 5. 什么情况下会在堆(栈)上分配数据?它们有性能上的区别吗? 6.“结构”...
  • 引用类型数组

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

    万次阅读 多人点赞 2016-07-18 09:45:37
    Java中有俩种数据类型,其中主要有8中基本数据类型引用数据类型,除了8中基本数据类型以外都是引用数据类型,8中基本数据类型分别是byte,short,int,long,char,boolean,float,double,具体如下:1、boolean:数据值...
  • Swift 值类型和引用类型

    千次阅读 2018-03-13 09:28:21
    Swift中有两种类型:值类型(Value Type),引用类型(Reference Type)。1. 值类型在Swift中,所有的基本类型:整型(Int)、浮点型(Float)、布尔类型(Boolean)、字符串类型(String)、数组(Array)、字典...
  • Java原始类型和引用类型

    千次阅读 2016-06-05 16:30:47
    在Java中提供了两种数据类型:原始类型和引用类型。 本文主要针对这两种类型进行说明,便于在实际开发过程中正确选择合适的数据类型。 1. 原始类型  Java中的原始类型是不同于类的基本数据类型,包括如下8种...
  • C#中值类型与引用类型的区别

    千次阅读 2018-09-28 12:09:01
    值类型是直接存储一个数值,而引用类型是存储对值的引用,这两种类型分别存储在不用的内存区域。而从内存上看,值类型是在栈中的操作,而引用类型是在堆中的操作。值类型是具体的那个数值所占用的空间大小,而引用...
  • C# 哪些引用类型??

    千次阅读 2019-10-09 09:33:01
    引用类型:类class,对象object,数组type [],字符串 string,委托delegate,接口interface 值类型:整数int,浮点数float double,布尔bool,字符char,结构struct,枚举enum ...
  • 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 是...
  • 值类型和引用类型

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

    千次阅读 2019-01-07 13:39:35
    1最本质的区别 值类型:内存中变量存储的是具体的值 比如: var num int num存放的是具体的int值  但是变量在内存中的地址可以通过 &...2.值类型,引用类型都包括哪些 基本的数据类型 int系列,float系列,b...
  • 基本类型与引用类型

    千次阅读 2016-03-25 13:04:33
    基本类型与引用类型
  • C#中引用类型和值类型分别有哪些

    万次阅读 2018-06-15 02:12:58
    C#的引用类型包括:数组,用户定义的类、接口、委托,object,字符串。 数组的元素,不管是引用类型还是值类型,都存储在托管堆上。 引用类型在栈中存储一个引用,其实际的存储位置位于托管堆。为了方便,本文简称...
  • 1、js的基本类型有哪些? 基本数据类型:按值访问,可...2.引用类型哪些? 引用类型:当复制保存着对象的某个变量时,操作的是对象的引用,但在为对象添加属性时,操作的是实际的对象。引用类型值指那些可能为多...
  • 在java多态性中这样一句话: 实际调用的方法版本取决于对象的类型不是引用变量的类型。 此话什么意思?能否举个简单例子 public class Polymorphism { public static void main(String[] args) { //既然是多态,...
  • 基本类型和引用类型区别

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

    千次阅读 2018-05-04 20:50:10
    一、值类型和引用类型值类型:int、float、bool和string这些类型都属于值类型,使用这些类型的变量直接指向存在内存中的值,值类型的变量的值存储在栈中。当使用等号=将一个变量的值赋给另一个变量时,如 j = i ,...
  • JS数据类型引用数据类型

    千次阅读 2019-06-28 16:46:51
    1、引用数据类型也就是对象数据...2、引用类型的值可以改变: let person = {name: 'lisa'} person.name = 'Jane' // 通过修改对象属性值更改对象 console.log(person) // 输出:{name: "Jane"} person.age =...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,960,430
精华内容 784,172
关键字:

哪些类型不是引用类型