五（十一）、Object 类、Equals方法、toString方法、包装类、Junit

java.lang,Object类
1.Object类是所有java类的根父类
2.如果在类的声明中未使用extends关键字指明其父类，则默认父类为 java.lang.Object类
Object中的功能（属性、方法）就具有通用性；
4.Object类只声明一个空参构造器

Equals：

面试题： == 和 equals()的区别
  一、
          ==：运算符，可以使用基本数据类型变量和引用数据变量中;
                    如果比较的是基本数据变量，比较两个变量报错的数据是否相等（不一定类型要相同）；
                    如果比较的是引用数据类型变量，比较的是地址值，即两个引用是否指向同一个对象实体；
          equals：
                  是方法；而非运算符，通过对象来调用；
                  object类中对equals()的定义 与 “==” 作用是相同的；比较两个对象的地址值是否相同，即啷个引用是否指向同一个实体；
              像String ,Date File 包装类等都重写了Object类中的equals()方法，重写以后，比较的不是两个引用的地址值是否相同，
              而是比较两个对象的“实体内容”。
          通常情况下，我们自定义的类如果使用equals()的话，也通常比较两个对象的“实体内容”是否相同，那么我们就需要对Object类中的
          equals()进行重写；

以下手动重写equals方法：

class Person1{
    private String name;
    private int age;
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    
    public void eat() {
        System.out.println("人吃饭。。。。");
        study();
    }
    
    public void study() {
        System.out.println("学习。。。");
    }
    public Person1(String name, int age) {
        //super();
        this(age);
        this.name = name;
        //this.age = age; //等同于 this("Tome");
    }
    public Person1() {
        super();
    }
    public Person1(String name) {
        this();//调用当前的空参构造器
        //super();
        this.name = name;
        
    }
    public Person1(int age) {
        //super();
        this.age = age;
    }
//    @Override //手写部分
//    public boolean equals(Object obj) {
//        if(this == obj) {
//            return true;
//        }else if(obj instanceof Person1) {
//            Person1 p = (Person1)obj;
//            if(name.equals(p.name) && age == p.age) {
//                return true;
//            }else {
//                return false;
//            }
//        }else {
//            return false;
//        }
//    }
    @Override
    public int hashCode() {
        final int prime = 31;
        int result = 1;
        result = primeresult + age;
        result = primeresult + ((name == null) ? 0 : name.hashCode());
        return result;
    }
//代码自动生成的equals
    @Override
    public boolean equals(Object obj) {
        if (this == obj)
            return true;
        if (obj == null)
            return false;
        if (getClass() != obj.getClass())
            return false;
        Person1 other = (Person1) obj;
        if (age != other.age)
            return false;
        if (name == null) {
            if (other.name != null)
                return false;
        } else if (!name.equals(other.name))
            return false;
        return true;
    }
    
    
}

    public static void main(String[] args) {
        int i = 10;
        int j = 10;
        double d = 10.0;
        char c = 10;
        System.out.println(i == j);//true
        System.out.println(i == d);//true
        System.out.println(c == i);//true
        
        Person1 person1 = new Person1("Tom", 11);
        Person1 person2 = new Person1("Tom", 11);
        
        
        System.out.println(person1 == person2);//false
        System.out.println(person1.equals(person2));//false重写前，重写后是true;
    }

toString()方法：

Object类中tostring()的使用
1.当我们输出一个对象的引用是，实际上调用的是当前对象的toString();
2.Object的定义：
         public String toString() {
            return getClass().getName() + "@" + Integer.toHexString(hashCode());
        }
    3. String Date File 包装类等都重写过toString()方法，使得在调用对象的实体时，返回“实体信息”；
    4.自定义类也可以重写toString()方法，一般默认生成即可
    5.对象.toString();如果对象是null 则报错 空指针异常；

Junit单元测试：

Java中的JUnite单元测试
  步骤：1.选中当前工程 右键选择bulidpath   add libraries -- JUnite 5 - finish;
          2.创建Java类，进行单元测试；此类是public 此类提供公共的无参构造器
          3.此类中声明单元测试方法：
              权限是public  没有返回值  没有形参；
              需要@Test注解，
              在单元测试类中导入 import org.junit.Test
          4.声明好单元测试方法以后，就可以在方法体内测试相关代码；
          5.写完代码以后，左键双击方法名，右键：run as  JUnite Test
  说明：
  1.如果执行结构没有任何异常，绿条
  2.如果执行结果出现异常，红条

包装类：

包装类的使用
  1.java提供了8种基本数据类型对应的包装类，使得基本数据类型的变量具有类的特征；
  2.基本数据类型 包装类 string 三者之间的转换；

//基本数据类型 --》 包装类：调用包装类的构造器
    @Test 
    public void test1() {
        int num1 = 10;
        Integer in1 = new Integer(num1);
        System.out.println(in1.toString());
        Float f1 = new Float(12.3);
        Double d1 = new Double(12.3);
        Boolean b1 = new Boolean(true);
        Boolean b2 = new Boolean("true");
        Boolean b3 = new Boolean("true123");
        System.out.println(b3);//false
    }
    //包装类--》 基本数据类型 ：调用包装类的 xxxValue();
    @Test 
    public void test2() {
        int num1 = 10;
        Integer in1 = new Integer(num1);
        int num2 = in1.intValue();
        System.out.println(num2+1);
        Float f1 = new Float(12.3);
        float f2 = f1.floatValue();
        System.out.println(f2);//false
    }
    //自动装箱 与 自动拆箱
    @Test 
    public void test3() {;
        int num = 10;
        Integer in1 = num;//自动装箱
        int num1 = in1;//自动拆箱；
        method(num);
    }
    //基本数据类型 包装类 --》String; 调用String重载的valueOf(Xxx xxx);
    @Test 
    public void test4() {
    //方式一
        int num = 10;
        String str = num+"";
        //方式二
        str = String.valueOf(num);
        
    }
    // String--》基本数据类型 包装类; 包装类的parseXXX();
    @Test 
    public void test5() {
        String str = "123";
        //可能会出现 numberformate 异常
        Integer in1 = Integer.parseInt(str);
        String str1 = "true";
        Boolean b1 = Boolean.parseBoolean(str1);
        
        
    }
    public void method(Object obj) {
        System.out.println(obj);
    }