Java基础之Object篇

最新推荐文章于 2021-04-08 08:59:16 发布

wingooom

最新推荐文章于 2021-04-08 08:59:16 发布

阅读量599

点赞数

分类专栏： java基础文章标签： java object

本文链接：https://blog.csdn.net/vegetable_bird_001/article/details/50936183

版权

java基础专栏收录该内容

32 篇文章 0 订阅

订阅专栏

概述

Object类是所有Java类的祖先。每个类都使用 Object 作为超类。所有对象（包括数组）都实现这个类的方法。

在不明确给出超类的情况下，Java会自动把Object作为要定义类的超类。

API预览

这里写图片描述

toString

public String toString()

返回该对象的字符串表示；
Object 类的 toString 方法返回一个字符串，该字符串由类名+”@”+此对象哈希码的无符号十六进制表示组成
getClass().getName() + ‘@’ + Integer.toHexString(hashCode())

package java_interview;
public class Test {
   public static void main(String[] args) {

       Dog happy = new Dog();
       System.out.println(happy);直接在里面happy，默认等于happy.toString() 
   }

}
class Dog{

}
/*output:
java_interview.Dog@585e25f3
*/

重写

class Dog{
    @Override  
    public String toString(){  

            return "这个方法被我重写了";  

        }  
/*output:
这个方法被我重写了
*/

equals

public boolean equals(Object obj)
指示某个其他对象是否与此对象“相等”；

equals 方法在非空对象引用上实现相等关系：
自反性：对于任何非空引用值 x，x.equals(x) 都应返回 true。
对称性：对于任何非空引用值 x 和 y，当且仅当 y.equals(x) 返回 true 时，x.equals(y) 才应返回 true。
传递性：对于任何非空引用值 x、y 和 z，如果 x.equals(y) 返回 true，并且 y.equals(z) 返回 true，那么 x.equals(z) 应返回 true。
一致性：对于任何非空引用值 x 和 y，多次调用 x.equals(y) 始终返回 true 或始终返回 false，前提是对象上 equals 比较中所用的信息没有被修改。

对于任何非空引用值 x，x.equals(null) 都应返回 false。

Object 类的 equals 方法实现对象上差别可能性最大的相等关系；即，对于任何非空引用值 x 和 y，当且仅当 x 和 y 引用同一个对象时，此方法才返回 true（x == y 具有值 true）。

原equals方法

public class Test {


   public static void main(String[] args) {

       Dog happy = new Dog("white");
       Dog ll =new Dog("white");
       System.out.println(happy.equals(ll));

       System.out.println(happy.hashCode());
       System.out.println(ll.hashCode());
   }

}
class Dog{

    private String name;
    Dog(){};
    Dog(String name){

        this.name=name;

    };
}
/*output:
false
2046587545
751294816
*/

重写equals方法

class Dog{

    private String name;
    Dog(){};
    Dog(String name){

        this.name=name;

    };
    //重写equals
    @Override
    public boolean equals(Object obj){

        if(obj==null)
            return false;
        else if(obj instanceof Dog){

            Dog temp =(Dog)obj;
            if(this.name==temp.name){

                return true;
            }
            else
                return false;

        }
        else
            return false;


    }
    //重写hashCode()
    @Override
    public int hashCode(){
        int result=17;
        result = 31*result+name.hashCode();
        return result;

    }
}
/*
true
113102392
113102392

*/

注意：当此方法被重写时，通常有必要重写 hashCode 方法，以维护 hashCode 方法的常规协定，该协定声明相等对象必须具有相等的哈希码。
在覆写equals时推荐使用getClass进行类型判断。而不是使用instanceof。(考虑情况：子类的对象也属于父类类型)

hashCode()

public int hashCode()

返回该对象的哈希码值,

支持该方法是为哈希表提供一些优点，例如，java.util.Hashtable 提供的哈希表。
hashCode 的常规协定是：

在一个应用程序执行期间，如果一个对象的equals方法做比较所用到的信息没有被修改的话，则对该对象调用hashCode方法多次，它必须始终如一地返回同一个整数。
如果两个对象根据equals(Object o)方法是相等的，则调用这两个对象中任一对象的hashCode方法必须产生相同的整数结果。
如果两个对象根据equals(Object o)方法是不相等的，则调用这两个对象中任一个对象的hashCode方法，不要求产生不同的整数结果。但如果能不同，则可能提高散列表的性能。

在Java集合中有两类，一类是List，一类是Set他们之间的区别就在于List集合中的元素师有序的，且可以重复，而Set集合中元素是无序不可重复的。对于List好处理，但是对于Set而言我们要如何来保证元素不重复呢？
当我们向一个集合中添加某个元素，集合会首先调用hashCode方法，这样就可以直接定位它所存储的位置，若该处没有其他元素，则直接保存。若该处已经有元素存在，就调用equals方法来匹配这两个元素是否相同，相同则不存，不同则散列到其他位置。这样处理，当我们存入大量元素时就可以大大减少调用equals()方法的次数，极大地提高了效率。
所以hashCode在上面扮演的角色为寻域（寻找某个对象在集合中区域位置）。hashCode可以将集合分成若干个区域，每个对象都可以计算出他们的hash码，可以将hash码分组，每个分组对应着某个存储区域，根据一个对象的hash码就可以确定该对象所存储区域，这样就大大减少查询匹配元素的数量，提高了查询效率。

clone

protected Object clone()
                throws CloneNotSupportedException

创建并返回此对象的一个副本该副本会有另一块独立的内存
所以：

Dog happy=new Dog();
Dog haha=happy

这只是引用haha指向了happy的内存空间，并不是副本

被克隆的类必须自己实现Cloneable 接口
实现Cloneable接口的类应该使用公共方法重写 Object.clone（它是受保护的)


class Dog implements Cloneable{  //实现接口

    private String name;
    public Dog(String name){
        this.name=name;

    }
    public String getName(){
        return name;
    }
    //重写clone方法
    @Override
    public Object clone() throws CloneNotSupportedException {
        return super.clone();


    }

}

抛出：
CloneNotSupportedException - 如果对象的类不支持 Cloneable 接口，则重写 clone 方法的子类也会抛出此异常，以指示无法克隆某个实例。

finalize

protected void finalize()
throws Throwable
当垃圾回收器确定不存在对该对象的更多引用时，由对象的垃圾回收器调用此方法。子类重写 finalize 方法，以配置系统资源或执行其他清除。

对于任何给定对象，Java 虚拟机最多只调用一次 finalize 方法。

finalize 方法抛出的任何异常都会导致此对象的终结操作停止，但可以通过其他方法忽略它。

finalize 方法可以采取任何操作，其中包括再次使此对象对其他线程可用；不过，finalize 的主要目的是在不可撤消地丢弃对象之前执行清除操作。例如，表示输入/输出连接的对象的 finalize 方法可执行显式 I/O 事务，以便在永久丢弃对象之前中断连接。
抛出：
Throwable - 此方法抛出的 Exception

getClass()

public final Class<? extends Object> getClass()

返回一个对象的运行时类。该 Class 对象是由所表示类的 static synchronized 方法锁定的对象。

notify

public final void notify()

唤醒在此对象监视器上等待的单个线程。如果所有线程都在此对象上等待，则会选择唤醒其中一个线程。选择是任意性的，并在对实现做出决定时发生。线程通过调用其中一个 wait 方法，在对象的监视器上等待。

直到当前的线程放弃此对象上的锁定，才能继续执行被唤醒的线程。被唤醒的线程将以常规方式与在该对象上主动同步的其他所有线程进行竞争；例如，唤醒的线程在作为锁定此对象的下一个线程方面没有可靠的特权或劣势。
此方法只应由作为此对象监视器的所有者的线程来调用。

通过以下三种方法之一，线程可以成为此对象监视器的所有者：

通过执行此对象的同步 (Sychronized) 实例方法。
通过执行在此对象上进行同步的 synchronized 语句的正文。对于
Class 类型的对象，可以通过执行该类的同步静态方法。

一次只能有一个线程拥有对象的监视器。

抛出：
IllegalMonitorStateException - 如果当前的线程不是此对象监视器的所有者。

notifyAll

public final void notifyAll()

唤醒在此对象监视器上等待的所有线程。

抛出：
IllegalMonitorStateException - 如果当前的线程不是此对象监视器的所有者。

wait(long timeout)

public final void wait(long timeout)
                throws InterruptedException

timeout - 要等待的最长时间（以毫秒为单位）。

导致当前的线程等待，直到其他线程调用此对象的 notify() 方法或 notifyAll() 方法，或者超过指定的时间量。

当前的线程必须拥有此对象监视器。

此方法导致当前线程（称之为 T）将其自身放置在对象的等待集中，然后放弃此对象上的所有同步要求。出于线程调度目的，线程 T 被禁用，且处于休眠状态，直到发生以下四种情况之一：

其他某个线程调用此对象的 notify 方法，并且线程 T 碰巧被任选为被唤醒的线程。
其他某个线程调用此对象的 notifyAll 方法。
其他某个线程中断线程 T。
已经到达指定的实际时间。

但是，如果 timeout 为零，则不考虑实际时间，该线程将一直等待，直到获得通知。
然后，从对象的等待集中删除线程 T，并重新进行线程调度。然后，该线程以常规方式与其他线程竞争，以获得在该对象上同步的权利；一旦获得对该对象的控制权，该对象上的所有其同步声明都将被还原到以前的状态 - 这就是调用 wait 方法时的情况。然后，线程 T 从 wait 方法的调用中返回。所以，从 wait 方法返回时，该对象和线程 T 的同步状态与调用 wait 方法时的情况完全相同。

在没有被通知、中断或超时的情况下，线程还可以唤醒一个所谓的虚假唤醒 (spurious wakeup)。虽然这种情况在实践中很少发生，但是应用程序必须通过以下方式防止其发生，即对应该导致该线程被提醒的条件进行测试，如果不满足该条件，则继续等待。换句话说，等待应总是发生在循环中，如下面的示例：

synchronized (obj) {
while (<condition does not hold>)
obj.wait(timeout);
... // Perform action appropriate to condition
     }

如果当前线程在等待时被其他线程中断，则会抛出 InterruptedException。在按上述形式恢复此对象的锁定状态时才会抛出此异常。

注意，由于 wait 方法将当前的线程放入了对象的等待集中，所以它只能解除此对象的锁定；可以同步当前线程的任何其他对象在线程等待时仍处于锁定状态。

此方法只应由作为此对象监视器的所有者的线程来调用。请参阅 notify 方法，了解线程能够成为监视器所有者的方法的描述。

抛出：
IllegalArgumentException - 如果超时值为负。
IllegalMonitorStateException - 如果当前的线程不是此对象监视器的所有者。
InterruptedException - 如果在当前线程等待通知之前或者正在等待通知时，另一个线程中断了当前线程。在抛出此异常时，当前线程的中断状态被清除。

wait(，，)

public final void wait(long timeout,
                       int nanos)
                throws InterruptedException

nanos - 额外时间（以毫微秒为单位，范围是 0-999999）。

导致当前的线程等待，直到其他线程调用此对象的 notify() 方法或 notifyAll() 方法，或者其他某个线程中断当前线程，或者已超过某个实际时间量。

wait(0, 0) 与 wait(0) 相同。

对于某一个参数的版本，实现中断和虚假唤醒是有可能的，并且此方法应始终在循环中使用：


synchronized (obj) {
while (<condition does not hold>)
obj.wait(timeout, nanos);
... // Perform action appropriate to condition
     }

此方法只应由作为此对象监视器的所有者的线程来调用。

wait（）


public final void wait()
                throws InterruptedException

导致当前的线程等待，直到其他线程调用此对象的 notify() 方法或 notifyAll() 方法。换句话说，此方法的行为就好像它仅执行 wait(0) 调用一样。

对于某一个参数的版本，实现中断和虚假唤醒是可能的，而且此方法应始终在循环中使用：

synchronized (obj) {
while (<condition does not hold>)
obj.wait();
... // Perform action appropriate to condition
     }

此方法只应由作为此对象监视器的所有者的线程来调用。

抛出：
IllegalMonitorStateException - 如果当前的线程不是此对象监视器的所有者。
InterruptedException - 如果在当前线程等待通知之前或者正在等待通知时，另一个线程中断了当前线程。在抛出此异常时，当前线程的中断状态被清除。

参考

wingooom

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
Java基础之Object篇

概述Object类是所有Java类的祖先。每个类都使用 Object 作为超类。所有对象（包括数组）都实现这个类的方法。在不明确给出超类的情况下，Java会自动把Object作为要定义类的超类。API预览toStringpublic String toString()返回该对象的字符串表示； Object 类的 toString 方法返回一个字符串，该字符串由类名+”@”+此对象哈希码的无符号十六
复制链接

扫一扫

专栏目录