万物接对象，那么基本数据也是对象吗？
不是，那么怎么变成对象喃？（经过包装就OK了）
看下面的表







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



Character, Boolean 都是object的子类






2.拆箱与装箱



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



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






/** 

 * <p>TypeChange.java 

 * <p>JAVA基本类型互相转换 

 *  

 * @author heardy 

 * @time 2011/01/30 

 * @version 1.0 

 */  

public class TypeChange {  

  

    /** 

     * 转为字符串 

     *  

     * @param obj 

     * @return 为null时返回空字符串 

     */  

    public static String objectToString(Object obj) {  

    String str = "";  

    try {  

        str = (String) obj;  

        if (str == null) {  

        str = "";  

        }  

    } catch (ClassCastException ce) {  

        try {  

        str = String.valueOf(obj);  

        } catch (Exception e) {  

        str = "";  

        }  

    }  

    return str.trim();  

    }  

  

    /** 

     * 转null为空字符 

     *  

     * @param str 

     * @return 

     */  

    public static String nullOfString(Object obj) {  

    String str = objectToString(obj);  

    return str;  

    }  

  

    /** 

     * 转null为Int 

     *  

     * @param obj 

     * @return 

     */  

    public static int nullOfInt(Object obj) {  

    return objectToInt(obj);  

    }  

  

    // *****************Object 转 其他类型*****************  

  

    /** 

     * 转字节 

     *  

     * @param str 

     * @return 

     * @throws 如果无法转换 

     *             抛出 NumberFormatException 

     */  

    public static byte objectToByte(Object obj) {  

    String str = objectToString(obj);  

    str = nullOfString(str);  

    try {  

        return Byte.parseByte(str);  

    } catch (NumberFormatException e) {  

        System.out.println("转换出错" + e);  

        throw e;  

    }  

    }  

  

    /** 

     * 转布尔 

     *  

     * @param str 

     * @return 为1或"true"返回真 否则假 

     */  

    public static boolean objectToBoolean(Object obj) {  

    String str = objectToString(obj);  

    if (str.equals("1")) {  

        return true;  

    } else if (str.equals("0")) {  

        return false;  

    } else {  

        try {  

        return Boolean.parseBoolean(str);  

        } catch (Exception e) {  

        return false;  

        }  

    }  

    }  

  

    /** 

     * 转Int 

     *  

     * @param str 

     * @return 相应的值 或 零 

     */  

    public static int objectToInt(Object obj) {  

    String str = objectToString(obj);  

    int i = 0;  

    try {  

        i = Integer.parseInt(str.trim());  

    } catch (NumberFormatException e) {  

        i = 0;  

    }  

    return i;  

    }  

  

    /** 

     * 转short 

     *  

     * @param obj 

     * @return 相应的值 或 零 

     */  

    public static short objectToShort(Object obj) {  

    String str = objectToString(obj);  

    short i = 0;  

    try {  

        i = Short.parseShort(str.trim());  

    } catch (NumberFormatException e) {  

        i = 0;  

    }  

    return i;  

    }  

  

    /** 

     * 转Double 

     *  

     * @param obj 

     * @return 相应的值 或 零 

     */  

    public static double objectToDouble(Object obj) {  

    String str = objectToString(obj);  

    double i = 0;  

    try {  

        i = Double.parseDouble(str.trim());  

    } catch (NumberFormatException e) {  

        i = 0;  

    }  

    return i;  

    }  

  

    /** 

     * 转Long 

     *  

     * @param obj 

     * @return 相应的值 或 零 

     */  

    public static long objectToLong(Object obj) {  

    String str = objectToString(obj);  

    Long li = new Long(0);  

    try {  

        li = Long.valueOf(str);  

    } catch (NumberFormatException e) {  

    }  

    return li.longValue();  

    }  

  

    // ***************** 其他类型相互转换 *****************  

  

    /** 

     * double转long 

     *  

     * @param d 

     * @return 只截取前面的整数 

     */  

    public static long doubleToLong(double d) {  

    long l = 0;  

    try {  

        // double转换成long前要过滤掉double类型小数点后数据  

        l = Long.parseLong(String.valueOf(d).substring(0,  

            String.valueOf(d).lastIndexOf(".")));  

    } catch (Exception e) {  

        l = 0;  

    }  

    return l;  

    }  

  

    /** 

     * double转int 

     *  

     * @param d 

     * @return 只截取前面的整数 

     */  

    public static int doubleToInt(double d) {  

    int i = 0;  

    try {  

        // double转换成Int前要过滤掉double类型小数点后数据  

        i = Integer.parseInt(String.valueOf(d).substring(0,  

            String.valueOf(d).lastIndexOf(".")));  

    } catch (Exception e) {  

        i = 0;  

    }  

    return i;  

    }  

  

    /** 

     * double转long(四舍五入) 

     *  

     * @param d 

     * @return 只截取前面的整数 (四舍五入) 

     */  

    public static long doubleToLongWhithRound(double d) {  

    long l = 0;  

    try {  

        l = Math.round(d);  

    } catch (Exception e) {  

        l = 0;  

    }  

    return l;  

    }  

  

    /** 

     * double转int(四舍五入) 

     *  

     * @param d 

     * @return 只截取前面的整数 (四舍五入) 

     */  

    public static int doubleToIntWhithRound(double d) {  

    int i = 0;  

    try {  

        i = (int) Math.round(d);  

    } catch (Exception e) {  

        i = 0;  

    }  

    return i;  

    }  

  

    public static double longToDouble(long d) {  

    double l = 0;  

    try {  

        l = Double.parseDouble(String.valueOf(d));  

    } catch (Exception e) {  

        l = 0;  

    }  

    return l;  

    }  

  

    public static int longToInt(long d) {  

    int l = 0;  

    try {  

        l = Integer.parseInt(String.valueOf(d));  

    } catch (Exception e) {  

        l = 0;  

    }  

    return l;  

    }  

} 

所有的包装类（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类型。

> 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.抽象方法没有方法体

    

            
欢迎大家关注笔者的微信公众号：JAVAandPython君
关注后发送“领取资料”即可领取5T技术资源
1
1.下面属于java包装类的是？
A.String
B.Long
C.Character
D.Short
分析：
   这应该是一个比较容易的题目了，但是也是得死记硬背的题，所以拿出来给大家记一记。 

   Java 语言是一个面向对象的语言，但是Java中的基本数据类型却是不面向对象的，这在实际使用时存在很多的不便，为了解决这个不足，在设计类时为每个基本数据类型设计了一个对应的类进行代表，即包装类。对应的基本类型和包装类如下表：






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错 抛出异常不一定是运行时异常，也有可能是编译时异常。这里甩给大家一张图：





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，如图：





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选项满足重写的各项条件，是正确的重写，所以插入第五行没有错误。