Java 基础之 Object

字数统计: 1.5k字   |   阅读时长≈ 7分

方法摘要

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
public final native Class<?> getClass() //获取对象的运行时对象的类

public native int hashCode()        //获取对象的 hash 值

public boolean equals(Object obj)   //比较两个对象是否相等

protected native Object clone()     //创建并返回一个对象的拷贝

public String toString()    //返回对象的字符串表示形式。 

public final native void notify()   //唤醒在该对象上等待的某个线程

public final native void notifyAll()    //唤醒在该对象上等待的所有线程

public final void wait()    //让当前线程进入等待状态。直到其他线程调用此对象的 notify() 方法或 notifyAll() 方法。 

public final native void wait(long timeout)  //让当前线程处于等待(阻塞)状态，直到其他线程调用此对象的 notify() 方法或 notifyAll() 方法，或者超过参数设置的timeout超时时间。 

public final void wait(long timeout, int nanos)  //与 wait(long timeout) 方法类似，多了一个 nanos 参数，这个参数表示额外时间（以纳秒为单位，范围是 0-999999）。 所以超时的时间还需要加上 nanos 纳秒。。 

protected void finalize()   //当 GC (垃圾回收器)确定不存在对该对象的有更多引用时，由对象的垃圾回收器调用此方法。

equals()

等价关系

  • 自反性
    1
    x.equals(x) //true
  • 对称性
    1
    x.equals(y) == y.equals(x) //true
  • 传递性
    1
    2
    3
    x.equals(y) //true
    y.equals(z) //true
    x.equals(z) //true
  • 一致性
    多次调用 equals() 方法结果不变
    1
    x.equals(y) == x.equals(y); // true
  • 与 null 的比较
    对任何不是 null 的对象 x 调用 x.equals(null) 结果都为 false
    1
    x.equals(null); // false;

    等价与相等

  • 对于基本类型，==判断两个值是否相等，基本类型没有 equals() 方法
  • 对于引用类型，==判断两个值的引用是否相等，而 equals() 方法判断引用的对象是否相等
    1
    2
    3
    4
    Integer x = new Integer(1);
    Integer y = new Integer(1);
    System.out.println(x.equals(y)); // true
    System.out.println(x == y);      // false

实现

  • 检查是否为同一个对象的引用，如果是直接返回 true；
  • 检查是否是同一个类型，如果不是，直接返回 false；
  • 将 Object 对象进行转型；
  • 判断每个关键域是否相等。
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    public class EqualExample {

        private int x;
        private int y;
        private int z;

        public EqualExample(int x, int y, int z) {
            this.x = x;
            this.y = y;
            this.z = z;
        }

        @Override
        public boolean equals(Object o) {
            if (this == o) return true;
            if (o == null || getClass() != o.getClass()) return false;

            EqualExample that = (EqualExample) o;

            if (x != that.x) return false;
            if (y != that.y) return false;
            return z == that.z;
        }
    }

hashCode()

hashCode 用于获取对象的 hash 值，表示在哈希表中的位置。

equals() 方法判断两个对象是否等价，等价的两个对象哈希值一定相等，而哈希值相等的两个对象不一定等价，因为计算哈希值具有随机性。

在覆盖 object 的 equals() 方法时应当总是覆盖 hashCode() 方法，保证等价的两个对象哈希值也是相等的

String 和 ArrayList 类都重写了 Object 的 equals() 方法，并重写了 hashCode() 方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
public final class String
    implements java.io.Serializable, Comparable<String>, CharSequence {
    
    public boolean equals(Object anObject) {
        if (this == anObject) {
            return true;
        }
        if (anObject instanceof String) {
            String anotherString = (String)anObject;
            int n = value.length;
            if (n == anotherString.value.length) {
                char v1[] = value;
                char v2[] = anotherString.value;
                int i = 0;
                while (n-- != 0) {
                    if (v1[i] != v2[i])
                        return false;
                    i++;
                }
                return true;
            }
        }
        return false;
    }   
    
    public int hashCode() {
        int h = hash;
        if (h == 0 && value.length > 0) {
            char val[] = value;
    
            for (int i = 0; i < value.length; i++) {
                h = 31 * h + val[i];
            }
            hash = h;
        }
        return h;
    }    
}

重写 hashCode 方法时，需要用素数31作为乘子，因为31可以被 JVM 优化

  • 左移 << : 左边的最高位丢弃，右边补全0（把 << 左边的数据*2的移动次幂）。
  • 右移 >> : 把>>左边的数据/2的移动次幂。
  • 无符号右移 >>> : 无论最高位是0还是1，左边补齐0。

所以 ：31 * i = (i << 5) - i（左边 31 * 2=62，右边2 * 2^5-2=62）两边相等，JVM就可以高效的进行计算

toString

toString() 方法用于返回对象的字符串表示形式。默认返回格式：对象的 class 名称 + @ + hashCode 的十六进制字符串。

1
2
3
4
public static void main(String[] args) {
    A a = new A();
    System.out.println(a.toString());    //client.A@b4c966a
}

clone()

1. cloneable

clone() 是 Object 的 protected 方法，它不是 public，一个类不显式去重写 clone()，其它类就不能直接去调用该类实例的 clone() 方法。

1
2
3
4
5
6
7
public class A {

   public static void main(String[] args) {
       A a = new A();
       a.clone();   //Unhandled exception: java.lang.CloneNotSupportedException
   }
}

重写 clone() 方法，必须实现 Cloneable，因为 Cloneable 接口规定，如果一个类没有实现 Cloneable 接口又调用了 clone() 方法，就会抛出 java.lang.CloneNotSupportedException

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
public class A implements Cloneable {

    private int a;
    private int b;

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

    public static void main(String[] args) throws CloneNotSupportedException {
        A a = new A();
        a.clone();
    }
}

2. 浅拷贝

拷贝对象和原始对象的引用类型引用同一个对象。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
public class A implements Cloneable {

    private int arr;

    public int getArr() {
        return arr;
    }

    public void setArr(int arr) {
        this.arr = arr;
    }

    @Override
    public A clone() throws CloneNotSupportedException {
        return (A) super.clone();
    }

    public static void main(String[] args) throws CloneNotSupportedException {
        A a = new A();
        a.setArr(123);
        A a1 = null;
        a1 = a.clone();
        System.out.println(a1.getArr()); //123
    }
}
```    

### 3. 深拷贝
拷贝对象和原始对象的引用类型引用不同对象。
```java
public class A implements Cloneable {

    private int arr;

    public int getArr() {
        return arr;
    }

    public void setArr(int arr) {
        this.arr = arr;
    }

    @Override
    public A clone() throws CloneNotSupportedException {
        A result = (A) super.clone();
        result.arr = this.arr;
        return result;
    }

    public static void main(String[] args) throws CloneNotSupportedException {
        A a = new A();
        a.setArr(123);
        A a1 = null;
        a1 = a.clone();
        System.out.println(a1.getArr()); //123
    }
}

4. clone() 的替代方案

使用 clone() 方法来拷贝一个对象即复杂又有风险，它会抛出异常，并且还需要类型转换。Effective Java 书上讲到，最好不要去使用 clone()，可以使用拷贝构造函数或者拷贝工厂来拷贝一个对象。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
public class A {

    private int arr;

    public int getArr() {
        return arr;
    }

    public void setArr(int arr) {
        this.arr = arr;
    }

    public A() {
    }

    public A(A a) {
        this.arr = a.arr;
    }

    public static void main(String[] args){
        A a = new A();
        a.setArr(123);
        A a1 = new A(a);
        System.out.println(a1.getArr());    //123
    }
}

tag:

    缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia-plus根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    3、在根目录_config.yml里添加配置： 

      jsonContent:
    meta: false
    pages: false
    posts:
      title: true
      date: true
      path: true
      text: false
      raw: false
      content: false
      slug: false
      updated: false
      comments: false
      link: false
      permalink: false
      excerpt: false
      categories: false
      tags: true

主要涉及技术:
java后端开发
微信公众号开发
Linux、Python
很惭愧

只做了一点微小的工作
谢谢大家