【重学Java四】Object通用方法、继承

欢迎关注博主

文章目录

• • • • 一、Object通用方法
      • • 1. Equals()
        • 2. hashCode()
        • 3. toString()
        • 4. clone()
      • 二、继承
      • • 1. 访问权限
        • 2. 抽象类与接口
        • 3. super
        • 4. 重写和重载

一、Object通用方法

public native int hashCode()

public boolean equals(Object obj)

protected native Object clone() throws CloneNotSupportedException

public String toString()

public final native Class<?> getClass()

protected void finalize() throws Throwable {}

public final native void notify()

public final native void notifyAll()

public final native void wait(long timeout) throws InterruptedException

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

public final void wait() throws InterruptedException
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

1. Equals()

**等价关系：**自反性(x.equals(x); // true)、对称性(x.equals(y) == y.equals(x); // true)、传递性(x.equals(y) && y.equals(z) // true)、一致性(x.equals(y) == x.equals(y); // true)、与null的比较(x.equals(null); // false;)

**等价与相等：**对于基本类型，==判断两个值是否相等。对于引用类型，==判断两个变量是否引用同一个对象，而equals()判断引用的对象是否等价。

2. hashCode()

hashCode() 返回哈希值，equals()方法用来判断两个对象是否等价。等价对象的散列值一定相同，但是散列值相同的两个对象不一定等价。

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

HashSet 和 HashMap 等集合类使用了 hashCode() 方法来计算对象应该存储的位置，因此要将对象添加到这些集合类中，需要让对应的类实现 hashCode() 方法。

Apple apple = new Apple("莫逸风");
Apple apple1 = new Apple("莫逸风");
Set<Apple> appleSet = new HashSet<>();
appleSet.add(apple1);
appleSet.add(apple);
System.out.println(appleSet.size()); //2
1
2
3
4
5
6

我没有重写equals方法和hashCode方法，所以Set达不到去重的效果。

3. toString()

默认返回 Apple@5cad8086 这种形式，其中 @ 后面的数值为散列码的无符号十六进制表示。

4. clone()

cloneable：

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

重写 clone() 必须实现Cloneable接口，否则会剖出CloneNotSupportedException异常。

clone() 方法并不是 Cloneable 接口的方法，而是 Object 的一个 protected 方法。Cloneable 接口只是规定，如果一个类没有实现 Cloneable 接口又调用了 clone() 方法，就会抛出 CloneNotSupportedException。

下方示例可以尝试将Orange的Cloneable接口去掉看一下效果。

public class Test {
    public static void main(String[] args) throws CloneNotSupportedException {
        Orange orange = new Orange("莫逸风");
        Orange clone = (Orange) orange.clone();
        System.out.println(clone.getName());
    }

}
class Orange implements Cloneable{
    String name;

    public Orange(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.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
27
28

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

**深拷贝：**拷贝对象和原始对象的引用类型引用不同对象。

clone() 的替代方案：

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

class Orange {
    String name;
    public Orange(Orange orange) {
        this.name = orange.getName();
    }
}
1
2
3
4
5
6

二、继承

1. 访问权限

Java 中有三个访问权限修饰符：private、protected 以及 public，如果不加访问修饰符，表示包级可见。

protected 用于修饰成员，表示在继承体系中成员对于子类可见，但是这个访问修饰符对于类没有意义。

可以对类或类中的成员（字段和方法）加上访问修饰符。

• 类可见表示其它类可以用这个类创建实例对象。
• 成员可见表示其它类可以用这个类的实例对象访问到该成员；

子类的方法重写了父类的方法，那么子类中该方法的访问级别不允许低于父类的访问级别。这是为了确保可以使用父类实例的地方都可以使用子类实例去代替，也就是确保满足里氏替换原则。

2. 抽象类与接口

抽象类：

抽象类和抽象方法都使用 abstract 关键字进行声明。如果一个类中包含抽象方法，那么这个类必须声明为抽象类。

抽象类和普通类最大的区别是，抽象类不能被实例化，只能被继承。

接口：

接口是抽象类的延伸，在 Java 8 之前，它可以看成是一个完全抽象的类，也就是说它不能有任何的方法实现。

从 Java 8 开始，接口也可以拥有默认的方法实现，这是因为不支持默认方法的接口的维护成本太高了。在 Java 8 之前，如果一个接口想要添加新的方法，那么要修改所有实现了该接口的类，让它们都实现新增的方法。

接口的成员（字段 + 方法）默认都是 public 的，并且不允许定义为 private 或者 protected。从 Java 9 开始，允许将方法定义为 private，这样就能定义某些复用的代码又不会把方法暴露出去。

接口的字段默认都是 static 和 final 的。

3. super

• 访问父类的构造函数：可以使用 super() 函数访问父类的构造函数，从而委托父类完成一些初始化的工作。子类会调用父类的默认构造，如果父类重写了构造，即无空构造时，子类构造必须调用父类一个构造。

• 访问父类的成员：如果子类重写了父类的某个方法，可以通过使用 super 关键字来引用父类的方法实现。

4. 重写和重载

重写：

存在于继承体系中，指子类实现了一个与父类在方法声明上完全相同的一个方法。

为了满足里式替换原则，重写有以下三个限制：

• 子类方法的访问权限必须大于等于父类方法；
• 子类方法的返回类型必须是父类方法返回类型或为其子类型。
• 子类方法抛出的异常类型必须是父类抛出异常类型或为其子类型。

使用 @Override 注解，可以让编译器帮忙检查是否满足上面的三个限制条件。

重载：

指一个方法与已经存在的方法名称上相同，但是参数列表不同。