精华内容
下载资源
问答
  • java学习之路---包装类

    2013-11-19 13:21:42
    Integer ,Byte,Float,Long,Double,Short都是属于Number类的子类 Character, Boolean 都是object的子类 2.拆箱与装箱 装箱就是:把基本数据转为包装类。 拆箱:包装类变为基本
    万物接对象,那么基本数据也是对象吗?
    不是,那么怎么变成对象喃?(经过包装就OK了)
    看下面的表


    Integer ,Byte,Float,Long,Double,Short都是属于Number类的子类

    Character, Boolean 都是object的子类


    2.拆箱与装箱

    装箱就是:把基本数据转为包装类。
    拆箱:包装类变为基本数据
    现在只需要了解就OK了,值得是怎么回事,java现在把拆箱和装箱都自动化了

    3.包装的应用
    就是类型之间的互相转换

    1. /** 
    2.  * <p>TypeChange.java 
    3.  * <p>JAVA基本类型互相转换 
    4.  *  
    5.  * @author heardy 
    6.  * @time 2011/01/30 
    7.  * @version 1.0 
    8.  */  
    9. public class TypeChange {  
    10.   
    11.     /** 
    12.      * 转为字符串 
    13.      *  
    14.      * @param obj 
    15.      * @return 为null时返回空字符串 
    16.      */  
    17.     public static String objectToString(Object obj) {  
    18.     String str = "";  
    19.     try {  
    20.         str = (String) obj;  
    21.         if (str == null) {  
    22.         str = "";  
    23.         }  
    24.     } catch (ClassCastException ce) {  
    25.         try {  
    26.         str = String.valueOf(obj);  
    27.         } catch (Exception e) {  
    28.         str = "";  
    29.         }  
    30.     }  
    31.     return str.trim();  
    32.     }  
    33.   
    34.     /** 
    35.      * 转null为空字符 
    36.      *  
    37.      * @param str 
    38.      * @return 
    39.      */  
    40.     public static String nullOfString(Object obj) {  
    41.     String str = objectToString(obj);  
    42.     return str;  
    43.     }  
    44.   
    45.     /** 
    46.      * 转null为Int 
    47.      *  
    48.      * @param obj 
    49.      * @return 
    50.      */  
    51.     public static int nullOfInt(Object obj) {  
    52.     return objectToInt(obj);  
    53.     }  
    54.   
    55.     // *****************Object 转 其他类型*****************  
    56.   
    57.     /** 
    58.      * 转字节 
    59.      *  
    60.      * @param str 
    61.      * @return 
    62.      * @throws 如果无法转换 
    63.      *             抛出 NumberFormatException 
    64.      */  
    65.     public static byte objectToByte(Object obj) {  
    66.     String str = objectToString(obj);  
    67.     str = nullOfString(str);  
    68.     try {  
    69.         return Byte.parseByte(str);  
    70.     } catch (NumberFormatException e) {  
    71.         System.out.println("转换出错" + e);  
    72.         throw e;  
    73.     }  
    74.     }  
    75.   
    76.     /** 
    77.      * 转布尔 
    78.      *  
    79.      * @param str 
    80.      * @return 为1或"true"返回真 否则假 
    81.      */  
    82.     public static boolean objectToBoolean(Object obj) {  
    83.     String str = objectToString(obj);  
    84.     if (str.equals("1")) {  
    85.         return true;  
    86.     } else if (str.equals("0")) {  
    87.         return false;  
    88.     } else {  
    89.         try {  
    90.         return Boolean.parseBoolean(str);  
    91.         } catch (Exception e) {  
    92.         return false;  
    93.         }  
    94.     }  
    95.     }  
    96.   
    97.     /** 
    98.      * 转Int 
    99.      *  
    100.      * @param str 
    101.      * @return 相应的值 或 零 
    102.      */  
    103.     public static int objectToInt(Object obj) {  
    104.     String str = objectToString(obj);  
    105.     int i = 0;  
    106.     try {  
    107.         i = Integer.parseInt(str.trim());  
    108.     } catch (NumberFormatException e) {  
    109.         i = 0;  
    110.     }  
    111.     return i;  
    112.     }  
    113.   
    114.     /** 
    115.      * 转short 
    116.      *  
    117.      * @param obj 
    118.      * @return 相应的值 或 零 
    119.      */  
    120.     public static short objectToShort(Object obj) {  
    121.     String str = objectToString(obj);  
    122.     short i = 0;  
    123.     try {  
    124.         i = Short.parseShort(str.trim());  
    125.     } catch (NumberFormatException e) {  
    126.         i = 0;  
    127.     }  
    128.     return i;  
    129.     }  
    130.   
    131.     /** 
    132.      * 转Double 
    133.      *  
    134.      * @param obj 
    135.      * @return 相应的值 或 零 
    136.      */  
    137.     public static double objectToDouble(Object obj) {  
    138.     String str = objectToString(obj);  
    139.     double i = 0;  
    140.     try {  
    141.         i = Double.parseDouble(str.trim());  
    142.     } catch (NumberFormatException e) {  
    143.         i = 0;  
    144.     }  
    145.     return i;  
    146.     }  
    147.   
    148.     /** 
    149.      * 转Long 
    150.      *  
    151.      * @param obj 
    152.      * @return 相应的值 或 零 
    153.      */  
    154.     public static long objectToLong(Object obj) {  
    155.     String str = objectToString(obj);  
    156.     Long li = new Long(0);  
    157.     try {  
    158.         li = Long.valueOf(str);  
    159.     } catch (NumberFormatException e) {  
    160.     }  
    161.     return li.longValue();  
    162.     }  
    163.   
    164.     // ***************** 其他类型相互转换 *****************  
    165.   
    166.     /** 
    167.      * double转long 
    168.      *  
    169.      * @param d 
    170.      * @return 只截取前面的整数 
    171.      */  
    172.     public static long doubleToLong(double d) {  
    173.     long l = 0;  
    174.     try {  
    175.         // double转换成long前要过滤掉double类型小数点后数据  
    176.         l = Long.parseLong(String.valueOf(d).substring(0,  
    177.             String.valueOf(d).lastIndexOf(".")));  
    178.     } catch (Exception e) {  
    179.         l = 0;  
    180.     }  
    181.     return l;  
    182.     }  
    183.   
    184.     /** 
    185.      * double转int 
    186.      *  
    187.      * @param d 
    188.      * @return 只截取前面的整数 
    189.      */  
    190.     public static int doubleToInt(double d) {  
    191.     int i = 0;  
    192.     try {  
    193.         // double转换成Int前要过滤掉double类型小数点后数据  
    194.         i = Integer.parseInt(String.valueOf(d).substring(0,  
    195.             String.valueOf(d).lastIndexOf(".")));  
    196.     } catch (Exception e) {  
    197.         i = 0;  
    198.     }  
    199.     return i;  
    200.     }  
    201.   
    202.     /** 
    203.      * double转long(四舍五入) 
    204.      *  
    205.      * @param d 
    206.      * @return 只截取前面的整数 (四舍五入) 
    207.      */  
    208.     public static long doubleToLongWhithRound(double d) {  
    209.     long l = 0;  
    210.     try {  
    211.         l = Math.round(d);  
    212.     } catch (Exception e) {  
    213.         l = 0;  
    214.     }  
    215.     return l;  
    216.     }  
    217.   
    218.     /** 
    219.      * double转int(四舍五入) 
    220.      *  
    221.      * @param d 
    222.      * @return 只截取前面的整数 (四舍五入) 
    223.      */  
    224.     public static int doubleToIntWhithRound(double d) {  
    225.     int i = 0;  
    226.     try {  
    227.         i = (int) Math.round(d);  
    228.     } catch (Exception e) {  
    229.         i = 0;  
    230.     }  
    231.     return i;  
    232.     }  
    233.   
    234.     public static double longToDouble(long d) {  
    235.     double l = 0;  
    236.     try {  
    237.         l = Double.parseDouble(String.valueOf(d));  
    238.     } catch (Exception e) {  
    239.         l = 0;  
    240.     }  
    241.     return l;  
    242.     }  
    243.   
    244.     public static int longToInt(long d) {  
    245.     int l = 0;  
    246.     try {  
    247.         l = Integer.parseInt(String.valueOf(d));  
    248.     } catch (Exception e) {  
    249.         l = 0;  
    250.     }  
    251.     return l;  
    252.     }  


    展开全文
  • Java Number

    2018-01-14 20:15:07
    所有的包装类(Integer、Long、Byte、Double、Float、Short)都是抽象类 Number 子类。 这种由编译器特别支持包装称为装箱,所以当内置数据类型被当作对象使用时候,编译器会把内置类型装箱为包装类。相似...

    所有的包装类(Integer、Long、Byte、Double、Float、Short)都是抽象类 Number 的子类。
    这种由编译器特别支持的包装称为装箱,所以当内置数据类型被当作对象使用的时候,编译器会把内置类型装箱为包装类。相似的,编译器也可以把一个对象拆箱为内置类型。Number 类属于 java.lang 包。

    下面是一个使用 Integer 对象的实例:

    public class Test{
        public static void main(String args[]){
          Integer x = 5;
          x =  x + 10;
          System.out.println(x); 
       }
    }

    result:
    15

    常用的一些方法

    方法 描述
    xxxValue() 将 Number 对象转换为xxx数据类型的值并返回。
    compareTo() 将number对象与参数比较。
    equals() 判断number对象是否与参数相等。
    valueOf() 返回一个 Number 对象指定的内置数据类型
    toString() 以字符串形式返回值。
    parseInt() 将字符串解析为int类型。
    展开全文
  • 下面属于java包装类的是? A.String B.Long C.Character D.Short 解释: Java 语言是一个面向对象的语言,但是Java中的基本数据类型却是不面向对象的,这在实际使用时存在很多的不便,为了解决这个不足,在设计类时...

    > 1.下面属于java包装类的是?
    A.String
    B.Long
    C.Character
    D.Short

    解释: Java 语言是一个面向对象的语言,但是Java中的基本数据类型却是不面向对象的,这在实际使用时存在很多的不便,为了解决这个不足,在设计类时为每个基本数据类型设计了一个对应的类进行代表,即包装类。对应的基本类型和包装类如下表:
    基本数据类型 包装类
    byte Byte
    boolean Boolean
    short Short
    long Long
    float Float
    double Double

    *String不是基本类型


    2.对于Java中异常的描述正确的是( )
    A.用throws定义了方法可能抛出的异常,那么调用此方法时一定会抛出此异常。
    B.如果try块中没有抛出异常,finally块中的语句将不会被执行。
    C.抛出异常意味着程序发生运行时错误,需要调试修改
    D.Java中的可不检测(unchecked)异常可能来自RuntimeException类或其子类。

    A错 在调用此方法的时候 也可以再次申明以将异常交由更高一级处理。
    B错 finally块中的语句一定会被执行。除非catch块中有System.exit(0)。
    C错 抛出异常不一定是运行时异常,也有可能是编译时异常。
    D对 运行时异常的特点是Java编译器不会检查它。

    解析:Exception(异常)是程序本身可以处理的异常。主要包含RuntimeException等运行时异常和IOException,SQLException等非运行时异常。

    运行时异常 包括:都是RuntimeException类及其子类异常,如NullPointerException(空指针异常)、IndexOutOfBoundsException(下标越界异常)等,这些异常是不检查异常,程序中可以选择捕获处理,也可以不处理。这些异常一般是由程序逻辑错误引起的,程序应该从逻辑角度尽可能避免这类异常的发生。
    运行时异常的特点是Java编译器不会检查它,也就是说,当程序中可能出现这类异常,即使没有用try-catch语句捕获它,也没有用throws子句声明抛出它,也会编译通过。
    非运行时异常(编译异常) 包括:RuntimeException以外的异常,类型上都属于Exception类及其子类。从程序语法角度讲是必须进行处理的异常(try catch 或者抛出),如果不处理,程序就不能编译通过。如IOException、SQLException等以及用户自定义的Exception异常,一般情况下不自定义检查异常

    选项中哪一行代码可以添加 到题目中而不产生编译错误?

    public abstract class MyClass {
         public int constInt = 5;
         //add code here
         public void method() {
         }
    }
    

    A. public abstract void method(int a);
    B. constInt = constInt + 5;
    C.public int method();
    D.public abstract void anotherMethod() {}

    A.是抽象方法,抽象类可以包含抽象方法,也可以不包含,虽然A 方法名是method,与题目中的方法同名,但是参数不同,是重载方法
    B. 在类中不能constInt = constInt + 5;
    C.方法中可以 C 的方法名与题目中的方法名相同,返回值不能作为重载的依据 D
    D.抽象方法没有方法体

    展开全文
  • 1.下面属于java包装类的是? A.String B.Long C.Character D.Short 分析: 这应该是一个比较容易的题目了,但是也是得死记硬背的题,所以拿出来给大家记一记。 Java 语言是一个面向对象的语言,但是...
        

    欢迎大家关注笔者的微信公众号:JAVAandPython君

    关注后发送“领取资料”即可领取5T技术资源

    1

    1.下面属于java包装类的是?

    A.String

    B.Long

    C.Character

    D.Short

    分析:

       这应该是一个比较容易的题目了,但是也是得死记硬背的题,所以拿出来给大家记一记。 
    
       Java 语言是一个面向对象的语言,但是Java中的基本数据类型却是不面向对象的,这在实际使用时存在很多的不便,为了解决这个不足,在设计类时为每个基本数据类型设计了一个对应的类进行代表,即包装类。对应的基本类型和包装类如下表:
    
    8733802-3149f3308ce33a99
    image

    答案:B,D

    2

    2.对于Java中异常的描述正确的是?

    A.用throws定义了方法可能抛出的异常,那么调用此方法时一定会抛出此异常。

    B.如果try块中没有抛出异常,finally块中的语句将不会被执行。

    C.抛出异常意味着程序发生运行时错误,需要调试修改

    D.Java中的可不检测(unchecked)异常可能来自RuntimeException类或其子类。

    分析:

    A错 在调用此方法的时候 也可以再次申明以将异常交由更高一级处理。

    B错 finally块中的语句一定会被执行。除非catch块中有System.exit(0)。对于finally确实值得深究,下次也写篇文章来分析分析。

    C错 抛出异常不一定是运行时异常,也有可能是编译时异常。这里甩给大家一张图:

    8733802-73b38496671294c4
    image

    这里多讲几句,Exception(异常)是程序本身可以处理的异常。主要包含RuntimeException等运行时异常IOException,SQLException等非运行时异常

    运行时异常包括:都是RuntimeException类及其子类异常,如NullPointerException(空指针异常)、IndexOutOfBoundsException(下标越界异常)等,这些异常是不检查异常,程序中可以选择捕获处理,也可以不处理。这些异常一般是由程序逻辑错误引起的,程序应该从逻辑角度尽可能避免这类异常的发生。

    运行时异常的特点是Java编译器不会检查它,也就是说,当程序中可能出现这类异常,即使没有用try-catch语句捕获它,也没有用throws子句声明抛出它,也会编译通过。

    非运行时异常(编译异常) 包括:RuntimeException以外的异常,类型上都属于Exception类及其子类。从程序语法角度讲是必须进行处理的异常(try catch 或者抛出),如果不处理,程序就不能编译通过。如IOException、SQLException等以及用户自定义的Exception异常,一般情况下不自定义检查异常。

    D对 运行时异常的特点是Java编译器不会检查它。

    答案:D

    3

    下列哪个说法是正确的?

    A. ConcurrentHashMap使用synchronized关键字保证线程安全

    B.HashMap实现了Collction接口

    C.Array****.asList方法返回java.util.ArrayList对象

    D.SimpleDateFormat是线程不安全的

    分析:

    A选项中,ConcurrentHashMap 使用segment来分段和管理锁,segment继承自ReentrantLock,因此ConcurrentHashMap使用ReentrantLock来保证线程安全。

    B中,HashMap定义规则如下:

    public class HashMap<K,V>   extends AbstractMap<K,V>   implements Map<K,V>, Cloneable, Serializable
    

    所以HasMap跟Collection没啥关系!

    C中,应该是Arrays.asList(),其将一个数组转化为一个List对象,这个方法会返回一个ArrayList类型的对象, 这个ArrayList类并非java.util.ArrayList类,而是Arrays类的内部

    D.特意去看了一下jdk,如图:

    8733802-713cde31bf217526.gif
    image.gif

    官方说是不安全的

    答案:D

    4

    java 中哪个关键字可以对对象加互斥锁?
    A.transient
    B.synchronized
    C.serialize
    D.static

    分析:

    这题估计大家都会,但是拿出来主要是说说有一些修饰符具体有啥用的,给大家拓展拓展:

    static 修饰符,用来创建类方法和类变量。

    final 修饰符,用来修饰类、方法和变量,final 修饰的类不能够被继承,修饰的方法不能被继承类重新定义,修饰的变量为常量,是不可修改的。

    abstract 修饰符,用来创建抽象类和抽象方法。

    **synchronized **用于多线程的同步。用来给对象和方法或者代码块加锁,各线程互斥访问。

    volatile 修饰的成员变量在每次被线程访问时,都强制从共享内存中重新读取该成员变量的值。而且,当成员变量发生变化时,会强制线程将变化值回写到共享内存。这样在任何时刻,两个不同的线程总是看到某个成员变量的同一个值。

    serialize:Java 对象序列化为二进制文件。

    transient:序列化的对象包含被 transient 修饰的实例变量时,java 虚拟机(JVM)跳过该特定的变量。

    答案:B

    5

    1 .class Parent{2. public float aFun(float a, float b) { }3 .}4 .class Child extends Parent{5 .6 .}
    

    将以下哪种方法插入行5是不合法的?

    A.float aFun(float a, float b){ }

    B.public int aFun(int a, int b) { }

    C.public float aFun(float p, float q){ }

    D.private int aFun(int a, int b){ }

    分析:

    这个题主要是考察了方法的重写,我们来扯一扯:

    方法重写应遵循“三同一小一大”原则

    “三同”:即方法名相同,形参列表相同,返回值类型相同;

    “一小”:子类方法声明抛出的异常比父类方法声明抛出的异常更小或者相等;

    “一大”:子类方法的访问修饰符应比父类方法更大或相等。

    A选项是重写,但是默认访问修饰符比父类小,插入第五行编辑器会报错。 default,默认的访问权限,也是可以省略的访问权限,它不仅能在设置了该权限的类中访问,也可以在同一包中的类或子类中访问。意思就是只能由跟这个类在同一个包中的类来访问,比private限制更少,但比protected限制更多。

    B、D不是重写。因为形参列表和返回值类型不同,不满足“三同”。所以写在第五行以普通方法对待,插入第五行没有错误。

    C选项满足重写的各项条件,是正确的重写,所以插入第五行没有错误。

    展开全文
  • Java Number & Math

    2019-10-08 12:40:22
    这种由编译器特别支持包装称为装箱,所以当内置数据类型被当作对象使用时候,编译器会把内置类型装箱为包装类。相似,编译器也可以把一个对象拆箱为内置类型。Number 类属于 java.lang 包。下面是一个使用 ...
  • Set 接口属于抽象 Set 下面有两个实现,HashSet 和 TreeSet 一、Set 接口 1、Set 概述 一个不包含重复元素 Collection 2、Set 案例 存储字符串并遍历 存储自定义对象并遍历 二、HashSet 实现 1、...
  • JAVA类集框架简单介绍

    2020-06-05 17:04:22
    所谓集就是一个动态对象数组,是对一些实现好的数据结构进行包装,最重要的是类集框架本身不受对象数组长度的限制。 集框架被设计成拥有以下几个特性: 1,高性能 2,框架必须允许不同类型的集以相同方式和...
  • 如JDK内部自带很多不可变类:Interger、Long和String(8种基本数据类型的包装类和String都是不可变类)等。 可变类:相对于不可变类,可变类创建实例后可以改变其成员变量值,开发中创建大部分类都属于可变类。 ...
  • 值类型和引用类型 值类型:Java的八种基本数据...引用类型:Java引用类型继承于Object类,像上面八种基本数据类型的包装类,以及我们自定义类都属于引用类型。对于引用类型变量空间分配需要使用到栈和堆,首先...
  • Java不可变对象

    2017-09-04 14:45:50
    一、不可变类简介不可变类:所谓的不可变类是指这个类的实例一旦创建完成后,就不能改变其成员变量值。如JDK内部自带的很多不可变类:Interger、Long和String等。...Java中的8个包装类和String类都是
  • 这两个类都属于java io中的包装类,为基础流提供了丰富读写方法,可以将java中数据类型轻松地写入流中。 下面还是先贴出源码进行简单分析:DataInputStream.java: package java.io; public class ...
  • 适配器模式(Java

    万次阅读 2019-08-03 01:26:41
    适配器模式(Java) 先来张官方UML 下面是我这个例子的UML 中国人是独立的一个类...在计算机编程中,适配器模式(有时候也称包装样式或者包装)将一个类的接口适配成用户所期待的。一个适配允许通常因为接口...
  • 这种类型的设计模式属于结构型模式,它是作为现有的类的一个包装。这种模式创建了一个装饰类,用来包装原有的类,并在保持类方法签名完整性的前提下,提供了额外的功能。我们通过下面的实例来演示装饰器模式的用法。...
  • Java开发技术大全(500个源代码).

    热门讨论 2012-12-02 19:55:48
    otherClass.java类的外部访问对象的成员 showInstVar.java 演示不同的对象拥有不同的成员变量 showMain.java 演示main方法访问本类成员 showMethod.java 演示如何定义一个方法体 showReturn_1.java return...
  • 这种类型的设计模式属于结构型模式,它是作为现有的类的一个包装。这种模式创建了一个装饰类,用来包装原有的类,并在保持类方法签名完整性的前提下,提供了额外的功能。我们通过下面的实例来演示装饰器模式的用法。...
  • 这种类型的设计模式属于结构型模式,它是作为现有的类的一个包装。 这种模式创建了一个装饰类,用来包装原有的类,并在保持类方法签名完整性的前提下,提供了额外的功能。 我们通过下面的实例来演示装饰器模式的用法...
  • 不可变类:所谓的不可变类是指这个类的实例一旦创建完成后,就不能改变其成员变量值。如JDK内部自带的很多不可变类:Interger、Long和String等。可变类:相对于不可变类,可变类...Java中的8个包装类和String类都...
  • 这种类型的设计模式属于结构型模式,它是作为现有的类的一个包装。 这种模式创建了一个装饰类,用来包装原有的类,并在保持类方法签名完整性的前提下,提供了额外的功能。 我们通过下面的实例来演示装饰器模式的...
  • 策略模式通常把一个系列的算法包装到一系列的策略类里面,作为一个抽象策略类的子类。用一句话来说,就是:“准备一组算法,并将每一个算法封装起来,使得它们可以互换”。下面就以一个示意性的实现讲解策略模式实例...
  • 这种类型的设计模式属于结构型模式,它是作为现有的类的一个包装。 这种模式创建了一个装饰类,用来包装原有的类,并在保持类方法签名完整性的前提下,提供了额外的功能。 我们通过下面的实例来演示装饰器模式的...
  • 这种类型的设计模式属于结构型模式,它是作为现有的类的一个包装。 这种模式创建了一个装饰类,用来包装原有的类,并在保持类方法签名完整性的前提下,提供了额外的功能。 我们通过下面的实例来演示装饰器模式的用法...
  • 这种类型的设计模式属于结构型模式,它是作为现有的类的一个包装。 这种模式创建了一个装饰类,用来包装原有的类,并在保持类方法签名完整性的前提下,动态给一个对象添提供了额外的功能。 我们通过下面的实例来...
  • 这种类型的设计模式属于结构型模式,它是作为现有的类的一个包装。 这种模式创建了一个装饰类,用来包装原有的类,并在保持类方法签名完整性的前提下,提供了额外的功能。 我们通过下面的实例来演示装饰器模式的...
  • 这种类型的设计模式属于结构型模式,它是作为现有的类的一个包装。 这种模式创建了一个装饰类,用来包装原有的类,并在保持类方法签名完整性的前提下,提供了额外的功能。 我们通过下面的实例来演示装饰器模式的用法...
  • 这种类型的设计模式属于结构型模式,它是作为现有的类的一个包装。 这种模式创建了一个装饰类,用来包装原有的类,并在保持类方法签名完整性的前提下,提供了额外的功能。 我们通过下面的实例来演示装饰器模式的用法...

空空如也

空空如也

1 2 3
收藏数 45
精华内容 18
关键字:

下面属于java包装类的是

java 订阅