一、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
}