Java语言基础学习Object类和包装类

一、java.lang.Object类

1.Object类是所有Java类的根父类

2.如果在类的声明中未使用extends关键字指明其父类，则默认父类为java.lang.Object类

例：method(Object obj){…} //可以接收任何类作为其参数 Person o=new Person(); method(o);

public class Person { ...

}

//等价于：

public class Person extends Object {

...

}

3.Object类中的功能(属性、方法)就具有通用性。

* 属性：无

* 方法：equals() 、toString() 、getClass() 、hashCode() 、clone() 、finalize()、wait() 、 notify()、notifyAll()

finalize()----->垃圾回收机制回收任何对象之前，总会先调用它的finalize方法。永远不要主动调用某个对象的finalize方法，应该交给垃圾回收机制调用。

4. Object类只声明了一个空参的构造器。

二、Object 类的使用-toString() 方法

当我们输出一个对象的引用时，实际上就是调用当前对象的toString()。输出的具体信息看toString()方法体内容。Date date=new Date(); System.out.println(“now=”+date); 相当于 System.out.println(“now=”+date.toString());

Object类中toString()的定义：toString()方法在Object类中定义，其返回值是String类型，返回类名和它的引用地址。

//Object类中toString()的定义：

public String toString() {

return getClass().getName() + "@" + Integer.toHexString(hashCode());

}

Customer cust1 = new Customer("Tom",21);

System.out.println(cust1.toString());//com.atguigu.java1.Customer@15db5225

System.out.println(cust1);//com.atguigu.java1.Customer@15db5225

public void println(Object x) {

String s = String.valueOf(x);

synchronized (this) {

print(s);

newLine();

}

public static String valueOf(Object obj) {

return (obj == null) ? "null" : obj.toString();

}

在进行String与其它类型数据的连接操作时，自动调用toString()方法 Date now=new Date(); System.out.println(“now=”+now); 相当于 System.out.println(“now=”+now.toString());

像String、Date、File、包装类等都重写了Object类中toString()方法。使得在调用对象的toString()时，返回"实体内容"信息。

可以根据需要在用户自定义类型中重写toString()方法 如String 类重写了toString()方法，返回字符串的值。 s1=“hello”;System.out.println(s1);//相当于System.out.println(s1.toString());

基本类型数据转换为String类型时，调用了对应包装类的toString()方法 int a=10; System.out.println(“a=”+a);

三、 Java中的JUnit单元测试

步骤：

1.选中当前工程 - 右键选择：build path - add libraries - JUnit - 下一步

2.创建Java类，进行单元测试。

* 此时的Java类要求：① 此类是public的 ②此类提供公共的无参的构造器(默认)。

3.此类中声明单元测试方法。

* 此时的单元测试方法：方法的权限是public,没有返回值，没有形参

4.此单元测试方法上需要声明注解：@Test,并在单元测试类中导入：import org.junit.Test;

5.声明好单元测试方法以后，就可以在方法体内测试相关的代码。

6.写完代码以后，左键双击单元测试方法名，右键：run as - JUnit Test。每个单元测试方法是独立的。

public class JUnitTest {//JunitTest单元测试类名

public void test(){//test单元测试方法名

}

说明：

1.如果执行结果没有任何异常：绿条

2.如果执行结果出现异常：红条

四、包装类的使用

针对八种基本数据类型定义相应的引用类型—包装类（封装类）

有了类的特点，就可以调用类中的方法，Java才是真正的面向对象。

装箱：包装类使得一个基本数据类型的数据变成了类。

有了类的特点，可以调用类中的方法。

int i = 500;

Integer t = new Integer(i);

String s = t.toString(); // s = “500“,t是类，有toString方法

String s1 = Integer.toString(314); // s1= “314“ 将数字转换成字符串。

String s2=“4.56”;

double ds=Double.parseDouble(s2); //将字符串转换成数字

拆箱：将数字包装类中内容变为基本数据类型。

int i = 500;

Integer t = new Integer(i);

int j = t.intValue(); // j = 500，intValue取出包装类中的数据

包装类在实际开发中用的最多的在于字符串变为基本数据类型。

String str1 = "30" ;

String str2 = "30.3" ;

int x = Integer.parseInt(str1) ; // 将字符串变为int型

float f = Float.parseFloat(str2) ; // 将字符串变为int型

基本数据类型 --->包装类：调用包装类的构造器

//基本数据类型 --->包装类：调用包装类的构造器

@Test

public void test1(){

int num1 = 10;

// System.out.println(num1.toString());

Integer in1 = new Integer(num1);

System.out.println(in1.toString());

Integer in2 = new Integer("123");

System.out.println(in2.toString());

//报异常

// Integer in3 = new Integer("123abc");

// System.out.println(in3.toString());

Float f1 = new Float(12.3f);

Float f2 = new Float("12.3");

System.out.println(f1);

System.out.println(f2);

Boolean b1 = new Boolean(true);

Boolean b2 = new Boolean("TrUe");

System.out.println(b2);//false

Boolean b3 = new Boolean("true123");

System.out.println(b3);//false

Order order = new Order();

System.out.println(order.isMale);//false初始默认值

System.out.println(order.isFemale);//null

}

class Order{

boolean isMale;

Boolean isFemale;

}

包装类--->基本数据类型:调用包装类Xxx的xxxValue()

@Test

public void test2(){

Integer in1 = new Integer(12);

int i1 = in1.intValue();

System.out.println(i1 + 1);

Float f1 = new Float(12.3);

float f2 = f1.floatValue();

System.out.println(f2 + 1);

}

自动装箱（类型必须匹配）：基本数据类型 --->包装类

//自动装箱：基本数据类型 --->包装类

int num2 = 10;

Integer in1 = num2;//自动装箱

boolean b1 = true;

Boolean b2 = b1;//自动装箱

自动拆箱（类型必须匹配）：包装类--->基本数据类型

System.out.println(in1.toString());

int num3 = in1;//自动拆箱

基本数据类型、包装类--->String类型：调用String重载的valueOf(Xxx xxx)

@Test

public void test4(){

int num1 = 10;

//方式1：连接运算

String str1 = num1 + "";

//方式2：调用String的valueOf(Xxx xxx)

float f1 = 12.3f;

String str2 = String.valueOf(f1);//"12.3"

Double d1 = new Double(12.4);

String str3 = String.valueOf(d1);

System.out.println(str2);//”12.3”

System.out.println(str3);//"12.4"

}

String类型 --->基本数据类型、包装类：调用包装类的parseXxx(String s)

@Test

public void test5(){

String str1 = "123";

//错误的情况：

// int num1 = (int)str1;

// Integer in1 = (Integer)str1;

//可能会报NumberFormatException

int num2 = Integer.parseInt(str1);

System.out.println(num2 + 1);

String str2 = "true1";

boolean b1 = Boolean.parseBoolean(str2);

System.out.println(b1);//false(不是true都返回false)

}

面试题：

@Test

public void test1() {

Object o1 = true ? new Integer(1) : new Double(2.0);

System.out.println(o1);//1.0（自动类型提升，编译时要统一类型所以Integer会自动转换成Double类型。

}

@Test

public void test2() {

Object o2;

if (true)

o2 = new Integer(1);

else

o2 = new Double(2.0);

System.out.println(o2);// 1

}

@Test

public void test3() {

Integer i = new Integer(1);

Integer j = new Integer(1);

System.out.println(i == j);//false

//Integer内部定义了IntegerCache结构，IntegerCache中定义了Integer[],

保存了从-128~127范围的整数。如果我们使用自动装箱的方式，给Integer赋值的范围在-128~127范围内时，可以直接使用数组中的元素，不用再去new了。目的：提高装箱效率

Integer m = 1;

Integer n = 1;

System.out.println(m == n);//true

Integer x = 128;//相当于new了一个Integer对象

Integer y = 128;//相当于new了一个Integer对象

System.out.println(x == y);//false

}