精华内容
下载资源
问答
  • 文章目录第1关:基本数据类型和包装类之间的转换编程要求第2关:包装类转换成其他数据类型编程要求测试说明第3关:包装类与字符串之间的转换编程要求测试说明: 第1关:基本数据类型和包装类之间的转换 编程要求 ...

    第1关:基本数据类型和包装类之间的转换

    编程要求

    补充完代码后,点击测评,平台会对你编写的代码进行测试,当你的结果与预期输出一致时,即为通过。

    预期输出:

    装箱后的结果为:66.6和66.6
    拆箱结果为:88.88和88.88

    package step1;
    
    public class Task {
    	public static void main(String[] args) {
    		
    		//请在此添加实现代码
    		/********** Begin **********/
    		//定义float对象
    		float f = 66.6f;
    		
    		//手动装箱
    		Float f1 = new Float(f);
    		
    		//自动装箱 
    		Float f2 =f;
    		
    		System.out.println("装箱后的结果为:" + f1 + "和" + f2);
    		
    		//定义一个Double包装类值为88.88
    		Double d = new Double(88.88);
    		
    		//手动拆箱
    		double d1 = d.doubleValue();
    		
    		//自动拆箱
    		double d2 = d;
    		
    		System.out.println("拆箱结果为:" + d1 + "和" + d2);
    		
    		/********** End **********/
    	}
    }
    

    第2关:包装类转换成其他数据类型

    编程要求

    请仔细阅读右侧代码,根据方法内的提示,在Begin - End区域内进行代码补充,具体任务如下:

    将int类型数据转换成其他数据类型。
    

    测试说明

    补充完代码后,点击测评,平台会对你编写的代码进行测试,当你的结果与预期输出一致时,即为通过。
    预期输出:
    Integer包装类:67
    double类型:67.0
    float类型:67.0
    int类型:67

    package step2;
    
    public class Task {
    	public static void main(String[] args) {
    
    		//请在此添加实现代码
    		/********** Begin **********/
    		// 定义int类型变量,值为67
    		int score = 67;
    
    		// 创建Integer包装类对象,表示变量score的值
    		Integer score1 = new Integer(score);
    
    		// 将Integer包装类转换为double类型
    		double score2 = score1.doubleValue(); 
    
    		// 将Integer包装类转换为float类型
    		float score3 = score1.floatValue();
    
    		// 将Integer包装类转换为int类型
    		int score4 = score1.intValue();
    
    		System.out.println("Integer包装类:" + score1);
    		System.out.println("double类型:" + score2);
    		System.out.println("float类型:" + score3);
    		System.out.println("int类型:" + score4);
    
    		/********** End **********/
    	}
    }
    

    第3关:包装类与字符串之间的转换

    编程要求

    请仔细阅读右侧代码,根据方法内的提示,在Begin - End区域内进行代码补充,具体任务如下:

    完成基本数据类型与字符串之间的相互转换。
    

    测试说明:

    补充完代码后,点击测评,平台会对你编写的代码进行测试,当你的结果与预期输出一致时,即为通过。
    预期输出:
    str + 12 的结果为: 78.512
    d + 100 的结果为: 280.2

    package step3;
    
    public class Task {
    	public static void main(String[] args) {
    		double a = 78.5;
            
    		//请在此添加实现代码
    		/********** Begin **********/
    		//将基本类型a转换为字符串
    		String str = String.valueOf(a);
            
    		System.out.println("str + 12  的结果为: "+(str + 12));
    		
    		String str1 = "180.20";
    	    // 将字符串str1转换为基本类型
    		Double d = Double.parseDouble(str1);
    	
    		System.out.println("d + 100 的结果为: "+ (d + 100));
    
    		/********** End **********/
    	} 
    }
    
    展开全文
  • 基本数据类型和包装类进行比较

    千次阅读 2018-08-16 09:46:46
    1、基本和基本型封装型进行“==”运算符的比较,基本型封装型将会自动拆箱变为基本型后再进行比较,因此Integer(0)会自动拆箱为int类型再进行比较,显然返回true;  int a = 220;  Integer b = 220;  System...

    1、基本型和基本型封装型进行“==”运算符的比较,基本型封装型将会自动拆箱变为基本型后再进行比较,因此Integer(0)会自动拆箱为int类型再进行比较,显然返回true;

             int a = 220;

             Integer b = 220;

            System.out.println(a==b);//true
    2、两个Integer类型进行“==”比较, 如果其值在-128至127  ,那么返回true,否则返回false, 这跟Integer.valueOf()的缓冲对象有关,这里不进行赘述。

            Integer c=3;

            Integer h=3;

            Integer e=321;

            Integer f=321;

            System.out.println(c==h);//true

            System.out.println(e==f);//false

    3、两个基本型的封装型进行equals()比较,首先equals()会比较类型,如果类型相同,则继续比较值,如果值也相同,返回true。

            Integer a=1;

            Integer b=2;

            Integer c=3;

            System.out.println(c.equals(a+b));//true

    4、基本型封装类型调用equals(),但是参数是基本类型,这时候,先会进行自动装箱,基本型转换为其封装类型,再进行3中的比较。 

            int i=1;

            int j = 2;

            Integer c=3;

            System.out.println(c.equals(i+j));//true

    展开全文
  • java八种基本数据类型包装类详解

    万次阅读 多人点赞 2018-12-20 10:14:40
    详解一、八种基本数据类型常识 1.1、基本常识表 对于上图有以下几点需要注意: java八种基本数据类型分为四类八种,四类分别为整型、浮点型、布尔型、字符型;八种分别为byte、short、int、long、float、double...

    详解一、八种基本数据类型常识

    1.1、基本常识表

    对于上图有以下几点需要注意:

    1. java八种基本数据类型分为四类八种,四类分别为整型、浮点型、布尔型、字符型;八种分别为byte、short、int、long、float、double、boolean、char;
    2. java八种基本数据类型的字节数:分别为1、2、4、8个字节;1字节(byte、boolean)、 2字节(short、char)、4字节(int、float)、8字节(long、double);
    3. 整数的默认类型为int,浮点数的默认类型为double
    4. 八种基本数据类型的包装类:除了char的是Character、int类型的是Integer,其他都是首字母大写
    5. 关于值的范围问题,需要注意char类型是无符号的,不能为负,所以是0开始的;

    详解二、直接量与类型转换

    2.1、直接量

    1. 整数型的直接量默认为int类型
    2. 浮点型的直接量默认为double类型
    @Test
    	public void d() {
    		int a=100;//这个100就是直接量
    		a=a+100;//但是这个a+100不是直接量
    		double b=3.14;
    	}

    2.2、类型转换

    1.自动转换:低类型的向高类型的转换 

            如下图:顺着箭头的方向是可以自动转换的;

    2.强制转换:高类型的向底类型转换,但可能会数据溢出或者精度丢失

     

    以上现象在实际中可以出现这三种问题:

    • 定义变量时出现的类型转换
    @Test
    	public void e(){
    		long a=200;//200是直接量,默认为int类型这里是自动转换为弄类型
    		
    		/*long b=100000000000;*/
    		//100000000000是个整数直接量,默认应该为int类型,但是超出了int类型的取值范围
    		
    		long c=1000000000000L;
    		//在整数直接量后面将了一个L,表示该直接量不再默认为int类型,为long类型,所以没错
    		
    		/*float d=34.3;*/
    		//浮点型直接量默认为double,double类型大,所以不能直接转换为float
    		
    		float e=34.3f;
    		//在浮点数直接量后面加上一个f,表示该直接量不再默认为double,为float类型
    	}

        以上为几种正常的情况,但是有一种特殊的情况,就是int型直接量可以直接赋给byte、short、char类型变量,只要不超出变量类型的取值范围

    @Test 
    	public void f() {
    		byte a=100;
    		short b=200;
    		char c=100;//注意char类型是一种特殊的int类型,可以不用写成单引号括起来的
    		
    		/*byte d=128;直接量128超出了byte类型的取值范围*/
    		
    		/*char e=-1;直接量-1不在char类型的取值范围内*/
    		
    	}

     

    • 数据运算时的类型转换

              (1)运算时,运算结果会向较大的类型转换

    @Test
    	public void g() {
    		int a=3;
    		double b=4;
    		System.out.println(a+b);//输出7.0
    		
    		float c=3.2f;
    		/*c=c+3.14; 编译错误,运算之后变为double类型*/	
    	}

             (2)特殊的:byte、short、char三种数据类型参与运算时,先一律转化为int类型;

    	@Test
    	public void h() {
    		byte a=3;
    		byte b=4;
    		/*byte c=a+b;
    		 * 编译错误,此处由于byte类型参与运算时,先直接转换为int类型,
    		 * 所以最后的结果也是int类型,但是得出的结果不能叫做int类型的直接量,所以编译错误
    		 * */
    		int d=a+b;
    	}
    • 强制转换

              高等级转为低等级的时候,必须强制转换,但实际工作中不推荐使用强制转换,可能会失精度或数据溢出;

    @Test
    	public void j() {
    		int a=128;
    		byte b=(byte)a;
    		System.out.println(b);//输出-128,出现了数据溢出
    		
    		double c=1.23;
    		int d=(int)c;
    		System.out.println(d);//输出1,精度丢失
    	}

           补充说明:不是只有强制转换的时候会出现数据,例如下面这种情况

    @Test
    	public void k() {
    		int a=10000000;
    		int b=10000000;
    		int c=a*b;
    		System.out.println(c);//输出276447232,得到的结果超出了int类型的范围,数据溢出
    	}

    详解三、对应包装类及使用

    3.1、基本介绍

           java是一门面向对象的语言,但是8中基本数据类型不具备面向对象的特征,所以实际使用中很不便所以为java八种基本数据类型提供了对应的包装类。

    基本数据类型

    对应包装类

    包装类的父类

    byte

    java.lang.Byte

    java.lang.Number

    short

    java.lang.Short

    java.lang.Number

    int

    java.lang.Integer

    java.lang.Number

    long

    java.lang.Long

    java.lang.Number

    float

    java.lang.Float

    java.lang.Number

    double

    java.lang.Double

    java.lang.Number

    boolean

    java.lang.Boolean

    java.lang.Object

    char

    java.lang.Character

    java.lang.Object

    1. 对应包装类比较特殊的就是int对应的Integer和char对应的Character;
    2. 对应包装类的直接父类:前6个由于是数,直接父类为Number,而后两个的直接父类就是Object类;

    3.2、常用方法一:静态方法 valueOf()

    1. 参数为基本数据类型,返回包装类对象
    2. 参数为String字符串(Character类没有以String为  参数的该方法),返回包装类对象
    @Test
    	public void a() {
    	/*1.参数为基本数据类型		
    	 * 作用:将基本数据类型转换为对应包装类 * */
    		Integer i=Integer.valueOf(10);
    		System.out.println(i);//输出10
    	
    	/*2.参数为String字符串时,
    	 * 作用:返回指定字符串值的包装类对象
    	 * 	*/
    		Integer a=Integer.valueOf("100");
    		System.out.println(a);//输出100
    		
    		Integer b=Integer.valueOf("100a")为
    		System.out.println(b);//运行错误,字符串的值不少一个int类型的
    		
    	}
    

    3.3、常用方法二:静态方法parseXXX(String str)

    1. Character类没有该方法;
    2. 作用:将字符串装换为对应的基本数据类型(注意此处和上面的valueOf方法返回值的不同);
    @Test
    	public void b() {
    		/*作用:将给定字符串装换为对应的基本数据类型
    		 * 前提是该字符串必须正确描述该基本数据类型表示的值*/
    		int a=Integer.parseInt("100");
    		System.out.println(a);//输出100
    		
    		int b=Integer.parseInt("100a");
    		System.out.println(b);//运行错误,字符串的值不为int类型
    				
    	}

    3.4、常用方法二:非静态方法XXXValue()

    1. 因为是非静态方法,所以不能像上面两个方法用类名调用了;
    2. 数字类的包装类(八种包装类中父类是Number的的六个类)才有该方法;
    3. 作用:将当前包装类对象转换为对应的基本数据类型;
    @Test
    	public void c() {
    		/*作用:将包装类对象转换为对应的基本数据类型*/
    		
    		Integer a=Integer.valueOf(100);//将基本数据类型转换为包装类对象
    		int b=a.intValue();//将包装类对象转换为对应的基本数据类型
    		System.out.println(b);//输出100
    		
    		Double c=Double.valueOf(2.33);
    		double d=c.doubleValue();
    		System.out.println(d);
    	}

    3.5、自动拆箱与装箱

    • 简介:jdk1.5之后的新特性。该特性是编译器认可的,是在编译器自动将基本数据类型和包装类相互转换,节省了麻烦。
    1. 自动拆箱 包装类——>基本数据类型 (原理是调用了xxxValue方法)    
    2. 自动装箱 基本数据类型——>包装类 (原理是调用了valueOf方法)
    @Test
    	public void d() {
    		/*自动装箱:valueOf*/
    		Integer i=123;//原理是 Integer i=Integer.valueOf(123);
    		
    		/*自动拆箱*/
    		int i1=i+1;//原理是	int i1=i.intValue()+1;
    		
    		Integer a=123;
    		Integer b=123;
    		Integer c=a+b;
    		/*原理为Integer c=Integer.valueOf(a.intValue()+b.intValue());*/
    	}

    3.6、关于valueOf()方法源码研究

    • 通过按住Ctrl键,鼠标点击该方法即可查看源码,以Integer类的valueOf(int i)的源码为例
     public static Integer valueOf(int i) {
            if (i >= IntegerCache.low && i <= IntegerCache.high)
                return IntegerCache.cache[i + (-IntegerCache.low)];
            return new Integer(i);
        }
    • 关于源码的理解:Integer类的valueOf(int i)方法首先会判断i是否在-128~127之间,如果在的话,就返回的对象是Integer类中静态数组cache中的对象,如果不是在这之间,就会重写创建一个新的对象。

    通过查看其它类的该方法的源码之后,可以得到该表:

    包装类

    valueOf(X i)返回对象的原则

    Byte

    直接取,数组范围为(-128,127),且byte值的范围也是(-128,127)

    Short

    (-128,127)之间在数组中取,否则new

    Integer

    (-128,127)之间在数组中取,否则new

    Long

    (-128,127)之间在数组中取,否则new

    Float

    直接new

    Double

    直接new

    Boolean

    直接返回,不new

    Character

    0-127之间从数组中取,否则new

    详解四、相关面试题

    4.1、类型转换

    • 注意一些喜欢忽视的类型转换
    public static void main(String[] args) {
    		int a=10;
    		double b=3.4;
    		System.out.println(a>b?a:b);
    		System.out.println(a);
    	}
    /*输出:10.0   10
    解析:这里是一个很容易让人不注意的类型转化,这里a与b参与了运算,
    所以类型向类型大的方向转化,10就变成了10.0,但是a本身是没有变化的*/

    4.2、+=的情况

    public static void main(String[] args) {
    		short a=1;	//第一行
    		 a=a+1;		//第二行
    		 a+=1;		//第三行
    }
    /*第几行的代码会出错?
    答案:第二行会出错,由于a+1变为了int类型,而int类型不能直接赋值给short类型
    但是+=这种情况是特殊的,所以不会出错;
    */

    4.3、自动装箱

    • 包装类和基本数据类型比较时,只要值相等就相等
    public static void main(String[] args) {
    		Integer a1=127;
    		Integer a2=127;
    		int a3=127;
    		Integer b1=128;
    		Integer b2=128;
    		int b3=128;
    		System.out.println(a1==a2);
    		System.out.println(a1==a3);
    		System.out.println(b1==b2);
    		System.out.println(b1==b3);	
    }
    /*输出:true true false true
    解析:自动装箱时采用valueOf方法,由于127在静态数组的范围内,所以不是new的,
    而128的两个引用是指向new出现对象的,所以第一个是true,第三个是false。
    而包装类和基本数据类型比较时,只要数值是相等的,就相等
    */

    4.4、char类型存储汉字

         char类型能不能存储一个汉字?为什么?

         解析:能,char类型采用的是Unicode编码,Unicode编码包含汉字,所以char类型自然是可以存储一个汉字的

    4.5、浮点数精度问题

    public static void main(String[] args) {
    		System.out.println(0.1*3==0.3);
    		System.out.println(0.1*4);
    }
    /*输出:false 0.4
    解析:有些浮点数不能准确的表示出来,与整数相乘之后出精度丢失,常见为小数位含3的
    */

    第一篇技术博客!记载一下2018.12.20 10:14:20!

    觉得写的还可以的话不要忘记点赞哦!

    觉得哪里写的有问题的话,欢迎评论指出问题,我们讨论讨论!

     

    展开全文
  • 基本数据类型与其包装类的比较

    千次阅读 2018-02-08 20:15:28
    最近刷题的时候碰到了不少基本数据类型和包装类进行比较的问题,一开始做的有点蒙,错多了之后就自己整理了一下,特记录下来加深印象。 在java中不能定义基本数据类型对象,为了能将基本数据类型视为对象处理,...

    最近刷题的时候碰到了不少基本数据类型和包装类进行比较的问题,一开始做的有点蒙,错多了之后就自己整理了一下,特记录下来加深印象。


    在java中不能定义基本数据类型对象,为了能将基本数据类型视为对象处理,并且能够调用方法简化其使用过程,java为每个基本类型都提供了包装类。
    下面是8种基本数据类型图解
    8种基本数据类型
    下面是基本数据类型及其包装类对照表:

    基本数据类型包装类
    intInteger
    byteByte
    shortShort
    longLong
    floatFloat
    doubleDouble
    charChar
    booleanBoolean

    包装类提供了多种常用方法,如下图:
    Integer类的方法
    其中equals方法在本篇中有所涉及,摘录其源码如下:

        public boolean equals(Object obj) {
            if (obj instanceof Integer) {
                return value == ((Integer)obj).intValue();
            }
            return false;
        }

    可以看出,先通过instanceof判断比较对象obj是否是Integer的类实例,如果不是,则return false,若是,则强制转换为Integer类并通过intValue()方法取值,比较调用方法的对象的值和该值是否相等,返回比较结果。
    包装类往往涉及到比较两个对象或者比较对象和基本数据类型的大小的问题。
    下面以最常用的Integer类为例,用程序说明几种判断方式。
    通过总结得到以下四点:
    1.同样被new出的两个相同类型的对象一定是不“==”的,因为==比较的是位置,而new出的对象一定是全新地址的,但是用equals比较时是比较的数值,是相等的。

        Integer a=new Integer(5);
        Integer b=new Integer(5);
        System.out.println(a==b);//return false
        System.out.println(a.equals(b));//return true

    2.在“==”进行比较时,有以下原则:
    1)不用new得到新对象,当要赋的值在区间[-128,127]时,该值会被缓存到IntegerCache.cache中,此时赋值的是同一对象,用“==”比较会返回ture;

        Integer a=5;
        Integer b=5;
        System.out.println(a==b);//return true

    2)当要赋的值在(-∞,-128)或(127,+∞)时,即时不用new得到新对象,用“==”比较也会返回false;

        Integer a=128;
        Integer b=128;
        Integer c=-129;
        Integer d=-129;
        System.out.println(a==b);//return false
        System.out.println(c==d);//return false

    3)当用new赋值时,一定返回false;
    3.当Integer对象与基本类型做比较时,默认将Integer对象做拆箱操作,比较基本类型,而基本类型的比较只与数值有关,因此数值一样就返回true;

        Integer a=new Integer(5);
        int c=5;
        System.out.println(a==c);//return true

    4.若两个Byte对象相加,则会自动升格为int,只能赋值给int或更高精度的类型,因此赋值给Byte一定出错。

            Byte a = new Byte((byte) 5);
            Byte b = new Byte((byte) 5);
            Byte c = a + b;
            /*
             * 报错如下:
             * Type mismatch: cannot convert from int to Byte 
             */

    希望有缺漏的地方各位能够予以补充。

    展开全文
  • 1、包装类是对象,拥有方法字段,对象的调用都是通过引用对象的地址;基本类型不是2、包装类型是引用的传递;基本类型是值的传递3、声明方式不同: 基本数据类型不需要new关键字; 包装类型需要new在堆内存中进行...
  • 作为面Java为什么要有基本数据类型和包装类型? 这个问题看似简单,其实也不好回答。毕竟这个问题不仅你我感觉到困惑,许多大佬也感觉到困惑,一些人希望把基本数据类型剔除,一些人希望继续保留。 ...
  • 基本数据类型和包装类的区别: 1.int初始值0 Integer初始值null 2.包装类中有很多方法。 3.集合框架中不能存放基本数据类型,只能存对象。 什么时候去使用? 在类中,一般使用包装类。 方法中,一般使用基本...
  • java中的基本数据类型如int,double等不是对象,无法通过向上转型获取到Object提供的方法. 而String却可以,因为String是一个对象而不是一个类型。 基本数据类型由于这样的特性,导致无法参与转型,泛型,反射等过程...
  • 包装类是对象,拥有方法字段.对象的调用都是通过引用对象的地址,产生对象时直接用引用指向这个对象(引用变量是在存在栈内存中,对象是在堆内存中的,堆中分配内存); 基本类型不是,直接存储数值.另外一个区别...
  • java基本数据类型对象包装类

    千次阅读 2017-10-30 22:37:35
    java基本数据类型对象包装类   一、包装类说明 为了方便操作基本数据类型值,将其封装成了对象,在对象中定义了属性行为丰富了该数据的操作。用于描述该对象的类就称为基本数据类型对象包装类基本数据类型与...
  • 基本数据类型和包装类、String类的转换&toString方法&instanceof运算符1.包装类
  • 字符串与其他数据类型之间的转换
  • Java 八大基本数据类型以及包装类

    千次阅读 2018-08-10 10:54:09
    Java 八大基本数据类型以及包装类 一、java中八种基本数据类型对应的包装类型: 原始类型 包装类 原始类型所占的字节数 short Short 2个字节 int Integer 4个字节 long Long 8个字节 float Float 4个字节...
  • 基本数据类型和包装类的参数绑定 学习本文需要安装的软件: JDK1.8 、IDEA2017.3、Maven3.3.3、Tomcat7.0.64 - 基本数据类型和包装类的参数绑定 1.准备POJO public class TestUser { private ...
  • 本人最近找工作,在面试javase基础这里,有很多公司还是喜欢考察基本数据类型和包装类型的使用情况,重点就是考察日常生活中对数据类型的选定还有使用场景做考察,比如问基本数据类型的占几个字节,取值范围多少、...
  • 数据类型:分为基本数据类型和引用数据类型 基本数据类型包括  数值型:byte(占一字节) short(占两字节) int(占四字节) long(占八字节)float(占四字节)double(占八字节);  字符型:char(占一字节)...
  • 8个基本数据类型包装类

    千次阅读 2017-02-20 15:03:55
    我们知道,java提供的8种基本数据类型并不支持面向对象的编程机制,不具备“对象“的...但是在某些时候,基本数据类型也会有一些制约,例如所有的引用类型的变量都继承了Object,都可以当成Object类型变量使用。但基
  • java数据类型包括两大基本数据类型和引用数据类型。 引用数据类型:、接口、数组。 基本数据类型:数值型{(整数类型:byte、short、int、long)(浮点类型:float、double)}、字符型(char)、布尔型...
  • 一、String 转化成 基本数据类型 利用基本数据类型对应的包装类的parseXxx() 或 valueOf() 方法 注意 : String 对象的字面量 是 数字类型。否则会报异常(NumberFormatException)。例如 : //定义一个 str 对象,字面...
  • 基本数据类型包装类 **Java是面向对象语言,但是不是“纯面向对象”,因为我们常用的基本数据类型就不是对象。但是在实际应用中我们常常将基本数据类型转化为对象,以方便操作。例如:将基本数据类型存储到object...
  • 包装类和基本数据类型的区别

    千次阅读 2018-01-25 14:18:18
    基本数据类型的 优点: 1.计算的效率高 2.不会由于常量池引起比较大小错误(比较数据更准确) 缺点 1.当数据库查询出结果封装到结果集时,如何返回的值为null时,会将结果赋值给字段,运行时会报错,不能将null值赋值...
  • ...注意:char两字节,包装类为Character,boolean的字节 原图地址:https://blog.csdn.net/ptsx0607/article/details/68951760  https://www.cnblogs.com/yangming1996/p/8830305.html...
  • 一、基本数据类型包装类之间的转换: import org.junit.Test; public class MainTest { /** * 基本数据类型包装类之间的转换 */ @Test public void test() { /** * 基本数据类型 -----> 包装类 */
  • 在Java初学阶段,想必很多人都会先学Java中的一些基本类型以及他们的包装类,如下 int --> Integer long --> Long double --> Double ...等等 很多人在学的时候感觉这用处不大啊,也不知道什么时候用,该...
  • Java中基本数据类型和包装类

    千次阅读 2015-03-25 14:52:35
    基本类型(原始数据类型) byte short int long float double char boolean 基本类型的变量持有原始值。 2. 符合数据类型(引用类型),引用类型持有引用值(即对某个对象的引用,而非对象本身)。一般Java在...
  • 八大基本数据类型对应的包装类

    千次阅读 2020-09-26 20:21:04
    int我们肯定都熟悉吧,是Java当中的一个基本数据类型,这跟C语言当中的int也一样,对于Integer呢,我们或多或少也知道一点,Integer是Java当中的包装类,说白了它就是一个类。   我们首先来回顾以下Java当中的八大...
  • 一、java中八种基本数据类型对应的包装类型:   原始类型 包装类 原始类型所占的字节数  short Short 2个字节  int Integer 4个字节  long Long 8个字节  float Float 4个字节  double Do
  • Java中基本数据类型和包装类型有什么区别?

    万次阅读 多人点赞 2017-03-11 19:15:50
    1、包装类是对象,拥有方法字段,对象的调用都是通过引用对象的地址,基本类型不是 2、包装类型是引用的传递,基本类型是值的传递 3、声明方式不同,基本数据类型不需要new关键字,而包装类型需要new在堆内存中...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 198,687
精华内容 79,474
关键字:

基本数据类型和包装类