Object

Object:类 Object 是类层次结构的根类。每个类都使用 Object 作为超类。
每个类都直接或者间接的继承自Object类。

Object类的方法

public int hashCode()

     返回该对象的哈希码值
     注意：哈希值是根据哈希算法计算出来的一个值，这个值和地址值有关，但是不是实际地址值。
     你可以理解为地址值。

public final Class getClass()

     返回此 Object 的运行时类
     Class类的方法：
     public String getName()：以 String 的形式返回此 Class 对象所表示的实体

public class StudentTest {
    public static void main(String[] args) {
        Student s1 = new Student();
        System.out.println(s1.hashCode()); // 11299397
        Student s2 = new Student();
        System.out.println(s2.hashCode());// 24446859
        Student s3 = s1;
        System.out.println(s3.hashCode()); // 11299397
        System.out.println("-----------");

        Student s = new Student();
        Class c = s.getClass();
        String str = c.getName();
        System.out.println(str); // cn.itcast_01.Student

        //链式编程
        String str2  = s.getClass().getName();
        System.out.println(str2);
    }
}

public String toString()

     返回该对象的字符串表示
     Integer类下的一个静态方法：
        public static String toHexString(int i)：把一个整 数转成一个十六进制表示的字符串

     这个信息的组成我们讲解完毕了，但是这个信息是没有任何意义的。所以，建议所有子类都重写该方法。
     怎么重写呢?
        把该类的所有成员变量值组成返回即可。
     重写的最终版方案就是自动生成toString()方法。

  注意：
     直接输出一个对象的名称，其实就是调用该对象的toString()方法。

package cn.itcast_02;

public class Student {
    private String name;
    private int age;

    public Student() {
        super();
    }

    public Student(String name, int age) {
        super();
        this.name = name;
        this.age = 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;
    }

    @Override
    public String toString() {
        return "Student [name=" + name + ", age=" + age + "]";
    }

    // @Override
    // public String toString() {
    // // return super.toString();
    // // return "hello";
    // return "姓名:" + name + ",年龄:" + age;
    // }


}

public boolean equals(Object obj)

  指示其他某个对象是否与此对象“相等” 
  这个方法，默认情况下比较的是地址值。比较地址值一般来说意义不大，所以我们要重写该方法。
  怎么重写呢?
        一般都是用来比较对象的成员变量值是否相同。
  重写的代码优化：提高效率，提高程序的健壮性。
  最终版：
        其实还是自动生成。

  看源码：
        public boolean equals(Object obj) {
            //this - s1
            //obj - s2
            return (this == obj);
        }

面试题：==与equals的区别?     
  ==:
        基本类型：比较的就是值是否相同
        引用类型：比较的就是地址值是否相同
  equals:
        引用类型：默认情况下，比较的是地址值。
        不过，我们可以根据情况自己重写该方法。一般重写都是自动生成，比较对象的成员变量值是否相同

package cn.itcast_03;

public class Student {
    private String name;
    private int age;

    public Student() {
        super();
    }

    public Student(String name, int age) {
        super();
        this.name = name;
        this.age = 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;
    }

    @Override
    public boolean equals(Object obj) {
        if (this == obj)
            return true;
        if (obj == null)
            return false;
        if (getClass() != obj.getClass())
            return false;
        Student other = (Student) 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;
    }

//  @Override
//  public boolean equals(Object obj) {
//      // return true;
//      //这里要改进，根据这里比较的成员变量来决定返回true还是false
//      //这里其实要比价的就是name和age
//      //但是，name是String类型的，而String是引用类型的，所以，在这里不能直接用==比较，应该用equals()比较
//      //String的equals()方法是重写自Object类的，比较的是字符串的内容是否相同
//      //this -- s1
//      //obj -- s2
//      //我们要使用的是学生类的特有成员变量,所以要向下转型
//      Student s = (Student)obj; //s -- obj -- s2;
//      if(this.name.equals(s.name) && this.age == s.age) {
//          return true;
//      }else {
//          return false;
//      }
//  }

//  @Override
//  public boolean equals(Object obj) {
//      //为了提高效率
//      if(this == obj){
//          return true;
//      }
//      
//      //为了提供程序的健壮性
//      //我先判断一下，obj是不是学生的一个对象，如果是，再做向下转型，如果不是，直接返回false。
//      //这个时候，我们要判断的是对象是否是某个类的对象?
//      //记住一个格式：对象名 instanceof 类名
//      //表示：判断该对象名是否是该类名一个对象
//      if(!(obj instanceof Student)){
//          return false;
//      }
//      //如果是就继续
//      
//      Student s = (Student)obj;
//      //System.out.println("同一个对象，还需要向下转型并比较吗?");
//      return this.name.equals(s.name) && this.age == s.age;
//  }


}

protected void finalize()

    当垃圾回收器确定不存在对该对象的更多引用时，由对象的垃圾回收器调用此方法。用于垃圾回收，但是什么时候回收不确定。

protected Object clone()

     建并返回此对象的一个副本。
        A:重写该方法

     Cloneable:此类实现了 Cloneable 接口，以指示 Object.clone() 方法可以合法地对该类实例进行按字段复制。 
    这个接口是标记接口，告诉我们实现该接口的类就可以实现对象的复制了。

package cn.itcast_04;

public class Student implements Cloneable {
    private String name;
    private int age;

    public Student() {
        super();
    }

    public Student(String name, int age) {
        super();
        this.name = name;
        this.age = 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;
    }

    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
}

public class StudentDemo {
    public static void main(String[] args) throws CloneNotSupportedException {
        //创建学生对象
        Student s = new Student();
        s.setName("林青霞");
        s.setAge(27);

        //克隆学生对象
        Object obj = s.clone();
        Student s2 = (Student)obj;
        System.out.println("---------");

        System.out.println(s.getName()+"---"+s.getAge());
        System.out.println(s2.getName()+"---"+s2.getAge());

        //以前的做法
        Student s3 = s;
        System.out.println(s3.getName()+"---"+s3.getAge());
        System.out.println("---------");

        //其实是有区别的
        s3.setName("刘意");
        s3.setAge(30);
        System.out.println(s.getName()+"---"+s.getAge());
        System.out.println(s2.getName()+"---"+s2.getAge());
        System.out.println(s3.getName()+"---"+s3.getAge());

    }
}

/*
    ---------
    林青霞---27
    林青霞---27
    林青霞---27
    ---------
    刘意---30
    林青霞---27
    刘意---30
*/