基本包装类型
1、自定义一个int类型的包装类
package f基本数据类型的包装类初识;
public class MyInt {
int value;
public MyInt() {
super();
}
public MyInt(int value) {
super();
this.value = value;
}
@Override
public String toString() {
// TODO 自动生成的方法存根
return String.valueOf(value);
}
}
2、基本数据类型的包装类
package f基本数据类型的包装类初识;
/*
* 1、Java中为8种基本数据类型准备了8种对应的包装类。8种包装类属于引用数据类型，父类是Object
* 2、实际的应用开发中不需要自己建这8中包装类，SUN公司已经帮我们写好了
*
* 八种基本数据类型类型所对应的包装类
* 基本数据类型 包装类型
* ------------------------------------------
* byte java.lang.Byte(父类Number)
* short java.lang.Short(父类Number)
* int java.lang.Integer(父类Number)
* float java.lang.Float(父类Number)
* double java.lang.Double(父类Number)
* boolean java.lang.Boolean(父类Object)
* char java.lang.Character(父类Object)
* 八种包装类中重点代表是java.lang.Integer，其他的与其类似，照葫芦画瓢
*/
public class IntegerTest {
public static void main(String[] args) {
//有时候调用doSome方法的时候需要传一个数字进去
//数字属于基本数据类型，而doSome()中的参数类型属于引用数据类型Object
//那么看起来doSome()方法是无法接收基本数据类型的，如何解决呢？可以传一个该数字对应的一个包装类进去
doSome(100);
//自己定义了一个MyInt类，现在把100经过构造方法包装成对象
MyInt myInt = new MyInt(100);
//doSome()按道理不能传一个100数字进去，把100包装，传一个100对应的包装类
doSome(myInt);//f基本数据类型的包装类初识.MyInt@1edf1c96--由于100的包装类MyInt中的toString方法没有重写，所以输出该对象的地址
//100--重写toString后可输出100
}
public static void doSome(Object obj) {
// TODO 自动生成的方法存根
System.out.println(obj);
}
}
3、包装类的拆箱和装箱
package g装箱和拆箱的概念;
/*
* 八种包装类型中有里有六个是数字对应的包装类，他们的父类都是Number，研究Number中公共的方法：
* 可以发现Number类是一个抽象类，无法被实例化
* byte byteValue() 以 byte 形式返回指定的数值。
* abstract double doubleValue() 以 double 形式返回指定的数值。
* abstract float floatValue() 以 float 形式返回指定的数值。
* abstract int intValue() 以 int 形式返回指定的数值。
* abstract long longValue() 以 long 形式返回指定的数值。
* short shortValue() 以 short 形式返回指定的数值。
* 这些方法所有的子类包装类都有，这些方法负责拆箱
*
*/
public class IntegerTest {
public static void main(String[] args) {
//利用Integer包装类的构造方法将123从基本数据类型向引用数据类型
Integer integer = new Integer(123);//基本数据类型-->引用数据类型(称之为装箱)
//引用数据类型 -->基本数据类型(称之为拆箱)
float f = integer.floatValue();//floatValue方法是Integer重写其父类Number中将引用数值转换为float类型
System.out.println(f);//123.0
int i = integer.intValue();//返回int、short、byte、long、float、double类型字段的方法都有
System.out.println(i);//123
}
}
4、Integer的构造方法
package hInteger的构造方法;
public class IntegerTest {
public static void main(String[] args) {
//在idea中Integer出现横线说明该类过时了
//所以JDK版本9及以后不建议使用该类
Integer x = new Integer(133);//将数字133转换成Integer包装类型
Integer y = new Integer("133");//将String类型的数字133装换成Integer包装类型
System.out.println(x+"\n"+y);
//同样的，其他包装类类似
Double m = new Double(133);//将数字133转换成Integer包装类型
Double n = new Double("133.0");//将String类型的数字133装换成Integer包装类型
System.out.println(m+"\n"+n);
/*
* 包装类中有几个常量，是其对应的基本数据类型的最大值和最小值等
*/
//通过访问包类的常量获取最大值最小值
System.out.println("int类型最大值："+Integer.MAX_VALUE);
System.out.println("int类型最小值："+Integer.MIN_VALUE);
System.out.println("byte类型最大值："+Byte.MAX_VALUE);
System.out.println("byte类型最小值："+Byte.MIN_VALUE);
}
}
5、包装类的自动装箱和拆箱
package i包装类的自动装箱和拆箱;
/*
* 自动装箱：基本数据类型自动转换成包装类型
* 自动拆箱：包装类型自动转换成基本数据类型
* 有了自动拆箱后，Number中方法就用不着了
* 好处：
* 就是方便编程，比如说调用方法要传的参数是Object引用类型，把一个基本数据类放进去会将其自动装箱
* 就不需要手动的new对象装箱了，但这必须是在JDK1.5以后的版本才行
*/
public class IntegerTest01 {
public static void main(String[] args) {
//在JDK1.5以后的版本中包装类支持自动装箱和拆箱
Integer xInteger = 100;//int类型--->自动转换为 Integer包装类，自动装箱，不用显示的new对象了
int yInt = xInteger;//自动拆箱
//+作加号时两边要求是基本数据类型，xInteger是包装类型，此时自动拆箱转换成基本数据类型，不会报错
System.out.println(xInteger + 1);//101
Integer a = 1000;
Integer b = 1000;
//==比较的两个对象的内存地址，此时不会触发自动拆箱机制
System.out.println(a == b);//false
System.out.println(a.equals(b));//true
}
}
package i包装类的自动装箱和拆箱;
public class IntegerTest02 {
public static void main(String[] args) {
//分析以下程序
Integer a = 128;
Integer b = 128;
System.out.println(a == b);//false
/*
* 上下程序输出不一样，为什么？
* Java中为了提高程序的执行效率，将[-128-127]之间所有的包装对象提前创建好放到了方法区中
* 的整数型常量池中了，当用到该区间的整数时直接从常量池中取出，就不需要new包装类对象了。整数型常量池中的每一个整数
* 对象都有自己内存地址，并且唯一，就跟字符串常量池中的一样
*/
//127这个包装类在整数常量池中，所以x和y所存第地址是一样的
//类加载阶段执行将这256个基本数据类型的包装类对象创建出来放进整数常量池中
//池，cache，缓存机制；就是已经准备好了的已经放在那存在了的意思，用的时候拿来就能用了
Integer x = 127;
Integer y = 127;
System.out.println(x == y);//true
}
}
public static main(String[] args){
Integer i1 = new Integer(1);
Integer i2 = new Integer(1);
System.out.println(i1==i2)//false -->记住任何用关键字new出来的对象都是存储到堆中的，两个对象内存地址一 定不同
Integer i3 = 126;
Integer i4 = 126;
int i5 = 126;
System.out.println(i3==i4)//true -->两边都是包装类型时==不会触发自动拆装箱机制两个都是对象类型（包装 类），但是java中把-127-128范围的基本数据类型的包装类封装到了方法区中的常 量池中了，做了一个缓存，所以这两个引用存储的的都是常量池中的包装类对象
System.out.println(i3==i5)//true -->==有一边是基本数据类型可以做自动拆箱处理
Integer i6 = 128;
Integer i7 = 128;
int i8 = 128;
System.out.println(i6==i7)//false -->不在-127-128范围，是两个存储在堆中的两个对象，地址不同
System.out.println(i6==i8)//true -->自动拆箱
}
6、数字格式化异常
package j数字格式化异常;
/*
* 所学过的经典异常：
* 空指针异常：NullPointException
* 类型转换异常：ClassCastException
* 数组下标越界异常：ArrayIndexOutOfBoundsEception
* 数字格式化异常：NumberFormatException
*/
public class ExceptionTest {
public static void main(String[] args) {
//手动装箱
Integer x = new Integer(1000);
//手动拆箱
int y = x.intValue();
System.out.println(y);
//放字符串进去至少得是数字字符串
Integer d = new Integer("565656");
//以下代码编译没有问题，符合Java语句语法，Integer有传字符串进去的构造方法
//但是运行时会报异常java.lang.NumberFormatException
//Integer a = new Integer("中国人");
}
}
7、Integer中的常用方法
package kInteger常用方法;
public class IntegerTest {
public static void main(String[] args) {
/*
* 重要方法
* static int parseInt(String s)
* 静态方法，传参String，返回int类型
* 就比如在网页文本框中输入的100实际上是"100".要传到后台存储到数据库中的必须是100数字，此时
* java程序需要将字符串"100"转换成100数字
*/
//当然字符串只能是数字的字符串，不然会报数字格式化异常NumberFormatException
//要想语句遇到异常能继续执行下面的代码，就捕获异常
try {
int getValue = Integer.parseInt("123456");//String -->转换 int
System.out.println(getValue+1222);//124678
int getValue2 = Integer.parseInt("zhkjh");//String -->转换 int
System.out.println(getValue+1222);//124678
} catch (Exception e) {
// TODO: handle exception
System.out.println("捕获到异常"+e);//捕获到异常java.lang.NumberFormatException: For input string: "zhkjh"
}
int getValue = Integer.parseInt("123456");//String -->转换 int
System.out.println(getValue+1222);//124678
//同样的，其他包装类中也有该方法
double retValue = Double.parseDouble("3.125");
System.out.println(retValue+1000);
//--------------------以下方法仅需了解------------------------------------------------
/*
* static String toBinaryString(int i)
* 静态的：将十进制转换成二进制的字符串
*/
System.out.println(Integer.toBinaryString(56));//111000
/*
* static String toHexString(int i)
* 以十六进制无符号（前面没有0x）整数形式返回 int 参数的字符串表示形式。
* 16进制：1,2,3,4,5,6,7,8,9,a,b,c,d,e,f,10,11,12,13,14,15,16,17,18,19,1a
* 满16进1
*/
System.out.println(Integer.toHexString(26));//1a
/*
* static String toOctalString(long i)
* 以八进制无符号（前面没有0）整数形式返回 long 参数的字符串表示形式。
*/
System.out.println(Integer.toOctalString(8));//10
//Object中的toString方法如下
/*
public String toString() {
return getClass().getName() + "@" + Integer.toHexString(hashCode());
}
*/
//hashCode方法将地址转换成int，toHexString再将其转成16进制以字符串返回
Object a = new Object();
System.out.println(a);//java.lang.Object@7dc5e7b4
}
}
8、String、int和Integer的相互转换
package lString和int和Integer相互转换;
public class Test {
public static void main(String[] args) {
//String-->int: Integer.parseInt(s)
System.out.println(Integer.parseInt("123456"));
//String-->Integer: Integer.valueOf(s)
System.out.println(Integer.valueOf("4565"));
Integer a = new Integer("1566");//底层也是调用Integer.valueOf(s)
//int-->String: 1、数字+"";2、String.valueOf(i)
System.out.println(15 + "456");
System.out.println(String.valueOf(1232656));
//int-->Integer: 1、Integer.valueOf(i)；2、自动装箱
Integer b = new Integer(465);//老方法，淘汰，底层调用Integer.valueOf(i)
Integer c = Integer.valueOf(155);//与上面一样，只不过直接点，淘汰
Integer d = 465;//自动装箱
//Integer-->String: 1、String.valueOf(e)
Integer e = 4898;
System.out.println(String.valueOf(e));
//Integer-->int: 1、自动拆箱；2、intValue()
Integer f = 44;
System.out.println(f + 56);//100,自动拆箱，自动调用intValue方法
int g = f.intValue();//成员方法，对象的引用.调用
}
}
