精华内容
下载资源
问答
  • 引用类型和原始类型具有不同的特征用法,它们包括:大小速度问题,这种类型以哪种类型的数据结构存储,当引用类型和原始类型用作某个的实例数据时所指定的缺省值。对象引用实例变量的缺省值为 null,而原始...

    Java 提供两种不同的类型:引用类型和原始类型(或内置类型)。另外,Java 还为每个原始类型提供了封装类(Wrapper)。如果需要一个整型变量,是使用基本的 int 型呢,还是使用 Integer 类的一个对象呢?如果需要声明一个布尔类型,是使用基本的 boolean,还是使用 Boolean 类的一个对象呢?本文可帮助您作出决定。

    下表列出了原始类型以及它们的对象封装类。

    原始类型封装类
    boolean Boolean
     charCharacter
    byte Byte
    short Short
    intInteger

    long  

    Long
    floatFloat
    double Double

    引用类型和原始类型的行为完全不同,并且它们具有不同的语义。例如,假定一个方法中有两个局部变量,一个变量为 int 原始类型,另一个变量是对一个 Integer 对象的对象引用:

    int i = 5; // 原始类型  Integer j = new Integer(10); // 对象引用

    这两个变量都存储在局部变量表中,并且都是在 Java 操作数堆栈中操作的,但对它们的表示却完全不同。(本文中以下部分将用通用术语堆栈代替操作数堆栈或局部变量表。)原始类型 int 和对象引用各占堆栈的 32 位。(要表示一个 int 或一个对象引用,Java 虚拟机实现至少需要使用 32 位存储。)Integer 对象的堆栈项并不是对象本身,而是一个对象引用。

    Java 中的所有对象都要通过对象引用访问。对象引用是指向对象存储所在堆中的某个区域的指针。当声明一个原始类型时,就为类型本身声明了存储。

    引用类型和原始类型具有不同的特征和用法,它们包括:大小和速度问题,这种类型以哪种类型的数据结构存储,当引用类型和原始类型用作某个类的实例数据时所指定的缺省值。对象引用实例变量的缺省值为 null,而原始类型实例变量的缺省值与它们的类型有关。

    许多程序的代码将同时包含原始类型以及它们的对象封装。当检查它们是否相等时,同时使用这两种类型并了解它们如何正确相互作用和共存将成为问题。程序员必须了解这两种类型是如何工作和相互作用的,以避免代码出错。

    例如,不能对原始类型调用方法,但可以对对象调用方法:

    int j = 5;  j.hashCode(); // 错误  //。..  Integer i = new Integer(5);  i.hashCode(); // 正确

    使用原始类型无须调用 new,也无须创建对象。这节省了时间和空间。混合使用原始类型和对象也可能导致与赋值有关的意外结果。看起来没有错误的代码可能无法完成您希望做的工作。例如:

    import java.awt.Point;  class Assign  {  public static void main(String args[])  {  int a = 1;  int b = 2;  Point x = new Point(0,0);  Point y = new Point(1,1); //1  System.out.println(“a is ” + a);  System.out.println(“b is ” + b);  System.out.println(“x is ” + x);  System.out.println(“y is ” + y);  System.out.println(“Performing assignment and ” +  “setLocation.。.”);  a = b;  a++;  x = y; //2  x.setLocation(5,5); //3  System.out.println(“a is ”+a);  System.out.println(“b is ”+b);  System.out.println(“x is ”+x);  System.out.println(“y is ”+y);  }  }

    这段代码生成以下输出:

    a is 1  b is 2  x is java.awt.Point[x=0,y=0]  y is java.awt.Point[x=1,y=1]  Performing assignment and setLocation.。.  a is 3  b is 2  x is java.awt.Point[x=5,y=5]  y is java.awt.Point[x=5,y=5]

    修改整数 a 和 b 的结果没什么意外的地方。b 的值被赋予整型变量 a,结果 a 的值增加了 1。这一输出反映了我们希望发生的情况。但是,令人感到意外的,是在赋值并调用 setLocation之后 x 和 y 对象的输出。我们在完成 x = y 赋值之后特意对 x 调用了 setLocation,x 和 y 的值怎么会相同呢?我们毕竟将 y 赋予 x,然后更改了 x,这与我们对整数 a 和 b 进行的操作没什么不同。 

    这种混淆是由原始类型和对象的使用造成的。赋值对这两种类型所起的作用没什么不同。但它可能看起来所有不同。赋值使等号 (=) 左边的值等于右边的值。这一点对于原始类型(如前面的 int a 和 b)是显而易见的。对于非原始类型(如 Point 对象),赋值修改的是对象引用,而不是对象本身。因此,在语句

    x = y;

    之后,x 等于 y。换句话说,因为 x 和 y 是对象引用,它们现在引用同一个对象。因此,对 x 所作的任何更改也会更改 y。下面是 //1 处的代码执行以后的情况:

    执行 //2 处的赋值以后情况如下:

    当在 //3 处调用 setLocation 时,这一方法是对 x 引用的对象执行的。因为 x 引用的 Point 对象也正是 y 所引用的对象,所以我们现在得到以下结果:

    因为 x 和 y 引用同一个对象,所以对 x 执行的所有方法与对 y 执行的方法都作用于同一个对象。

    区分引用类型和原始类型并理解引用的语义是很重要的。若做不到这一点,则会使编写的代码无法完成预定工作。

    希望通过以上内容的介绍,能够给你带来帮助。

    另外,引用类型的一些优势:

    对象可以被序列化,原始类型不行。
    对象提供的方法可以灵活转换,可以扩展,原始类型不行
    在集合类中只能使用对象,不能使用原始类型
    原始类型没有null的概念,对象有,某些情况下需要辨别某个参数是否被初始化了,如果使用原始类型,那么0的值不知道是初始值还是没有初始化系统自动给的。
    引用类型可以封装


    转载于:https://my.oschina.net/qq2636472828/blog/210295

    展开全文
  • Java原始类型和引用类型

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

    在Java中提供了两种数据类型:原始类型和引用类型。 本文主要针对这两种类型进行说明,便于在实际开发过程中正确选择合适的数据类型。


    1.  原始类型

         Java中的原始类型是不同于类的基本数据类型,包括如下8种基本类型:double、float、byte、short、int、long、char、boolean。这8种 原始类型直接存储在Java的内存栈中,数据本身的值也是存储在栈中,即当声明了一个原始类型时,就在栈中为类型本身申请了存储。

          同时,Java为每个原始类型提供了对应的封装类型,分别如下:


    原始类型封装类
    doubleDouble
    floatFloat
    byteByte
    shortShort
    intInteger
    longLong
    charCharacter
    booleanBoolean

        Java中针对原始数据类型提供了对应的封装类,因为在类中可以定义一些必要的方法,用于实现基本数据类型的数值与可打印字符串之间的转换,以及一些其他的实用程序方法;  
        另外,有些数据结构库类只能操作对象,而不支持基本数据类型的变量,包装类提供一种便利的方式,能够把基本数据类型转换成等价的对象,从而可以利用数据结构库类进行处理。   


    2.  引用类型

         引用类型和原始类型的行为完全不同,分别具有不同的语义,并且具有不同的特征和用法,它们包括:大小和速度问题,使用原始类型无须调用 new,也无须创建对象,这节省了时间和空间。另外,对象引用实例变量的缺省值为 null,而原始类型实例变量的缺省值与它们的类型有关。


       下面用一段简单的代码看看原始类型和引用类型在实际编码中的区别:

    package DataType;
    
    public class Demo1 {
    	
    	public static void main(String args[]){
    		int a = 1;  //原始类型
    		int b = 2;  //原始类型
    		Point pOne = new Point(5,5);  //引用类型
    		Point pTwo = new Point(6,6);  //引用类型
    		
    		System.out.println("Before : a =" + a);
    		System.out.println("Before : b =" + b);
    		System.out.println("Before : pOne =" + pOne.toString());
    		System.out.println("Before : pTwo =" + pTwo.toString());
    		
    		a = b;   //将b赋值给a
    		a++;     //a自增
    		pOne = pTwo;   //将pTwo 赋值给pOne
    		
    		pOne.setX(10);  //重置pOne中的值
    		pOne.setY(10);
    		System.out.println("After : a =" + a);
    		System.out.println("After : b =" + b);
    		System.out.println("After : pOne =" + pOne.toString());
    		System.out.println("After : pTwo =" + pTwo.toString());
    	}
    
    }
    

    注:省略了Point类的相关代码,其很简单,就两个int变量,和其对应的set\get方法,以及构造函数等。


    首先看看输出结果,如下:

    Before : a =1
    Before : b =2
    Before : pOne =Point [x=5, y=5]
    Before : pTwo =Point [x=6, y=6]
    After : a =3
    After : b =2
    After : pOne =Point [x=10, y=10]
    After : pTwo =Point [x=10, y=10]
    

    从结果中看出,重新赋值后,a和b的值输出结果,在意料之中;而程序中真的pOne和pTwo,仅改变了pOne的值,为什么输出结果中pTwo也改变了,并且跟pOne一致呢?


    这就是由于原始类型和引用类型的存储结构不一致导致的,其实,针对“=”本身,对这两种数据类型是没有本质区别的,都是"="左右的值等于右边的值,但不同的是,针对引用类型,赋值符“=”改变的是对象引用,而不是对象本身,也就是说当程序执行完下面这句之后,

    <strong>pOne = pTwo;</strong>
    pOne和pTwo,均指向了同一个对象,因此对pOne的任何操作,同时也会影响到pTwo。




    展开全文
  • java原始类型也就是说java的基本数据类型。 JAVA的基本数据类型有8种:byte(字节)、short(短整型)、int(整数型)、long(长整型)、float(单精度浮点数类型)、double(双精度浮点数类型)、char(字符类型)、boolean(布尔...
    java原始类型也就是说java的基本数据类型。
    

    JAVA的基本数据类型有8种:byte(字节)、short(短整型)、int(整数型)、long(长整型)、float(单精度浮点数类型)、double(双精度浮点数类型)、char(字符类型)、boolean(布尔类型)。


    1、什么是引用类型
     
        引用类型(reference type)指向一个对象,不是原始值,指向对象的变量是引用变量。
     
        在java里面除去基本数据类型的其它类型都是引用数据类型,自己定义的class类都是引用类型,可以像基本类型一样使用。

       
     示例如下:

        public class MyDate {
            private int day = 8;
            private int month = 8;
            private int year = 2008;
            private MyDate(int day, int month, int year){...}
            public void print(){...}
        }
        public class TestMyDate {
            public static void main(String args[]) {
                //这个today变量就是一个引用类型的变量
                MyDate today = new MyDate(23, 7, 2008);
            }
        }

    2、引用类型的赋值

       
     在java编程语言中,用类的一个类型声明的变量被指定为引用类型,这是因为它正在引用一个非原始类型,这对赋值具有重要的意义。如下代码:

        int x = 7;
        int y = x;
        String s = "Hello";
        String t = s;

        四个变量被创建:两个原始类型 int 和两个引用类型String。x的值是7,而这个值被复制到y;x和y是两个独立的变量且其中任何一个的进一步的变化都不对另外一个构成影响。至于变量s和t,只有一个String对象存在,它包含了文本"Hello",s和t均引用这个单一个对象。

        java中的引用类型概念

        如果将变量t重新定义为t="World";则新的对象World被创建,而t引用这个对象。      
          
         java中的引用类型概念

    3、按值传递和按引用传递的区别

        1)按值传递
       
        指的是在方法调用时,传递的参数是按值的拷贝传递。示例如下:

    1.    public class TempTest {
    2.        private void test1(int a) {
    3.            // 做点事情
    4.            a++;
    5.        }
    6.       
    7.        public static void main(String args[]) {
    8.            TempTest t = new TempTest();
    9.            int a = 3;
    10.            t.test1(a);//这里传递的参数a就是按值传递。
    11.            System.out.printIn("main方法中的a===" + a);
    12.         }
    13.     }
       
        按值传递的重要特点:传递的是值的拷贝,也就是说传递后就互不相关了。第9行的a和第2行的a是两个变量,当改变第2行的a的值,第9行a的值是不变的,所以打印结果是3。

        main  方法中的a 为 3
        test1 方法中的a 为 4
       
        我们把第9行的a称之为实参,第2行的a称之为形参;对于基本数据类型,形参数据的改变,不影响实参的数据。

        2)按引用传递

        指的是在方法调用时,传递的参数是按引用进行传递,其实传递的是引用的地址,也就是变量所对应的内存空间的地址。

        示例如下:

    1.    public class TempTest {
    2.        private void test1(A a) {
    3.            a.age = 20;
    4.            System.out.printIn("test1方法中的age="+a.age);
    5.        }
    6.        public static void main(String args[]) {
    7.            TempTest t = new TempTest();
    8.            A a = new A();
    9.            a.age = 10;
    10.           t.test1(a);// 这里传递的参数a就是按引用传递
    11.              System.out.printIn("main方法中的age="+a.age);
    12.         }
    13.     }
    14.     classA {
    15.         public int age = 0;
    16.     }  

        运行结果如下:test1方法中的age = 20  main方法中的age = 20

        按引用传递的重要特点:

        传递的是值的引用,也就是说传递前和传递后都指向同一个引用(也就是同一个内存空间)。

        要想正确理解按引用传递的过程,就必须学会理解内存分配的过程,内存分配示意图可以辅助我们去理解这个过程。

        用上面的例子来进行分析:
      
        (1)、运行开始,运行第8行,创建了一个A的实例,内存分配示意图如下:

          main方法中的a 
       
          java中的引用类型概念

        (2)、运行第9行,修改了A实例里面的age的值,内存分配示意图如下:   
       
          main方法中的a  
         

           java中的引用类型概念
     
        (3)、运行第10行,是把main方法中的变量a所引用的内存空间地址,按引用传递给test1方法中的a变量。请注意:这两个a变量是完全不同的,不要被名称相同所蒙蔽,但它们指向了同一个A实例。内存分配示意图如下:

        java中的引用类型概念

        (4)、运行第3行,为test1方法中的变量a指向A实例的age进行赋值,完成后形成新的内存示意图如下:

         java中的引用类型概念
         此时A实例的age值的变化是由test1方法引起的。
       
        (5)、运行第4行,根据此时的内存示意图,输出test1方法中的age=20
        
        (6)、运行第11行,根据此时的内存示意图,输出main方法中的age=20

        3)对上述例子的改变

        理解了上面的例子,可能有人会问,那么能不能让按照引用传递的值,相互不影响呢?就是test1方法里面的修改不影响到main方法里面的呢?

        方法是在test1方法里面新new一个实例就可以了。改变成下面的例子,其中第3行为新加的:

    1.    public class TempTest {
    2.        private void test1(A a) {
    3.            a = new A();// 新加的一行
    4.            a.age = 20;
    5.            System.out.printIn("test1方法中的age="+a.age);
    6.        }
    7.        public static void main(String args[]) {
    8.            TempTest t = new TempTest();
    9.            A a = new A();
    10.            a.age = 10;
    11.           t.test1(a);// 这里传递的参数a就是按引用传递
    12.              System.out.printIn("main方法中的age="+a.age);
    13.         }
    14.     }
    15.     classA {
    16.         public int age = 0;
    17.     }  

        运行结果为:test1方法中的age=20  main方法中的age=10

        实现了按引用传递的值传递前与传递后互不影响,还是使用内存示意图来理解一下:

        (1)、运行开始,运行第9行,创建了一个A实例,内存分配示意图如下:

        java中的引用类型概念
       
        (2)、运行第10行,是修改A实例里面的age的值,运行后内存分配示意图如下:

        java中的引用类型概念
       
        (3)、运行第11行,是把mian方法中的变量a所引用的内存地址,按引用传递给test1方法中的a变量。请注意:这两个a变量是完全不同的,不要被名称相同所蒙蔽。

        java中的引用类型概念

         (4)、运行第3行,为test1方法中的变量a重新生成了新的A实例,完成后形成的新的内存示意图如下:

        java中的引用类型概念

         (5)、运行第4行,为test1方法中的变量a指向的新的A实例的age进行赋值,完成后形成新的内存示意图如下:

        java中的引用类型概念

        注意:这个时候test1方法中的变量a的age被改变,而main方法中的a变量是没有改变的。

         (6)、运行第5行,根据此时的内存示意图,输出test1方法中的age=20

         (7)、运行第12行,根据此时的内存示意图,输出main方法中的age=10

        说明:

        (1)、“在Java里面参数传递都是按值传递”这句话的意思是:按值传递是传递的值的拷贝,按引用传递其实传递的是引用的地址值,所以统称按值传递。

        (2)、在Java里面只有基本类型和按照下面这种定义方式的String是按值传递,其它的都是按引用传递。就是直接使用双引号定义的字符串方式:String str = "Java快车";

    展开全文
  • 第一章 原始类型和引用类型引言:javascript存在两种类型,原始类型和引用类型原始类型保存为简单数据值。引用类型则保存为对象,其本质是指向内存位置的引用。 其他编程语言用栈储存原始类型,用堆储存引用类型。...

    第一章 原始类型和引用类型

    引言:javascript存在两种类型,原始类型和引用类型。原始类型保存为简单数据值引用类型则保存为对象,其本质是指向内存位置的引用

        其他编程语言用栈储存原始类型,用堆储存引用类型。javascript完全不同:它使用一个变量对象追踪变量的生存期。原始值被直接保存在变量对象内,而引用值作为一个指针保存在变量对象内,该指针指向实际对象在内存中的存储位置。

    1.1原始类型(共5种)

    boolean      布尔

    number       数字,值为任何整型或浮点数

    string           字符串

    null               空类型,该原始类型仅有一个值:null;

    undefined    未定义,该原始类型仅有一个值:undefined;

    所有原始类型的值都有字面形式。字面形式是不被保存在变量中的值,如姓名或者价格。

    eg  var name="Nicholas";

           var count=25;

    (1)原始类型的变量直接保存在原始值,当你将原始值赋给另一个变量时,该值将被复制到变量中。

    例子:                                                                 运行结果:

                    

    本例中,color2 保存了"red"值,虽然color1和color2具有同样的值,但是二者毫无关联,之后再改变color1的值也不会影响color2.因为每个含有原始值的变量使用自己的存储空间,一个变量的改变不会影响到其它变量。存在两个不同的存储地址。

    1.2 鉴别原始类型

    (1)使用typeof操作符

    值得注意的:console.log(typeof null);         //"object"

    所以判断一个值是否为空类型的最佳方法是直接和null比较。用三等号操作符

    console.log(undefined==null);   //true

    console.log(undefined===null);   //false

    因为双等号在比较时,会将变量进行强制转换。

    (2)原始方法

    虽然字符串、数字、布尔是原始类型,但是他们也拥有方法。特别是字符串有很多方法。

    比如 toLowerCase()  charAt()   subString()   toString(16) {将数字转换为16进制数}

    1.3 引用类型

    对象是引用类型的实例。

    对象是属性的无序列表。属性包含键(始终是字符串)和值。如果一个属性的值是函数,它就被称为方法。

    (除了函数可以运行外,一个包含数组的属性和一个包含函数的属性没什么区别i)

    1.3.1 创建对象

    (1)使用new操作符和构造函数。

    var object=new Object();

    引用类型不在变量中直接保存对象。所以上例中的object变量实际上并不包含对象的实例,而是指向内存中实际对象所在位置的指针。

    举例: var object1=new Object();

               var object2=object1;

    这两个变量都指向第一行杯创建的那个对象实例。


    1.3.2 对象引用解除

    最佳手段是将对象变量置为null.

       var object1=new Object();

       object1=null;  //dereference

    1.3.3 添加删除属性

       举例:    

    var object1=new Object();
    
                          var object2=object1;
    
                          object1.myproperty="awesom"
    
                          console.log(object2.myproperty);     // "awesom"

         object1 上增加了myproperty属性,该属性也可以被object2访问,因为object1和object2指向同一个对象。

    1.4 内建类型实例化

    内建类型有:Array    数组类型

                        Date     日期和时间类型

                        Error     运行期错误类型

                        Function    函数类型

                        Object      通用对象类型

                       RegExp     正则表达式类型

       可以用new来实例化每一个内建引用类型。

    1.4.1 字面形式

      内建类型有字面形式。字面形式允许你在不需要使用new操作符和构造函数显式创建对象的情况下生成引用值。

    1.4.2 对象和数组字面形式

    (1)对象字面形式

    var book={
    
    name:"hui"
    
    year:2018
    
    };

    属性名字也可以用字符串表示,特别是希望名字中包含空格和其他特殊字符时。

    等价写法:

    var book=new Object();

    book.name="name";

    book.year=2018;

    (2)数组字面形式

    var colors=["red","blue","green"];

    等价写法:var colors=new Array("red" ,"blue","green");

    1.4.3 函数字面形式

    基本上函数都要用字面形式来定义。

    function reflect(value){

    return value;

    }

    1.4.4 正则表达式字面形式

     var numbers=/\d+/g;

    等价形式:var numbers=new RegExp("\\d+","g");

    1.5 访问属性

    用 . 和 [] 访问

    [] 允许在属性名使用特殊符号,也允许你用变量而不是字符串字面形式来指定访问的属性。

    var array =[];

    var method ="push";

    array[method](12345);

    1.6 鉴别引用类型

    函数最容易鉴别,用typeof操作符。对其他引用类型使用typeof,返回"object"

    所以鉴别引用类型用instanceof操作符。instanceof操作符以一个对象和一个构造函数为参数。


    1.7 鉴别数组

    鉴别数组可以用instanceof操作符。但是有一个例外会影响网页开发:javascript的值可以在同一个网页的不同框架之间传输。

    ECMAscript引入了Array.isArray().

    1.8 原始封装类型

    原始封装类型一共有三种 String  Number Boolean

    当读取字符串、数字或布尔值时,原始封装类型将自动被创建,但这些临时对象在使用它们的语句结束时就立刻被销毁.

    var name="hui";
    hui.last="wang";
    console.log(name.last);      //undefined
    

    另外,虽然原始封装类型会被自动创建,但是在这些值上进行instanceof操作,对应类型的返回值都是false。

    这是因为临时对象仅在值读取时被创建,instanceof操作符并没有读到任何东西,也没有临时对象的创建,于是他说这些值并不属于原始封装类型。


    展开全文
  • 原始类型 原始类型共有以下五种 boolean //布尔,值为 true 或 false number //数字,值为任何整型或浮点型数值 string //字符串,值为由单引号或双引号包围的单个字符或连续字符(JavaScript 不区分字符类型) ...
  • 【08】原始类型和引用类型区别01,原始值是不可更改的:任何方法都无法更改(或“突变”)一个原始值。引用值是可变的。02,原始值的比较是值的比较:只有在它们的值相等时它们才相等。对象的比较并非值的比较:...
  • java原始类型和引用类型 几年前,当我开始编辑Java Basics系列时,我认为将一些非常详细的信息拉到自己的帖子中是很有意义的。 这样,初学者的内容就更容易消化了。 首先,我将介绍有关Java的8种原始类型的所有信息...
  • 使用原始类型无须调用new,也...原始类型,引用类型是对象  原始类型大小比较用"==",引用类型大小比较用"equals" 原始类型 封装 ================= boolean Boolean char Character byte Byte short Sh
  • Java为我们提供了两种不同 的类型:原始类型和引用类型
  • JavaScript原始类型和引用类型

    千次阅读 2015-10-23 09:43:58
    引子理解使用对象是理解整个 JavaScript 的关键JavaScript 把对象作为语言的中心,几乎所有的 JavaScript 的...JavaScript 中的数据分为两种类型:原始类型和引用类型,两者都通过对象进行访问。原始类型保存为简单
  • 引用类型和原始类型区别

    千次阅读 2016-03-25 19:49:37
    Java 提供两种不同的类型:引用类型和原始类型(或内置类型)。另外,Java 还为每个原始类型提供了封装(Wrapper)。如果需要一个整型变量,是使用基本的 int 型呢,还是使用 Integer 的一个对象呢?如果需要...
  • 一共有5 种原始类型(primitive type),即 Undefined、Null、Boolean、Number String 引用类型 引用类型通常叫做(class),也就是说,遇到引用值,所处理的就是对象。 尽管ECMAScript从技术上说是一门...
  • JavaScript数据类型,包括原始类型和引用类型有哪些? 原始类型有五个 Number类型 专门保存数字的类型,可用于进行数学计算等的数值 String类型 专门用来保存字符串的类型;” “,用来存储字符串类型的文本. ...
  • 泛型 将类型参数化的、方法、接口。 类型作为实参。 语法 class GeneralType </Type/>{ Type object; public GeneralType(Type object){ this.object = object ...原始类型 封装 boolean Boolean char
  • Java 提供两种不同的类型:引用类型和原始类型(或内置类型)。Int是java的原始数据类型,Integer是java为int提供的封装。Java为每个原始类型提供了封装原始类型 封装 boolean –> Boolean byte –> ...
  • 陈国佳总结《2018年4月23日》【连续194天】 标题:Jvm原始类型和引用类型; 内容: 1.看了JVm规范8版到2.5; 2.原始类型包括数值类型,boolean类型returnAddress类型: 2.jvm引用类型
  • 目录赋值原始类型赋值引用类型赋值比较原始类型的比较引用类型的比较函数传参原始类型传参引用类型传参原始类型引用类型三种情况下的对比: 赋值 原始类型赋值 //原始类型赋值 let str1 = "小hu";//给str1 赋值一...
  • 我们先前学过的数据类型可以划分成两原始类型和引用类型原始类型的数据都是一些比较简单数据,比如字符串,数字等。引用类型的数据稍微复杂一点,比如对象。 原始类型的数据直接存储在变量的内存空间中,而...
  • Java 提供两种不同的类型:引用类型和原始类型(或内置类型)。另外,Java 还为每个原始类型提供了封装(Wrapper)。 如果需要一个整型变量,是使用基本的 int 型呢,还是使用 Integer 的一个对象呢?如果需要声明...
  • 原始类型 原始类型变量直接包含着值 The Java programming language is a statically typed language, which means that every variable and every expression has a type that is known at compile time. 通俗...
  • Java原始类型引用类型

    2020-03-10 21:06:06
    文章目录Java原始类型引用类型原始类型引用类型原始类型引用类型Java泛型编程Java泛型编程 原始类型 Java原始类型有8中、分别是:bool byte char short int long float double 原始类型的函数参数传值方式是按值传递...
  •  Java 提供两种不同的类型:引用类型和原始类型(或内置类型)。另外,Java 还为每个原始类型提供了封装(Wrapper)。如果需要一个整型变量,是使用基本的 int 型呢,还是使用 Integer 的一个对象呢?如果需要声明一...
  • 二 比较的区别三 传参的区别原始类型和引用类型的类型检测1 原始类型检测:typeof(值)2 引用类型检测: 值 instanceof 类型练习(数组存储学生列表)第一次代码结果不符合代码结果(最后一次的覆盖前几次的输入结果)...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 254,427
精华内容 101,770
关键字:

原始类型和引用类型的区别