Java中Object类

Object类

Object类是所有类的直接或者间接的父类。
当一个类没有使用extends关键字指明其父类的情况下，该类的默认父类就是java.lang.Object类。
Object类是Java语言中所有类的根，所有的类都直接或间接的继承了Object类，数组也继承了Object类，因为Object类是所有类的直接或者间接父类，所以Object类中的功能就是通用功能。

Object类中的方法

1.clone（）
protected Object clone():克隆，复制的意思，
创建一个对象，返回当前对象的复制品。返回值是一个Object类型的对象，如需其他引用，注意向下转型。该方法是被protected修饰的，是受保护的。调用该方法需要在类中重写。

package com.zretc.java;
/**
 * 克隆实现的过程
 * 1.要将被实现对象的类：必须实现Cloneable接口
 * 2.要在该类中重写Object.clone()
 * 3.调用clone方法之后，需要对该方法进行异常处理
 * 4.将返回值Object对象向下转型，之后就可以将该返回对象给到被实现
类的引用。
 *  * 注意：两个对象的地址值不同，但内容相同
 * @author 马富贵
 * */
public class CloneDemo {
 public static void main(String[] args) throws
CloneNotSupportedException {
 Animal animal = new Animal("巴菲兔",12);
 Animal animal2 = (Animal) animal.clone();
 //输出两个克隆对象的地址值，是完全不一致的。
System.out.println(animal);//com.zretc.java.Animal@2a139a55
 
System.out.println(animal2);//com.zretc.java.Animal@15db9742
 //但是他们的内容相同。
 System.out.println(animal.info());//[姓名：巴菲兔 年
龄：12]
 System.out.println(animal2.info());//[姓名：巴菲兔 年
龄：12]
 //比较两个对象的地址
 System.out.println(animal == animal2);//false
 }
}

package com.zretc.java;
public class Animal implements Cloneable {
 private String name;
 private int age;
 
 public Animal() {
 }
 public Animal(String name , int age) {
 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 {
 // TODO Auto-generated method stub
 return super.clone();
 }
 public String info() {
 return "[姓名：" + this.name + "\t年龄：" + this.age + 
"]";
 }

2.fianllize
当堆空间的某个对象在栈空间没有任何引用指向它的时候，那么java的GC机制就会自动调用这个对象的finallize()方法，表示堆空间的这个实体被回收。
测试：Animal 对象引用为null，强制调用gc机制，在对象被释放之前，调用重写的finallize()方法

package com.zretc.java;
public class FinallizeDemo {
 public static void main(String[] args) {
 Animal animal = new Animal("布朗熊",2);
 System.out.println(animal);//Animal [name=布朗熊, age=2]
 animal = null;
// 强制调用：gc机制，gc调用之前会调用finallize
 System.gc();//对象被释放--->Animal [name=布朗熊, age=2]
 }
}

**注：**final，finally，finallize三者之间的区别？

• final:是一个关键字，最终的、不可变的意思。
  被它修饰的属性，值不可以被更改；
  被它修饰的方法，不可以被重写；
  被它修饰的类，不可以被继承。

• finally:是一个关键字，常与try-catch连用，作用是无论是否发生异常都必须执行的代码块。

• finallize:是Object类的一个方法，作用是java中的gc()垃圾回收机制在释放对象之前必须要调用的一个方法。

3.getClass()
获取当前对象的所属类，在直接写入getClass的时候，不能放到静态方法中，因为此时对象还没有出现。

package com.zretc.java;
import java.util.Date;
public class GetClassDemo {
 //1.直接写入：但是注意不能在静态方法中直接写入
 public void method() {
 System.out.println(getClass());
 }
 public static void main(String[] args) {
 GetClassDemo g = new GetClassDemo();
System.out.println(g.getClass());//classcom.zretc.java.GetClassDemo
 Date date = new Date();
 System.out.println(date.getClass());//classjava.util.Date
 g.method();//class com.zretc.java.GetClassDemo
 }
}

4.equals()
用于比较两个对象的地址，也就是堆内存中的地址，该方法底层使用的就是==，当我们想要比较两个对象的内容的时候，需要重写equals方法，例如：String类的equals()就已经被重写了。

package com.zretc.java;
public class Course {
 private String name;
 private double score;
 
 public Course() {
 super();
 }
 public Course(String name, double score) {
 super();
 this.name = name;
 this.score = score;
 }
 public String getName() {
 return name;
 }
 public void setName(String name) {
 this.name = name;
 }
 public double getScore() {
 return score；
 }
 public void setScore(double score) {
 this.score = score;
 }
 
// 重写equals方法
 public boolean equals(Object obj) {
// 1.判断当前对象和传入的obj对象地址是否相等？
// 如果地址相等，则内容一定也相等。
 if(this == obj) {
 return true;
 }
 
// 2.判断传入的obj对象是否为null，如果为null，结果一定是false
 if(obj == null) {
 return false;
 }
 
// 3.判断当前对象与传入的obj对象的类型是否一致，若不一致一定是返
回false
 if(this.getClass() != obj.getClass()) {
 return false;
 }
// 4.确认是同一个类的话，将传入的对象向下转型
 Course course =(Course) obj;
 if(name == null) {
 if(course.name != null) {
 return false;
 }
// 5.当name不为空，将name与obj的name进行字符串比较
 }else if(!name.equals(course.name)){
 return false;
 }
 
// 6.判断成绩类型double，如果小数的长度不相等，也要返回false
 if(Double.doubleToLongBits(score) !=
Double.doubleToLongBits(course.score)) {
 return false;
 }
 return true;
 }
 }

测试类：

package com.zretc.java;
public class EqualsDemo {
 public static void main(String[] args) {
 Object i = 10;
 System.out.println(i.equals(1));//false
 
 //注意：c1和c2的地址不一样，但是内容相同
 Course c1 = new Course("java",90.01);
 Course c2 = new Course("java",90.01);
 System.out.println(c1.equals(c2));//true
 System.out.println(c1 == c2);//false
 }
 }

注：==和equals的区别?
==：是比较运算符

• 可以使用在基本数据类型和引用数据类型变量中
• 比较基本数据类型时，比较的是值
• 比较引用数据类型时，比较的是地址
  equals()：是一个方法，而非运算符
• 要调用该方法，必须是引用数据类型的对象.的方式调用
• Object中，equals是这样定义的

public boolean equals(Object obj) {
 return (this == obj);
}

• 说明：Object类中定义的equals()和==的作用是相同的：比较两个对象的地址值是否相同.即两个引用是否指向同一个对象实体
• 像String、Date、File、包装类等都重写了Object类中的equals()方法。重写以后，比较的不是两个引用的地址是否相同，而是比较两个对象的"实体内容"是否相同
• 通常情况下，我们自定义的类如果使用equals()的话，也通常是比较两个对象的"实体内容"是否相同。那么，我们就需要对Object类中的equals()进行重写
• 重写的原则：比较两个对象的实体内容是否相同

5.toString()

• 该方法返回的是一个字符串，他的值为：
  getClass().getName() + “@” + Integer.toHexString(hashCode());
  [全类名][@][转换为16进制的哈希码]
• 重写toString(),可以自定义格式：

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