精华内容
下载资源
问答
  • java 基本类型

    千次阅读 2009-02-24 10:25:00
    Java基本类型有8种:字符型:char 布尔型:boolean 整型:int ,short , long 浮点型:float,double,bytepublic class PrimitiveTypeTest { public static void main(String[] args) { // byte System.out....

    Java基本类型有8种:
    字符型:char
    布尔型:boolean
    整型:int ,short , long
    浮点型:float,double,byte

     

    运行结果:

    1、基本类型:byte 二进制位数:8
    2、包装类:java.lang.Byte
    3、最小值:Byte.MIN_VALUE=-128
    4、最大值:Byte.MAX_VALUE=127
    5、
    6、基本类型:short 二进制位数:16
    7、包装类:java.lang.Short
    8、最小值:Short.MIN_VALUE=-32768
    9、最大值:Short.MAX_VALUE=32767
    10、
    11、基本类型:int 二进制位数:32
    12、包装类:java.lang.Integer
    13、最小值:Integer.MIN_VALUE=-2147483648
    14、最大值:Integer.MAX_VALUE=2147483647
    15、
    16、基本类型:long 二进制位数:64
    17、包装类:java.lang.Long
    18、最小值:Long.MIN_VALUE=-9223372036854775808
    19、最大值:Long.MAX_VALUE=9223372036854775807
    20、
    21、基本类型:float 二进制位数:32
    22、包装类:java.lang.Float
    23、最小值:Float.MIN_VALUE=1.4E-45
    24、最大值:Float.MAX_VALUE=3.4028235E38
    25、
    26、基本类型:double 二进制位数:64
    27、包装类:java.lang.Double
    28、最小值:Double.MIN_VALUE=4.9E-324
    29、最大值:Double.MAX_VALUE=1.7976931348623157E308
    30、
    31、基本类型:char 二进制位数:16
    32、包装类:java.lang.Character
    33、最小值:Character.MIN_VALUE=0
    34、最大值:Character.MAX_VALUE=65535

    展开全文
  • java基本类型

    千次阅读 2014-03-21 11:48:13
    java中,有八种基本类型,本文对这些类型做个介绍。 1、布尔型 boolean 2、字符型 char 占2个字节 3、整型 byte 占1个字节 short 占2个字节 int 占4个字节 long 占8个字节 4、小数型 float 占4个字节 ...

    在java中,有八种基本类型,本文对这些类型做个介绍。

    1、布尔型

    boolean

    2、字符型

    char 占2个字节

    3、整型

    byte 占1个字节

    short 占2个字节

    int 占4个字节

    long 占8个字节

    4、小数型

    float 占4个字节

    double 占8个字节


    注意:

    1、因为java的平台无关性,所以这里能够明确指出每个类型占用字节数;

    2、java中没有无符号数的概念,都是有符号数。在位操作时,有个无符号右移>>>;

    3、对于整型,默认的数值类型为int;对于小数型,默认的数值类型为double;当然在赋值时,可以通过后缀来制定类型,如:1L表示long型;

    4、默认会向上转型。在做强制转换时,注意强制转换的作用范围,如:(short)1/2d和(short)(1/2d)是不一样的。

    展开全文
  • Java基本类型

    千次阅读 2010-05-06 20:17:00
    from http://hi.baidu.com/18276393/blog/item/f6efc9d77ee7bc2806088b61.html原文基本类型,或者叫做内置类型,是JAVA中不同于类的特殊类型。它们是我们编程中使用最频繁的类型,因此面试题中也总少不了它们的身影...
    
    

    原文
    基本类型,或者叫做内置类型,是JAVA 中 不同于类的特殊类型。它们是我们编程中使用最频繁的类型,因此面试 题中也总少不了它 们的身影,在这篇文章中我们将从面试中常考的几个方面来回顾一下与基本类型相关的知识。

    基本类型共有八种,它们分别都有相对应的包装类。
    基本类型可以分为三类,字符类型char,布尔类型boolean以及数值类型byte、short、int、long、float、double。数值 类型又可以分为整数类型byte、short、int、long和浮点数类型float、double。JAVA中的数值类型不存在无符号的,它们的取值 范围是固定的,不会随着机器硬件环境或者操作系统的改变而改变。实际上,JAVA中还存在另外一种基本类型void,它也有对应的包装类 java.lang.Void,不过我们无法直接对它们进行操作。对于数值类型的基本类型的取值范围,我们无需强制去记忆,因为它们的值都已经以常量的形 式定义在对应的包装类中了。请看下面的例子:
    复制内容到剪贴板
    代码:
    public class PrimitiveTypeTest {
    public static void main(String[] args) {
    // byte
    System.out.println("基本类型:byte 二进制位数:" + Byte.SIZE);
    System.out.println("包装类:java.lang.Byte");
    System.out.println("最小值:Byte.MIN_VALUE=" + Byte.MIN_VALUE);
    System.out.println("最大值:Byte.MAX_VALUE=" + Byte.MAX_VALUE);
    System.out.println();

    // short
    System.out.println("基本类型:short 二进制位数:" + Short.SIZE);
    System.out.println("包装类:java.lang.Short");
    System.out.println("最小值:Short.MIN_VALUE=" + Short.MIN_VALUE);
    System.out.println("最大值:Short.MAX_VALUE=" + Short.MAX_VALUE);
    System.out.println();

    // int
    System.out.println("基本类型:int 二进制位数:" + Integer.SIZE);
    System.out.println("包装类:java.lang.Integer");
    System.out.println("最小值:Integer.MIN_VALUE=" + Integer.MIN_VALUE);
    System.out.println("最大值:Integer.MAX_VALUE=" + Integer.MAX_VALUE);
    System.out.println();

    // long
    System.out.println("基本类型:long 二进制位数:" + Long.SIZE);
    System.out.println("包装类:java.lang.Long");
    System.out.println("最小值:Long.MIN_VALUE=" + Long.MIN_VALUE);
    System.out.println("最大值:Long.MAX_VALUE=" + Long.MAX_VALUE);
    System.out.println();

    // float
    System.out.println("基本类型:float 二进制位数:" + Float.SIZE);
    System.out.println("包装类:java.lang.Float");
    System.out.println("最小值:Float.MIN_VALUE=" + Float.MIN_VALUE);
    System.out.println("最大值:Float.MAX_VALUE=" + Float.MAX_VALUE);
    System.out.println();

    // double
    System.out.println("基本类型:double 二进制位数:" + Double.SIZE);
    System.out.println("包装类:java.lang.Double");
    System.out.println("最小值:Double.MIN_VALUE=" + Double.MIN_VALUE);
    System.out.println("最大值:Double.MAX_VALUE=" + Double.MAX_VALUE);
    System.out.println();

    // char
    System.out.println("基本类型:char 二进制位数:" + Character.SIZE);
    System.out.println("包装类:java.lang.Character");
    // 以数值形式而不是字符形式将Character.MIN_VALUE输出到控制台
    System.out.println("最小值:Character.MIN_VALUE="
    + (int) Character.MIN_VALUE);
    // 以数值形式而不是字符形式将Character.MAX_VALUE输出到控制台
    System.out.println("最大值:Character.MAX_VALUE="
    + (int) Character.MAX_VALUE);
    }
    }
    运行结果:

    1、基本类型:byte 二进制位数:8
    2、包装类:java.lang.Byte
    3、最小值:Byte.MIN_VALUE=-128
    4、最大值:Byte.MAX_VALUE=127
    5、
    6、基本类型:short 二进制位数:16
    7、包装类:java.lang.Short
    8、最小值:Short.MIN_VALUE=-32768
    9、最大值:Short.MAX_VALUE=32767
    10、
    11、基本类型:int 二进制位数:32
    12、包装类:java.lang.Integer
    13、最小值:Integer.MIN_VALUE=-2147483648
    14、最大值:Integer.MAX_VALUE=2147483647
    15、
    16、基本类型:long 二进制位数:64
    17、包装类:java.lang.Long
    18、最小值:Long.MIN_VALUE=-9223372036854775808
    19、最大值:Long.MAX_VALUE=9223372036854775807
    20、
    21、基本类型:float 二进制位数:32
    22、包装类:java.lang.Float
    23、最小值:Float.MIN_VALUE=1.4E-45
    24、最大值:Float.MAX_VALUE=3.4028235E38
    25、
    26、基本类型:double 二进制位数:64
    27、包装类:java.lang.Double
    28、最小值:Double.MIN_VALUE=4.9E-324
    29、最大值:Double.MAX_VALUE=1.7976931348623157E308
    30、
    31、基本类型:char 二进制位数:16
    32、包装类:java.lang.Character
    33、最小值:Character.MIN_VALUE=0
    34、最大值:Character.MAX_VALUE=65535

    Float和Double的最小值和最大值都是以科学记数法的形式输出的,结尾的“E+数字”表示E之前的数字要乘以10的多少倍。比如3.14E3就是 3.14×1000=3140,3.14E-3就是3.14/1000=0.00314。

    大家将运行结果与上表信息仔细比较就会发现float、double两种类型的最小值与Float.MIN_VALUE、 Double.MIN_VALUE的值并不相同,这是为什么呢?实际上Float.MIN_VALUE和Double.MIN_VALUE分别指的是 float和double类型所能表示的最小正数。也就是说存在这样一种情况,0到±Float.MIN_VALUE之间的值float类型无法表示,0 到±Double.MIN_VALUE之间的值double类型无法表示。这并没有什么好奇怪的,因为这些范围内的数值超出了它们的精度范围。

    基本类型存储在栈中,因此它们的存取速度要快于存储在堆中的对应包装类的实例对象。从Java5.0(1.5)开始,JAVA虚拟机(Java Virtual Machine)可以完成基本类型和它们对应包装类之间的自动转换。因此我们在赋值、参数传递以及数学运算的时候像使用基本类型一样使用它们的包装类,但 这并不意味着你可以通过基本类型调用它们的包装类才具有的方法。另外,所有基本类型(包括void)的包装类都使用了final修饰,因此我们无法继承它 们扩展新的类,也无法重写它们的任何方法。

    各种数值类型之间的赋值与转换遵循什么规律呢?我们来看下面这个例子:
    复制内容到剪贴板
    代码:
    public class PrimitiveTypeTest {
    public static void main(String[] args) {
    // 给byte类型变量赋值时,数字后无需后缀标识
    byte byte_a = 1;
    // 编译器会做范围检查,如果赋予的值超出了范围就会报错
    // byte byte_b = 1000;
    // 把一个long型值赋值给byte型变量,编译时会报错,即使这个值没有超出byte类型的取值范围
    // byte byte_c = 1L;

    // 给short类型变量赋值时,数字后无需后缀标识
    short short_a = 1;
    // 编译器会做范围检查,如果赋予的值超出了范围就会报错
    // short short_b = 70000;
    // 把一个long型值赋值给short型变量,编译时会报错,即使这个值没有超出short类型的取值范围
    // byte short_c = 1L;

    // 给short类型变量赋值时,数字后无需后缀标识
    int int_a = 1;
    // 编译器会做范围检查,如果赋予的值超出了范围就会报错
    // int int_b = 2200000000;
    // 把一个long型值赋值给int型变量,编译时会报错,即使这个值没有超出int类型的取值范围
    // int int_c = 1L;

    // 可以把一个int型值直接赋值给long型变量,数字后无需后缀标识
    long long_a = 1;
    // 如果给long型变量赋予的值超出了int型值的范围,数字后必须加L(不区分大小写)标识
    long long_b = 2200000000;
    // 编译器会做范围检查,如果赋予的值超出了范围就会报错
    // long long_c = 9300000000000000000L;

    // 可以把一个int型值直接赋值给float型变量
    float float_a = 1;
    // 可以把一个long型值直接赋值给float型变量
    float float_b = 1;
    // 没有F(不区分大小写)后缀标识的浮点数默认为double型的,不能将它直接赋值给float型变量
    // float float_c = 1.0;
    // float型数值需要有一个F(不区分大小写)后缀标识
    float float_d = 1.0F;
    // 把一个double型值赋值给float型变量,编译时会报错,即使这个值没有超出float类型的取值范围
    // float float_e = 1.0D;
    // 编译器会做范围检查,如果赋予的值超出了范围就会报错
    // float float_f = 3.5000000E38F;

    // 可以把一个int型值直接赋值给double型变量
    double double_a = 1;
    // 可以把一个long型值直接赋值给double型变量
    double double_b = 1;
    // 可以把一个float型值直接赋值给double型变量
    double double_c = 1F;
    // 不带后缀标识的浮点数默认为double类型的,可以直接赋值
    double double_d = 1.0;
    // 也可以给数字增加一个D(不区分大小写)后缀标识,明确标出它是double类型的
    double double_e = 1.0D;
    // 编译器会做范围检查,如果赋予的值超出了范围就会报错
    // double double_f = 1.8000000000000000E308D;

    // 把一个double型值赋值给一个byte类型变量,编译时会报错,即使这个值没有超出byte类型的取值范围
    // byte byte_d = 1.0D;
    // 把一个double型值赋值给一个short类型变量,编译时会报错,即使这个值没有超出short类型的取值范围
    // short short_d = 1.0D;
    // 把一个double型值赋值给一个int类型变量,编译时会报错,即使这个值没有超出int类型的取值范围
    // int int_d = 1.0D;
    // 把一个double型值赋值给一个long类型变量,编译时会报错,即使这个值没有超出long类型的取值范围
    // long long_d = 1.0D;

    // 可以用字符初始化一个char型变量
    char char_a = 'a';
    // 也可以用一个int型数值初始化char型变量
    char char_b = 1;
    // 把一个long型值赋值给一个char类型变量,编译时会报错,即使这个值没有超出char类型的取值范围
    // char char_c = 1L;
    // 把一个float型值赋值给一个char类型变量,编译时会报错,即使这个值没有超出char类型的取值范围
    // char char_d = 1.0F;
    // 把一个double型值赋值给一个char类型变量,编译时会报错,即使这个值没有超出char类型的取值范围
    // char char_e = 1.0D;
    // 编译器会做范围检查,如果赋予的值超出了范围就会报错
    // char char_f = 70000;
    }
    }
    从上面的例子中我们可以得出如下几条结论:

    1、未带有字符后缀标识的整数默认为int类型;未带有字符后缀标识的浮点数默认为double类型。
    2、如果一个整数的值超出了int类型能够表示的范围,则必须增加后缀“L”(不区分大小写,建议用大写,因为小写的L与阿拉伯数字1很容易混淆),表示 为long型。
    3、带有“F”(不区分大小写)后缀的整数和浮点数都是float类型的;带有“D”(不区分大小写)后缀的整数和浮点数都是double类型的。
    4、编译器会在编译期对byte、short、int、long、float、double、char型变量的值进行检查,如果超出了它们的取值范围就会 报错。
    5、int型值可以赋给所有数值类型的变量;long型值可以赋给long、float、double类型的变量;float型值可以赋给float、 double类型的变量;double型值只能赋给double类型变量。

     


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

    千次阅读 2017-06-01 15:48:09
    Java基本类型共有八种,基本类型可以分为三类,字符类型char,布尔类型boolean以及数值类型byte、short、int、long、float、double。数值类型又可以分为整数类型byte、short、int、long和浮点数类型float、double。...
  • Java基本数据类型转换与java基本类型转换优先级转换类型1. 自动类型转换: 编译器自动完成类型转换,不需要再程序中编写代码转换规则: 从存储范围小的类型到存储范围大的类型具体规则 : byteàcharàshortàintàlong...
  • java基本类型与包装类型

    千次阅读 2016-05-25 11:11:17
    java基本类型与包装类型 基本数据类型:byte,int, short, long, boolean,char, float,double等 包装类型 : Byte,Integer,Short,Long,Boolean,Character,Float,Double等 基本类型(primitive type)...
  • java基本类型与包装类型区别

    千次阅读 2017-05-30 17:31:01
    Java基本类型与包装类型区别 Java中基本类型都有固定的存储空间,不像其他大多数语言那样随机器硬件架构的变化而变化,这种占存储空间大小的不变性是java程序比其他大多数语言编写的程序更具可移植性的原因之一...
  • Java 基本类型默认值问题

    千次阅读 2018-07-27 11:17:48
    Java 基本类型默认值问题 最近正在以 Java编程思想(第四版)为主要参考书籍学习Java基础部分的内容,记录下一些个人认为值得一记的知识点,以供巩固复习,如有理解错误的地方,欢迎大家指正。 与C++不同...
  • Java基本类型,字面值前后缀,类型转换
  • Java 基本类型和对象类型的区别  基本类型: int long byte float double char boolean short  对象类型: Integer Long Byte Float Double Character Boolean Short  包装类:  java中有时候运算时两个对象...
  • Java基本类型变量与引用类型变量

    千次阅读 2015-04-22 17:13:59
    Java基本类型变量与引用类型变量  (2013-04-08 20:47:54) 转载▼ 标签:  java   设计模式   java设计模式   语句   it 分类: Java Java基本类型变量...
  • Java基本类型和常量讲解

    千次阅读 2017-01-15 17:24:39
    基本类型或者叫做内置类型,是JAVA中不同于类的特殊类型。...Java基本类型共有八种,基本类型可以分为三类,字符类型char,布尔类型boolean以及数值类型byte、short、int、long、float、double。数值类
  • Java基本类型和取值范围

    千次阅读 2018-08-14 21:36:34
    Java基本类型和取值范围 类型 字节数 范围 byte 1 -128~127 (-2的7次方到2的7次方-1) short 2 -32768~32767(-2的15次方到2的15次方-1)  int 4 -...
  • java 基本类型和常量讲解

    千次阅读 2015-07-10 15:21:37
    基本类型或者叫做内置类型,是JAVA...1. Java的基本类型Java基本类型共有八种,基本类型可以分为三类,字符类型char,布尔类型boolean以及数值类型byte、short、int、long、float、double。数值类型又可以分为整数类型b
  • java基本类型和包装类型

    千次阅读 2018-10-08 11:20:21
    java是面向对象的语言为什么还要有基本类型,只有包装类型完全面向对象不行吗? java语言可以只有基本类型吗,为什么还有要包装类型? java中的基本类型和包装类型:  基本类型  包装器类型 boolean ...
  • JAVA基本类型的拆箱和装箱

    千次阅读 2019-03-01 23:12:44
    一个基础知识小回顾,码太多,基础的东西也要总结,最近推荐一本好书《java的编程逻辑》。... java基本类型有8种: 整数:byte(1字节)、short(2字节)、int(4字节)、long(8字节) 浮点数:float、d...
  • Java基本类型和不可变类

    千次阅读 2018-10-09 18:53:00
    Java基本类型共有八种,基本类型可以分为三类: 字符类型char 布尔类型boolean 数值类型byte、short、int、long、float、double 数值类型又可以分为整数类型byte、short、int、long和浮点数类型float、double ...
  • java基本类型的长度

    千次阅读 2013-03-11 11:40:17
    java基本类型的长度 基本类型:byte 二进制位数:8 包装类:java.lang.Byte 最小值:Byte.MIN_VALUE=-128 最大值:Byte.MAX_VALUE=127 基本类型:short 二进制位数:16 包装类:java.lang.Short ...
  • Java基本类型所占字节和范围

    千次阅读 2019-06-07 14:01:15
    Java基本类型哪些,所占字节和范围 Kb=1024b 1B(Byte)=8 Bit(比特) 一个字节的字长是8位 一个字符的字长是16位 Byte 一个字节 8位 -127-127 Short 一个字符 二个字节 16位 Char 一个字符 二个字节 16位...
  • Java基本类型和包装类型总结

    万次阅读 多人点赞 2017-07-19 12:36:40
    1.Java基本类型及其对应的包装器类Java有8种基本类型:大致分为3类:字符,布尔,数值类型(在java中数值是不存在无符号的,这一点不像C/C++,他们的取值范围是固定的,不会随着机器硬件的环境或者操作系统的改变...
  • java基本类型和包装类型的区别

    千次阅读 2019-02-24 14:01:29
    1、为什么存在基本类型: 在Java中正常应该设置对象,然后通过new一个对象存储在堆中,再通过栈的引用来使用对象,但对于简单的小的变量,用new 显的繁琐麻烦,所以产生了基本类型 2、有了基本类型,为什么还会产生...
  • Java基本类型变量

    千次阅读 2013-01-26 09:52:22
    Java的8中基本类型的变量称为基本类型变量,而类、接口和数组变量时引用类型变量。这两种类型变量的结构和含义不同,系统对他们的处理也不相同。 1.基本类型与引用类型变量  *基本类型(primitive type)  基本...
  • java基本类型和包装器类【转】

    千次阅读 2015-09-29 18:10:25
    简要讲述java基本类型和包装类型,为装箱和拆箱的学习做准备

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 99,884
精华内容 39,953
关键字:

java基本类型

java 订阅