JavaSE-继承（包含Object类）

目录

• 继承（包含Object类）
  • 何为继承
  • 优点
    • 代码复用
    • 易于维护和扩展
  • 缺点
    • 紧密耦合
    • 缺乏灵活性
  • 常用的方法
  • Object类
    • Object类中的常用方法：
  • 方法重写规则
    • 方法重写规则
  • 方法重写与方法重载的区别
    • 示例代码
  • super关键字的用法
    • 示例代码
  • final关键字的用法
    • 示例代码

继承（包含Object类）

何为继承

在面向对象编程（OOP）中，继承是一种机制，它允许一个类（称为子类或派生类）继承另一个类（称为父类或基类）的属性和方法。继承提供了一种代码复用的方式，使得子类可以继承父类的公共属性和方法，而不需要重新编写相同的代码。

优点

代码复用

通过继承，可以在现有的类基础上创建新类，新类自动拥有父类的所有属性和方法，这样可以减少代码的重复编写。

易于维护和扩展

继承提供了一种层次结构，使得代码更加模块化，易于维护和扩展。如果需要修改某个功能，只需要在父类中修改，所有继承自该父类的子类都会受到影响。

缺点

紧密耦合

继承创建了类之间的强依赖关系，如果父类发生改变，可能会影响所有继承自该父类的子类。

缺乏灵活性

继承是静态的，一旦定义了继承关系，就很难改变。这限制了代码的灵活性。

常用的方法

在Java中，继承可以通过关键字extends来实现。下面是一个简单的示例：

// 父类
class Animal {
    void eat() {
        System.out.println("动物吃东西");
    }
}

// 子类
class Dog extends Animal {
    void bark() {
        System.out.println("狗叫");
    }
}

public class TestInheritance {
    public static void main(String[] args) {
        Dog myDog = new Dog();
        myDog.eat(); // 继承自Animal类的方法
        myDog.bark(); // Dog类特有的方法
    }
}

Object类

在Java中，所有的类都隐式地继承自java.lang.Object类，这是Java类层次结构的根类。即使在定义类时没有显式地指定父类，它也会默认继承自Object类。

class MyClass {
    // ...
}

public class TestObject {
    public static void main(String[] args) {
        MyClass myObject = new MyClass();
        // 可以使用Object类的方法
        myObject.toString();
    }
}

Object类中的常用方法：

在Java中，Object类是所有类的根类，它提供了一些常用的方法，这些方法在很多情况下都非常有用。以下是Object类的一些常用方法及其简要说明：

1. equals(Object obj)：检查传递给此方法的对象是否与该对象相等。默认行为是比较对象的引用，但通常需要根据类的属性重写这个方法。

2. hashCode()：返回该对象的哈希码值。支持equals方法的类通常也应该重写hashCode方法，以维护equals和hashCode的一致性。

3. toString()：返回该对象的字符串表示。通常需要重写这个方法以提供更有用的信息。

4. getClass()：返回运行时类对象，这个类对象表示该对象的实际类。

5. notify() 和 notifyAll()：唤醒在此对象监视器上等待的单个或所有线程。

6. wait()：导致当前线程等待，直到另一个线程调用此对象的notify()或notifyAll()方法。

7. wait(long timeout) 和 wait(long timeout, int nanos)：导致当前线程等待，直到另一个线程调用此对象的notify()或notifyAll()方法，或者超过指定的时间。

下面是一个示例，展示了如何使用这些方法：

class Person {
    private String name;
    private int age;

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

    @Override
    public boolean equals(Object obj) {
        if (this == obj) return true;
        if (obj == null || getClass() != obj.getClass()) return false;
        Person person = (Person) obj;
        return age == person.age &&
               (name != null ? name.equals(person.name) : person.name == null);
    }

    @Override
    public int hashCode() {
        int result = name != null ? name.hashCode() : 0;
        result = 31 * result + age;
        return result;
    }

    @Override
    public String toString() {
        return "Person{" +
               "name='" + name + '\'' +
               ", age=" + age +
               '}';
    }

    public static void main(String[] args) throws InterruptedException {
        Person person1 = new Person("Kimi", 30);
        Person person2 = new Person("Kimi", 30);

        System.out.println("person1 = " + person1);
        System.out.println("person2 = " + person2);

        System.out.println("Are person1 and person2 equal? " + person1.equals(person2));
        System.out.println("Hash code of person1: " + person1.hashCode());
        System.out.println("Hash code of person2: " + person2.hashCode());

        // 获取类对象
        System.out.println("Class of person1: " + person1.getClass().getName());
        System.out.println("Class of person2: " + person2.getClass().getName());
    }
}

在这个例子中，我们重写了equals、hashCode和toString方法，以便提供更有意义的行为。我们也展示了如何获取对象的类对象，并打印出它的名称。这个例子没有展示wait、notify和notifyAll方法的使用，因为它们通常与多线程编程一起使用，涉及到更复杂的同步机制。

方法重写规则

方法重写（Override）是指子类中定义一个与父类中具有相同名称、参数列表的方法。这是实现多态的一种方式。

方法重写规则

1. 方法名、参数列表和返回类型必须与父类中被重写的方法相同。
2. 访问权限不能比父类中被重写的方法更严格。
3. 不能重写父类中声明为final的方法。
4. 如果父类中的方法被声明为static，则子类中的方法也必须是static。

方法重写与方法重载的区别

• 方法重写：发生在子类和父类之间，要求方法名、参数列表相同，返回类型相同或兼容，访问权限相同或更宽松。
• 方法重载：发生在同一个类中，要求方法名相同，参数列表不同。

示例代码

class Parent {
    void show() {
        System.out.println("Parent show()");
    }
}

class Child extends Parent {
    // 方法重写
    void show() {
        System.out.println("Child show()");
    }

    // 方法重载
    void show(int num) {
        System.out.println("Child show(int num)");
    }
}

public class TestOverride {
    public static void main(String[] args) {
        Child obj = new Child();
        obj.show(); // 调用重写的方法
        obj.show(10); // 调用重载的方法
    }
}

super关键字的用法

super关键字用于引用父类中的属性、方法和构造器。

示例代码

class Parent {
    String name = "Parent";

    void show() {
        System.out.println("Parent show()");
    }
}

class Child extends Parent {
    String name = "Child";

    void show() {
        super.show(); // 调用父类的show方法
        System.out.println("Child show(), name = " + name);
    }
}

public class TestSuper {
    public static void main(String[] args) {
        Child obj = new Child();
        obj.show();
    }
}

final关键字的用法

final关键字可以用于修饰类、方法和变量。

• final类：不能被继承。
• final方法：不能被重写。
• final变量：一旦赋值后，其值不能被改变。

示例代码

final class FinalClass {
    // ...
}

class MyClass {
    final void show() {
        // ...
    }
}

public class TestFinal {
    public static void main(String[] args) {
        final int num = 10; // final变量
        // num = 20; // 编译错误：不能为final变量赋值
    }
}

通过上述内容，你应该对继承有了基本的了解，包括它的概念、优点、缺点、方法重写规则以及super和final关键字的用法。希望这些示例代码能帮助你更好地理解这些概念。