java中object子类型 object子类有哪些

Java-object类及其子类(toString、equals)

什么是Object类

Object类存储在java.lang包中，是java.long包下的核心类。是所有java类(Object类除外)的终极父类 ， 何一个类时候如果没有明确的继承一个父类的话，那么它就是Object的子类； 接口是不继承Object类的 。

Object类的结构（Object提供了11个方法）

• public final native Class<?> getClass()
• public native int hashCode()
• public boolean equals(Object obj)
• protected native Object clone() throws CloneNotSupportedException
• public String toString()
• public final native void notify()
• public final native void notifyAll()
• public final native void wait(long timeout) throws InterruptedException
• public final void wait(long time,int nanos) throws InterruptedException
• public final void wait () throws interruptedException
• protected void final finalize() throws Throwable { }

对方法进行分析，看看每个方法到底有什么用：

1. clone()

保护方法，实现对象的浅复制，只有实现了Cloneable接口才可以调用该方法，否则抛出CloneNotSupportedException异常。

2. getClass()

final方法，返回Class类型的对象，反射来获取对象。

3. toString()

该方法用得比较多，一般子类都有覆盖，来获取对象的信息。

4. finalize()

该方法用于释放资源。因为无法确定该方法什么时候被调用，很少使用。

5. equals()

比较对象的内容是否相等

6. hashCode()

该方法用于哈希查找，重写了equals方法一般都要重写hashCode方法。这个方法在一些具有哈希功能的Collection中用到。

7. wait()

wait方法就是使当前线程等待该对象的锁，当前线程必须是该对象的拥有者，也就是具有该对象的锁。wait()方法一直等待，直到获得锁或者被中断。wait(long timeout)设定一个超时间隔，如果在规定时间内没有获得锁就返回。

调用该方法后当前线程进入睡眠状态，直到以下事件发生。

1. 其他线程调用了该对象的notify方法。
2. 其他线程调用了该对象的notifyAll方法。
3. 其他线程调用了interrupt中断该线程。
4. 时间间隔到了。

此时该线程就可以被调度了，如果是被中断的话就抛出一个InterruptedException异常。

8. notify()

该方法唤醒在该对象上等待的某个线程。

9. notifyAll()

该方法唤醒在该对象上等待的所有线程。

toString方法

• Object类中定义有public String toString()方法，其返回值是 String 类型，描述当前对象的有关信息。
• 在进行String与其它类型数据的连接操作时（如：System.out.println(“info”+person）），将自动调用该对象类的 toString()方法
• 可以根据需要在用户自定义类型中重写toString()方法。

简单的说：其作用是取得对象信息，返回该对象的字符串表示

举例：

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

   public Animal(int age,String name){
       this.age = age;
       this.name = name;
   }

public class TestAnimal {
    public static void main(String[] args) {
        Animal animal = new Animal(12,"wc");
        System.out.println(animal);
    }
}
 //输出：com.feifan.run.Demo3.Animal@1b6d3586

在使用对象直接输出的时候，默认输出的是一个对象在堆内存上的地址值；如若要输出该对象的内容，则要覆写toString()方法

覆写Person中的toString()方法

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

   public Animal(int age,String name){
       this.age = age;
       this.name = name;
   }

    @Override
    public String toString() {
        return "Animal{" +
                "age=" + age +
                ", name='" + name + '\'' +
                '}';
    }
public class TestAnimal {
    public static void main(String[] args) {
        Animal animal = new Animal(12,"wc");
        System.out.println(animal);
    }
}

toString( )的核心目的在于取得对象信息

System.out.println("qwe"+342)
输出：qweqwe

为什么qwe和342一个是字符串，一个是int类型的数据类型，可以直接拼接在一起

• 因为Object是所有类的父类，任意类都是继承Object类的。而Object中定义了 toString()方法，所以任意类中都包含了toString()方法，对象在实例化之后都可以调用。
• 所以任意对象转字符串的输出，是通过覆写 toString()方法实现的…
• 每一个类中都包含有toString()，但是并不是每一个类都覆写了toString()

equals方法

作用：对象比较

对于字符串变量来说，使用“==”和“equals()”方法比较字符串时，其比较方法不同。

• “==”比较两个变量本身的值，即两个对象在内存中的首地址。
• (java中，对象的首地址是它在内存中存放的起始地址，它后面的地址是用来存放它所包含的各个属性的地址，所以内存中会用多个内存块来存放对象的各个参数，而通过这个首地址就可以找到该对象，进而可以找到该对象的各个属性)。
• equals()”比较字符串中所包含的内容是否相同。

例如：

String s1,s2,s3 = "abc", s4 ="abc" ;
s1 = new String("abc");
s2 = new String("abc");

s1==s2   是 false      //两个变量的内存地址不一样，也就是说它们指向的对象不 一样，

s1.equals(s2) 是 true    //两个变量的所包含的内容是abc，故相等。

String s1,s2,s3 = "abc", s4 ="abc" ;
        s1 = new String("abc");
        s2 = new String("abc");
        System.out.println("s1==s2:"+(s1==s2));
        System.out.println("s1==s3:"+(s1==s3));
        System.out.println("s3==s4:"+(s3==s4));
        System.out.println("s1.equals(s2):"+(s1.equals(s2)));
        System.out.println("s1.equals(s3):"+(s1.equals(s3)));
        System.out.println("s3.equals(s4):"+(s3.equals(s4)));

结果：

对于s3和s4来说，有一点不一样要引起注意，由于s3和s4是两个字符，串常量所生成的变量，其中所存放的内存地址是相等的，所以s3==s4是true（即使没有s3=s4这样一个赋值语句）

对于非字符串变量来说，"=="和"equals"方法的作用是相同的都是用来比较其，对象在堆内存的首地址，即用来比较两个引用变量是否指向同一个对象。

例如：

class A
{
      A obj1   =   new  A();
      A obj2   =   new  A();
}
     obj1==obj2　　//结果为false
     obj1.equals(obj2)//是false
　　　//但是如加上这样一句：
　　　obj1=obj2;　　
　　　//执行后
　　　obj1==obj2  //是true
     obj1.equals(obj2) //是true

equals方法对于字符串来说是比较内容的，而对于非字符串来说是比较，其指向的对象是否相同的。

== 比较符也是比较指向的对象是否相同的也就是对象在对内存中的的首地址。

String类中重新定义了equals这个方法，而且比较的是值，而不是地址。所以是true。

注意：

Animal animal1 = new Animal(12,"wc");
        Animal animal2 = new Animal(12,"wc");
        System.out.println("animal1.equals(animal2):  "+animal1.equals(animal2));
		//结果为false

两个对象animal1和animal2的内容明明相等，应该是true呀？怎么会是false?

因为此时直接调用equals()方法默认进行比较的是两个对象的地址。这个方法就来自Object类，（Object类中的equals方法是用来比较“地址”的，所以等于false）。

在源码中，传递来的Object对象和当前对象比较地址值，返回布尔值。

但是，new一下就会在堆上创建新空间，两个对象地址自然不会相同，所以为false。

但是在判断两个对象是否相等时，比如要判断一个Person类的两个对象的姓名是否相同时，此时要重新覆写equals()

关于equals和==的用法区别

• 如果是基本类型比较，那么只能用==来比较，不能用equals

public class EqualsDemo { 
public static void main(String[] args) 
{ 
int a = 3; 
int b = 4; 
int c = 3; 
System.out.println(a == b);//结果是false 
System.out.println(a == c);//结果是true 
System.out.println(a.equals(c));//错误，编译不能通过，equals方法 
//不能运用与基本类型的比较 
} 
}

• 对于基本类型的包装类型，比如Boolean、Character、Byte、Shot、Integer、Long、Float、Double等的引用变量，==是比较地址的，而equals是比较内容的。

public class EqualsDemo2 {

        public static void main(String[] args)
        {
            Integer n1 = new Integer(30);
            Integer n2 = new Integer(30);
            Integer n3 = new Integer(31);
            System.out.println(n1 == n2);//结果是false 两个不同的Integer对象，故其地址不同，
            System.out.println(n1 == n3);//那么不管是new Integer(30)还是new Integer(31) 结果都显示false
            System.out.println(n1.equals(n2));//结果是true 根据jdk文档中的说明，n1与n2指向的对象中的内容是相等的，都是30，故equals比较后结果是true
            System.out.println(n1.equals(n3));//结果是false 因对象内容不一样，一个是30一个是31
        }
    }