java学习笔记21

 Object类
 1 Object是所有类的根类，任何一个类都继承他
 2 常用方法
    API 应用程序编程接口
 toString()方法：
 1 默认实现：类名@对象的内存地址转换为十六进制的形式
 2 目的：返回对象的字符串表示形式
 3 建议所有的子类都去重写toString()方法

public class test1()
{
   public static void main(String[] args)
   {
       MyTime t1=new MyTime(1970,1,1);
       String s1=t1.toString();
       System.out,println(s1);
       System.out.println(s1.toString);
   }
}
class MyTime
{
    int year;
    int month;
    int day;
    public MyTime()
    {}
    public MyTime(int year,int month,int day)
    {
         this.year=year;
         this.month=month;
         this.day=day;
    }
    //重写toString方法
    public String toString()
    {
       return this.year+"年"+this.month+"月"+this.day+"日";
    }
}
//println源码中有toString方法

equals方法：

public class Demo02Equals {
    public static void main(String[] args) {
        /*
            Person类默认继承了Object类,所以可以使用Object类的equals方法
            boolean equals(Object obj) 指示其他某个对象是否与此对象“相等”。
            equals方法源码:
                public boolean equals(Object obj) {
                    return (this == obj);
                }
                参数:
                    Object obj:可以传递任意的对象
                    == 比较运算符,返回的是一个布尔值 true false
                    基本数据类型:比较的是值
                    引用数据类型:比价的是两个对象的地址值
               this是谁?那个对象调用的方法,方法中的this就是那个对象;p1调用的equals方法所以this就是p1
               obj是谁?传递过来的参数p2
               this==obj -->p1==p2
         */
        Person p1 = new Person("迪丽热巴",18);
        //Person p2 = new Person("古力娜扎",19);
        Person p2 = new Person("迪丽热巴",18);
        System.out.println("p1:"+p1);//p1:com.itheima.demo01.Object.Person@58ceff1
        System.out.println("p2:"+p2);//p2:com.itheima.demo01.Object.Person@7c30a502

        //p1=p2;//把p2的地址值赋值给p1
        ArrayList<String> list = new ArrayList<>();

        boolean b = p1.equals(p1);
        System.out.println(b);
    }
}
 

重写Object类的equals方法

/*
   Object类的equals方法默认比较的是两个对象的地址值
   重写使他比较属性
   问题：隐含着一个多态
   多态：无法使用子类特有方法
   解决：向下转型
*/
public boolean equals(Object obj)
{
//如果是本身
if(obj==this)
{ 
    return true;
}
//增加一个判断，如果传递的参数是null，返回false，空值异常
if (obj==null)
{
    return false;
}
/*
    增减一个判断，是Person类型在转换，防止类型转换异常
*/
if(obj instanceof Person){
   Person p=(Person)obj;
   boolean b=this.name.equals(p.name)&&this.age.equals(p.age);}
   else
   {
      return false;
   }
}

Objects的equals方法
在JDK7添加了一个Objects工具类，它提供了一些方法来操作对象，它由一些静态的实用方法组成，这些方法是null-save（空指针安全的）或null-tolerant（容忍空指针的），用于计算对象的hashcode、返回对象的字符串表示形式、比较两个对象。
在比较两个对象的时候，Object的equals方法容易抛出空指针异常，而Objects类中equals方法就优化了这个问
题。
总结
1 Object类
（1） 是所有类的父类
（2） 提供了一些非常常用的方法
2 toString()方法
作用：打印对象信息
重写前打印地址值
重写后打印包名
3 equals()方法
s1.equals(s2);
重写前 基本数据类型 比数值；引用，比地址值
Objects类
1 equals
比较两个对象是否相同，不同点：增加了一些健壮性判断
equals方法

public class Test05{
    public static void main(String[] args){
       Usear usear1=new Usear("zzz",new Address("beijing"));
       Usear usear2=new Usear("zzz",new Address("beijing"));
       System.out.println(usear1.equals(usear2));
    }
}
class Usear
{
 String name;
 Address addr;
 public Usear()
 {}
 public Usear(String name,Address add)
 {
     this.name=name;
     this.addr=addr;
 }
 //重写equals方法
 public boolean equals(Object obj)
 {
    if(obj==null)||!(obj instanceof Usear)
        return false;
    if(this==obj)
         return true;
    User u=(User)obj;
    if(this.name.equals(u.name)&&this.adds.equals(u.adds))
          return true;
 }    
}
class Address
{
     String city;
     public Address()
     {}
     public Address(String city)
     {
        this.city=city;
     }

}

finalize()方法

/*
   关于Object类中的finalize()方法
   1 源码
   protect void finalize() throws Throwable{}
   2 JVM的垃圾回收机制调用，当一个java对象将要被回收时，调用
   3 如果希望对象销毁时执行一段代码时，这段代码写到finalize中
   4 java中的垃圾回收器不是轻易使用，垃圾太少或时间不到可能使用，可能不使用
*/
public class Test
{
  public static void main(String[] args)
  {
      Person p=new Person();
      p=null;
  }
}
//记录对象被销毁的时间点，在finalize方法中添加代码
class Person
{
    protected void finalize() throws Throwable
    {
       System.out.println("即将被销毁");
    }
}

hashCode()
int hashCode:在Object，public native int hashCode();不是抽象方法，带有naive关键字，底层调用c++
hashCode()方法返回的是哈希码；
实际就是一个java对象的内存地址，经过哈希算法，得出的一个值

public class test
{
   public static void main(String[] args)
   {
       Object o=new Object();
       int hashCodeValue=o.hashCode();
       System.out.println(hashCodeValue);
   }
}