【面向对象的程序设计——类的重用】object类、终结类与终结方法

原创已于 2024-11-18 15:07:09 修改 · 1.1k 阅读

18 ·

CC 4.0 BY-SA版权

文章标签：

#java #jvm #开发语言

于 2024-11-18 11:09:18 首次发布

文章目录

Object类
终结类和终结方法

Object类

是Java类层次中的最高等级的类，是所有类的直接或间接父类，也就包含了Java中的所有公共属性

主要方法

public final Class getClass() ：获取当前对象所属的类信息，返回Class对象。
public String toString() ：返回表示当前对象本身有关信息的字符串对象。
public boolean equals(Object obj) ：比较两个对象引用是否指向同一对象，是则返回true，否则返回false
protected Object clone( ) ：复制当前对象，并返回这个副本。
Public int hashCode() ：返回该对象的哈希代码值。
protected void finalize() throws Throwable: 在对象被回收时执行，通常完成的资源释放工作。

相等与同一

在Object类中声明的equal()方法功能是比较两个对象引用是否只想一个对象。两个对象具有相同的类型，及相同的属性值，则称二者相等(equal)。如果两个引用变量指向的是同一个对象，则称这两个引用变量同一。两个对象同一，则肯定相等。两个对象相等，不一定同一。比较运算符“==” 判断的是这两个对象是否同一。

public class Main {
	public static void main(String args[]) {
		BankAccount a = new BankAccount("Bob", 123456, 100.00f);
		BankAccount b = new BankAccount("Bob", 123456, 100.00f);
		if (a == b) {
			System.out.println("YES");
		} else {
			System.out.println("NO");
		}
	}
}

运行结果：
NO
原因：a，b是相等，不是同一

public class Main {
	public static void main(String args[]) {
		BankAccount a = new BankAccount("Bob", 123456, 100.00f);
		BankAccount b = a;
		if (a == b) {
			System.out.println("YES");
		} else {
			System.out.println("NO");
		}
	}
}

运行结果：
YES

equals方法

equals方法的语法结构如下：

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

public class Main {
public static void main(String args[]){
	BankAccount a = new BankAccount("Bob", 123456, 100.00f); 
	BankAccount b = new BankAccount("Bob", 123456, 100.00f); 
	if (a.equals(b))  //之前这里是a == b（使用“==”判断是否同一）
		System.out.println("YES"); 
	else 
		System.out.println("NO");
	}
}

覆盖equals方法

class Apple {
    private String color;
    private boolean ripe;
    public Apple(String aColor, boolean isRipe) {
        color = aColor;
        ripe = isRipe;
    }
    public void setColor(String aColor) { color = aColor; }
    public void setRipe(boolean isRipe) { ripe = isRipe; }
    public String getColor() { return color; }
    public boolean getRipe() { return ripe; }
    @Override
    public String toString() {
        if (ripe) return("A ripe " + color + " apple");
        else return("A not so ripe " + color + " apple");
    }
    //覆盖equals方法
    @Override
    public boolean equals(Object obj) {
        if (obj instanceof Apple) {
            Apple a = (Apple) obj;
            return (color.equals(a.getColor()) && (ripe == a.getRipe()));
        }
        return false;
    }
}
public class Main {
    public static void main(String[] args) {
        Apple a = new Apple("red", true);
        Apple b = new Apple("red", true);
        System.out.println(a + " is equal to " + b + ": " + a.equals(b));
        System.out.println("a is identical to b: " + (a == b));
        Apple c = a;
        System.out.println(a + " is equal to " + c + ": " + a.equals(c));
        System.out.println("a is identical to c: " + (a == c));
    }
}

运行结果：
A ripe red apple is equal to A ripe red apple: true
a is identical to b: false
A ripe red apple is equal to A ripe red apple: true
a is identical to c: true

hashCode方法

这是一个用于返回对象哈希码的方法，哈希码是一个对象在内存中的地址的整数表示形式，但是这个值并不一定是对象的内存地址。如果两个对象通过 equals 方法比较是相等的，那么这两个对象必须具有相同的哈希码。如果两个对象的哈希码相等，它们不一定通过 equals 方法比较相等。这是因为不同的对象可能产生相同的哈希码（哈希碰撞）。如果重写了 equals 方法，那么也应该重写 hashCode 方法，以保持上述契约。

clone方法

就是复制一个对象，在Object 类中被定义为protected，所以需要覆盖为public。为了能够使用 clone 方法，类必须实现 Cloneable 接口。这个接口是一个标记接口，不包含任何方法，但它告诉JVM这个类的对象可以被克隆。如果一个类没有实现 Cloneable 接口，调用 clone 方法会抛出 CloneNotSupportedException 异常。clone方法的使用语法如下：

class MyObject implements Cloneable 
{ 
	//…
}

默认情况下，clone 方法执行的是浅拷贝，这意味着它只复制对象本身及其所有基本类型字段，而不会复制对象引用字段指向的对象。因此，副本对象和原对象将共享相同的引用字段。如果需要深拷贝，即复制对象及其引用字段指向的所有对象，那么类必须重写 clone 方法并递归地克隆这些字段。

eg-1

// 代码由AI生成
public class MyClass implements Cloneable {
    private int[] array;
    // 省略构造函数和其他方法...
    @Override
    protected Object clone() throws CloneNotSupportedException {
        // 调用 super.clone() 来执行浅拷贝
        MyClass cloned = (MyClass) super.clone();
        // 手动复制数组以实现深拷贝
        cloned.array = array.clone();
        return cloned;
    }
}

finalize方法

在对象被垃圾回收器回收之前，系统自动调用对象的finalize方法。如果要覆盖finalize方法，覆盖方法的最后必须调用super.finalize。

终结类和终结方法

当我们需要声明一个终结类，在声明的时候需要在class前面加一个final，终结类将不能再被继承。

final class Person{
    String name;
    String sex;
    int age;
}
class Child extends Person{
    String home;
}
public class Main {
    public static void main(String[] args) {
        Child child = new Child();
        System.out.println(child);
    }
}

编译器输出：
Error:(6, 21) java: 无法从最终Person进行继承

对应的还有终结方法，就是在方法声明前加上final

class parnet{
    public parnet() {
    }
    final int getPI(){
        return (int) Math.PI;
    }
}
class Child extends parnet{
    public Child() {
    }
    int getPI(){
        return 3.14;
    }
}