Java面向对象----封装类介绍、基本数据类型、封装类以及String类型之间的互相转化总结----含思维导图

一、封装类（包装类）

1、定义：封装对应基本数据类型的相关属性以及操作方法的类。

2、作用：让java更好的面向对象。

3、基本数据类型以及封装类：

基本数据类型	封装类（包装类）
byte	Byte
short	Short
int	Integer
long	Long
float	Float
double	Double
boolean	Boolean
char	Char

4、封装类中的方法：

方法名	含义
BYTES	获取其对应基本数据类型所占的字节数
SIZE	获取其对应基本数据类型所占的字节数
MAX_VALUE	获取其对应基本数据类型能表示数据的最大值
MIN_VALUE	获取其对应基本数据类型能表示数据的最大值

二、基本数据类型、封装类、String类型之间互相转换

（一）基本数据类型与String类型
    1、基本数据类型转String类型：
     (1) 通过字符串拼接基本数据类型: String str = “”+ 10086;
     (2) String类中的valueOf（基本数据类型）方法，String str = String.valueOf(10086);
     (3) 将基本数据类型转为封装类对象，通过封装类对象.toString();(不推荐）
    2、String类型转基本数据类型：
     (1) 通过对应封装类.parseXXX(String str);此时是直接转为基本数据类型，与valueOf()方法不一样。

String str = "123";

try {

    int a = Integer.parseInt(str);

} catch (NumberFormatException e) {

    e.printStackTrace();

}

     (2) 先通过封装类对象.valueOf(String sr)方法将字符串转为封装类对象;然后进行拆箱操作。

String str = "123";

try {

    int b = Integer.valueOf(str).intValue()

} catch (NumberFormatException e) {

    e.printStackTrace();

}

（二）基本数据类型与封装类型
    1、基本数据类型转封装类型：
     (1) 自动装箱：Integer i = 10;
     (2) 通过封装类的构造方法。例如：int i= 10；Integer a=new Integer(i);
     (3) 通过封装类.valueOf(基本数据类型)。
    2、封装类型转基本数据类型：
     (1) 自动拆箱类
     (2) 封装类对象.XXXvalue();
    补充：拆箱：将封装类对象自动转为基本数据类型；装箱:将基本数据类型自动转为封装类。
（三）封装类型与String
    1、封装类型转String类型：封装类对象.toString();
    2、String类型转封装类：通过封装类.valueOf(String str)

三、封装类实例之间比较运算符==与equals()方法的区别

1、等于（==） ：比较的是内存地址是否相同

  (1) 如果 == 运算符的两个操作数相等，计算结果为 true；否则计算结果为 false。
  (2) 如果操作数是基本类型，这个运算符测试两个操作数的值是否一样。
  (3) 如果操作数是引用类型，这个运算符测试两个操作数是否指向同一个对象或数组。
  (4) 如果使用 == 比较两个数字或字符，而且两个操作数的类型不同，在比较之前会把取值范围窄的操作数转换成取值范围宽的操作数类型。例如，比较short 类型的值和float 类型的值时，在比较之前会先把 short 类型的值转换成 float 类型。对浮点数来说，特殊的负零和普通的正零相等；特殊的NaN和任何数，包括NaN自己，都不相等。如果想测试浮点数是否为NaN，要使用Float.isNan() 或 Double.isNan() 方法。

2、equals()方法 ：String类型与封装类型都重写了equals()方法，比较的是内容是否相等，不是比较的内存地址

看一段如下样例代码：

	    Integer a = 1000;
		int b = 1000;
		System.out.println(a.equals(b)); // true
		
		Integer c = 100;
		int d = 100;
		System.out.println(c.equals(d)); // true

		Integer a1 = 1000;
		Integer a2 = 1000;
		System.out.println(a1.equals(a2)); // true

		Integer b1 = 100;
		Integer b2 = 100;
		System.out.println(b1.equals(b2)); // true

		Integer c1 = 100;
		Integer c2 = 100;
		System.out.println(c1 == c2); // true

		Integer d1 = 1000;
		Integer d2 = 1000;
		System.out.println(d1 == d2); // false
		
		Integer e1 = new Integer(1);
　　    Integer e2 = new Integer(1);
　　    System.out.println(e1 == e2); // false
　　    System.out.println(e1.equals(e2)); // true
		
        String str1 = "hello";
		String str2 = new String("hello");
		String str3 = "hello";
		System.out.println(str1 == str2); // false
		System.out.println(str1 == str3); // true
		System.out.println(str1.equals(str2)); // true

 (1) 分析上面代码：a1.equals(a2)与(b1.equals(b2)的输出结果
  ① Java中对Integer类型对象 采用 int类型字段赋值，实际采用的是vauleOf()方法。

 Integer.class中valueOf方法定义如下：       
　　　　public static Integer valueOf(int i) {
　　　　　　final int offset = 128;
　　　　　　if (i >= -128 && i <= 127) { // must cache
　　　　　　　　return IntegerCache.cache[i + offset];
　　　　　　}
　　　　　　return new Integer(i);
　　　　}
//**********************************************************************
IntegerCache.class中定义如下：　

　　　　static final Integer cache[] = new Integer[-(-128) + 127 + 1];
　　　　static {
　　　　　　for(int i = 0; i < cache.length; i++)
　　　　　　　　cache[i] = new Integer(i - 128);
　　　　　　}
　　}

  ② 通过如上方法可以看出，JDK编译器在程序运行时就把 -128~127 范围的数字预编译放进缓冲区。所以如下：
   A: c1 和 c2引用对象赋值，采用的是valueOf()方式，由于值<127，实际引用的是IntegerCache中的同一对象，所以== 比较为true。
   B: d1和 d2引用对象赋值，采用的是valueOf()方式，由于值>127，实际会分别通过new操作创建新的对象，所以== 比较为false。
   C: e1 和 e2引用对象直接采用new操作创建新的对象，内存地址不同，所以==比较为false。

四、思维导图