Object类常用方法和包装类

equals()

’==‘ 和 equals()的区别

’==‘ 运算符

1. 可以使用在基本数据类型变量和引用数据类型变量中
2. 如果比较的是基本数据类型，比较两个变量保存的数据是否相等。（不一定类型相同）
   如果比较的是引用数据类型，比较两个对象的内存地址值是否相等。

equals()方法的使用
3. 是一个方法，而非运算符
4. 只能适用于引用数据类型
5. Object类中equals()的定义和’==‘作用相同
6. 像String,Data,File,包装类等都重写了Object类中的equals()的方法，重写后就不再是对比内存地址值，而是比较两个对象的”实体内容“是否相等

实例代码：

public class test {
    public static void main(String[] args){
        String s="111";
        String s1="111";
        String s2=new String("3333");
        String s3=new String("4444");
        int i=1;
        int i1=2;
        Dog d=new Dog();
        Dog d1=new Dog();
        System.out.println(s == s1);
        System.out.println(s2 == s3);
        System.out.println(i == i1);
        System.out.println(d == d1);
        System.out.println(s.equals(s1));
        System.out.println(s2.equals(s3));
        System.out.println(d.equals(d1));
    }
}
/*输出结果为：
true
false
false
false
true
false
false
*/

重写equals()

在日常使用过程中，我们在自定义类中使用equals()方法通常是为了比较两个对象的“实体内容”是否相等，这时候，我们就要对Object类的equals()进行重写

public class test {
    public static void main(String[] args){
        Person p=new Person(20,1111);
        Person p1=new Person(20,1111);
        Person p2=new Person(22,2222);
        System.out.println(p.equals(p1));
        System.out.println(p.equals(p2));
    }
}

class Person{
    int age;
    long id;
    public Person(int age,int id){
        this.age = age;
        this.id = id;
    }
    //重写equals()方法
    public boolean equals(Object obj){
        //判断内存地址是否相同
        if (this == obj){
            return true;
        }
        if (obj instanceof Person){
            Person person = (Person)obj;
            if (this.age == person.age && this.id == person.id){
                return true;
            }
        }
        return false;
    }
}
/*输出结果为：
true
false
*/

toString

Object类中toString()的使用

1. 当我们输出一个对象的引用时，实际上就是调用了当前对象的toString
2. 像String,Data,File,包装类等都重写了toString方法
3. 自定义类也可以重写toString的方法

代码实例：

public class test {
    public static void main(String[] args){
        Person p=new Person(20,1111);
        System.out.println(p.toString());
    }
}

class Person{
    int age;
    long id;
    public Person(int age,int id){
        this.age = age;
        this.id = id;
    }
    //重写toString方法
    public String toString(){
        return "Person[age="+this.age+",id="+this.id+"]";
    }
}
/*输出结果为：
Person[age=20,id=1111]
*/

Java中的JUnit单元测试

步骤:

1. 选中当前工程-右键选择: build path - add libraries - JUnit 4 -下- 步
2. 创建Java类，进行单元测试。
   此时的Java类要求: ①此类是public的 ②此类提供公共的无参的构造器
3. 此类中声明单元测试方法。
   此时的单元测试方法:方法的权限是public ,没有返回值，没有形参
4. 此单元测试方法上需要声明注解: @Test,并在单元测试类中导入: import org.junit. Test;
5. 声明好单元测试方法以后，就可以在方法体内测试相关的代码。
6. 写完代码以后，左键双击单元测试方法名，右键: run as - JUnit Test

说明：

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

在实际开发过程中，可以直接使用@test然后点击IDE的错误提示让其进行自动修正

包装类

在Java中，基本数据类型无法体现面向对象，而使用包装类，便可以使其拥有类的特点，调用类中的方法。

基本数据类型，包装类，String之间的相互转化

在JDK 5.0的时候加入了一个新特点：自动装箱与自动拆箱

//自动装箱:基本数据类型--->包装类
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)

public void test(){
	int num1 =10;
	//方式1:连接运算
	String str1 = num1 + "";
	//方式2:调用String的valueOf(Xxx xXx )
	float f1 = 12.3f;
	String str2 = String.value0f(f1);//"12.3"

	Double d1 = new Double(12.4);
	String str3 = String.valueOf(d1);
	System.out.println(str2);
	System.out.println(str3);//"12.4"
}

不论是基本数据类型还是包装类都可以使用方式2

string类型—>基本数据类型、包装类:调用包装类的parseXxx()

String s=new String("123");
int num=Integer.parseInt(s);

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;
Integer y = 128;
System. out.println(x == y);//false