(一)
/**
- 包装类的作用:
-
使编程更加方便
- @author Administrator
*/
public class Test01 {
public static void main(String[] args) {
//调用方法, 只要是引用类型的数据就可以作为实参
m1("abc"); //实际上是把"abc"在常量池中的引用传递给obj参数
m1(123); //不能把基本类型数据传递给obj参数
/*
* 这儿没有语法错误, 是因为系统把基本类型123先转换为了对应的包装类对象, 再把包装类对象的引用传递给形参obj
*/
}
//obj是Object类型的引用, obj参数保存的是对象的引用(地址)
public static void m1( Object obj) {
}
}
(二)
public class Application {
public static void main(String[] args) {
// SpringApplication.run(Application.class, args);
System.out.println( Integer.SIZE); //32
System.out.println( Integer.BYTES); //4
System.out.println( Integer.MIN_VALUE); //-2147483648
System.out.println( Integer.MAX_VALUE); //2147483647
System.out.println( Integer.TYPE); //int
System.out.println( Boolean.TYPE);
System.out.println( Boolean.TRUE);
System.out.println( Boolean.FALSE);
System.out.println( Double.NaN);
System.out.println( Double.POSITIVE_INFINITY);
System.out.println( Double.NEGATIVE_INFINITY);
System.out.println( 10 / 0.0 ); //Infinity, 无穷大
System.out.println( -10 / 0.0 ); //-Infinity, 负无穷大
System.out.println( 0 / 0.0 ); //NaN, Not a Number
}
}
测试结果:
32
4
-2147483648
2147483647
int
boolean
true
false
NaN
Infinity
-Infinity
Infinity
-Infinity
NaN
Process finished with exit code 0
注意: System.out.println( 10 / 0 ); 输出会报异常:Exception in thread “main” java.lang.ArithmeticException: / by zero
(三)
/**
- 包装类的构造方法
-
1) 根据基本类型创建包装类对象
-
2) 根据字符串 创建包装类对象
- @author Administrator
*/
public class Test02 {
public static void main(String[] args) {
// 1) 根据基本类型创建包装类对象
Integer i1 = new Integer(123);
Double dd1 = new Double(45.78);
Boolean bb1 = new Boolean(true);
//2) 根据字符串 创建包装类对象
Integer i2 = new Integer("456123");
System.out.println( i2 );
//注意, 根据字符串创建包装类对象时, 字符串要符合数字的格式
// i2 = new Integer(“adfasf”); //java.lang.NumberFormatException
// i2 = new Integer(“3.14”); // java.lang.NumberFormatException
Double dd2 = new Double("45.78");
// dd2 = new Double(“adsf”); //java.lang.NumberFormatException:
dd2 = new Double(“456”);
//布尔类型比较特殊, 如果是"true"字符串会转换为true, 其他的字符串都转换为false
Boolean bb2 = new Boolean("true");
System.out.println( bb2 );
bb2 = new Boolean("trasdfaffdue");
System.out.println( bb2 );
bb2 = new Boolean( null );
System.out.println( bb2 );
}
}
输出结果:
456123
true
false
false
Process finished with exit code 0
(四)
public class Application {
/**
* 包装类的常用操作
* @author Administrator
*
*/
public static void main(String[] args) {
//1)包装类对象
Integer i1 = new Integer(456);
Integer i2 = new Integer("123");
//2) 从Number继承的方法, 可以把包装类对象转换为基本类型
byte bb = i2.byteValue();
double dd = i1.doubleValue();
System.out.println( bb );
System.out.println( dd );
bb = i1.byteValue(); //只把最后一个字节保存到bb变量中
System.out.println( bb ); //-56
//3)compareTo(Integer anotherInteger) 如果第一个对象大 返回正数, 参数对象大返回负数,相等返回0
//Comparable<T>接口,作用是比较当前对象与参数对象的大小 , 一个类实现了该接口,需要重写compareTo()
//Comparable<T>接口中的<T>是泛型(把数据类型当作参数), 指定参数对象的数据类型
//Integer对象比较大小是根据value字段的值比较大小
//每个包装类都有一个value字段, 保存对应的基本类型的值
System.out.println( i1.compareTo(i2) ); //1
Boolean b1 = new Boolean(true);
Boolean b2 = new Boolean("afda");
System.out.println( b1.compareTo(b2)); //1
//4)equals(Object obj) ,判断两个对象的是否相等,根据基本类型的value值判断是否相等
System.out.println( i1.equals(i2) );
System.out.println( b1.equals(b2) );
//5)parseInt(String s) 可以把字符串转换为基本类型的数据
int xx = Integer.parseInt("7894");
System.out.println( xx );
// xx = Integer.parseInt(“7.894”); // java.lang.NumberFormatException:
double dd3 = Double.parseDouble(“45.123”);
System.out.println(dd3);
boolean flag = Boolean.parseBoolean(“qerreqe”);
System.out.println( flag ); //false
//6)把整数转换为二进制,八进制,十六进制
System.out.println( Integer.toBinaryString(100));
System.out.println( Integer.toOctalString(100));
System.out.println( Integer.toHexString(100));
//7)valueOf(int i) /valueOf(String s) 把基本类型/字符串 转换为包装类对象
i1 = Integer.valueOf( 258);
i2 = Integer.valueOf("369");
System.out.println(i1);
System.out.println(i2);
dd3 = Double.valueOf(3.14);
dd = Double.valueOf("456.789");
}
}
输出结果
123
456.0
-56
1
1
false
false
7894
45.123
false
1100100
144
64
258
369
Process finished with exit code 0
(五)
/**
- int , String, Integer相互转换
- @author Administrator
*/
public class Test05 {
public static void main(String[] args) {
int num = 123;
//1) int-->String
String text = "" + num; //字符串与基本类型连接,先把基本类型转换为字符串再连接
// "" + "123"
text = String.valueOf(num);
text = Integer.toString(num);
//2) String --> int
num = Integer.parseInt(text);
//3) int --> Integer
Integer i1 = new Integer(num);
i1 = Integer.valueOf(num);
i1 = num; //Java可以自动的把基本类型转换为包装类对象
//4) Integer--> int
num = i1.intValue();
num = i1; //Java可以自动的把包装类对象转换为基本类型数据
//5) Integer-->String
text = i1.toString();
//6) String-->Integer
i1 = new Integer(text);
i1 = Integer.valueOf(text);
}
}
(六)
/**
- 装箱
-
把基本类型转换为包装类对象
- 拆箱
-
把包装类对象转换为基本类型
- 在Java中,可以自动的装箱与拆箱
- @author Administrator
*/
public class Test06 {
public static void main(String[] args) {
Integer i1 = 456; //自动装箱
Integer i2 = 456; //根据基本类型456创建一个包装类对象
System.out.println( i1 == i2 ); //false 包装类是引用类型
System.out.println( i1.equals(i2)); //true
i1 = 123; //根据基本类型123创建一个包装类对象
i2 = 123;
System.out.println( i1 == i2 ); //true
/*
* Java认为-128~127之间的整数是最常用的整数
* 在这个范围内的整数自动装箱后,生成的包装类对象存储方法区的共享池中
* i1 = 123; 会创建一个包装类对象保存到方法区的常量池中
* 再执行i2 = 123; 时, 就直接把常量池中的包装对象的 引用赋值给i2
*/
Long gg1 = 99L;
Long gg2 = 99L;
System.out.println( gg1 == gg2 ); //true
}
}