首页 > 其他分享 >继承

继承

时间：2024-08-01 11:43:36浏览次数：9  
标签：继承 重写 子类 父类 方法 public

何为继承

继承（Inheritance）是面向对象编程（OOP）中的一个基本概念，它允许一个类（称为子类或派生类）继承另一个类（称为父类或基类）的属性和方法。继承是一种机制，通过这种机制，可以创建一个新类，这个新类是现有类的修改版或扩展版。

继承的特点：

  1. 代码复用：继承支持代码复用。子类可以继承父类的代码，无需重新编写相同的代码。

  2. 层次结构：继承支持创建类之间的层次结构，这有助于组织和管理大型软件项目。

  3. 扩展性：子类可以扩展父类的功能，通过添加新的方法或覆盖现有方法来实现。

  4. 多态性：继承是实现多态性的一个基础。通过继承，子类可以被看作是父类的一种特殊类型，这允许将子类对象视为父类对象使用。

  5. 访问控制：子类可以访问父类的公共（public）和受保护（protected）成员，但不能直接访问私有（private）成员。

  6. 方法重写：子类可以重写（Override）父类的方法，提供特定的实现。

  7. 构造器：子类继承父类的属性，但需要调用父类的构造器来初始化这些属性。

  8. super 关键字：在子类中，可以使用 super 关键字来引用父类的成员，包括调用父类的构造器或方法。

  9. 类型兼容性：在Java中，子类是其父类的一个子类型。因此，子类的对象可以在任何期望父类对象的地方使用。

  10. 最终类：如果一个类被声明为 final，则它不能被其他类继承。

示例：

// 父类
public class Animal {
    protected String name;

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

    public void eat() {
        System.out.println(name + " is eating.");
    }

    public void sleep() {
        System.out.println(name + " is sleeping.");
    }
}

// 子类
public class Dog extends Animal { // Dog 继承自 Animal
    public Dog(String name) {
        super(name); // 调用父类的构造器
    }

    @Override // 注解表示我们正在重写一个方法
    public void eat() {
        System.out.println(name + " is eating dog food.");
    }

    public void bark() {
        System.out.println(name + " says bark!");
    }
}

// 使用继承
public class Main {
    public static void main(String[] args) {
        Dog myDog = new Dog("Buddy");
        myDog.eat();  // 使用继承并重写的方法
        myDog.bark(); // Dog类特有的方法
    }
}

在这个示例中，Dog 类通过 extends 关键字继承自 Animal 类。Dog 类继承了 Animal 类的 name 属性和 eat()、sleep() 方法，并且重写了 eat() 方法，添加了 bark() 方法。这展示了继承如何用于代码复用和功能扩展。

继承的优缺点

继承作为面向对象编程的一个核心概念，提供了代码复用和建立层次结构的能力，但同时也带来了一些设计上的挑战。

优点：

  1. 代码复用：继承允许子类继承父类的属性和方法，减少了代码的重复编写，提高了开发效率。

  2. 层次结构：继承支持创建清晰的类层次结构，有助于组织和管理大型软件项目。

  3. 多态性：继承是实现多态性的基础，允许将子类对象视为父类对象使用，提高了程序的灵活性。

  4. 扩展性：子类可以扩展父类的功能，通过添加新的方法或覆盖现有方法来实现特定的行为。

  5. 简化性：使用继承可以简化复杂的系统设计，将通用功能抽象到父类中，子类专注于特定功能。

  6. 维护性：当父类的方法需要修改时，所有继承自该父类的子类都会自动获得更新，简化了维护工作。

缺点：

  1. 紧密耦合：继承创建了类之间的强关联，父类的改变可能会影响到所有子类，这可能导致代码难以维护。

  2. 脆弱性：高度的继承结构可能使得系统变得脆弱，一个小的修改可能会在意想不到的地方引起问题。

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

  4. 继承深度：过度使用继承可能导致继承层次过深，使得代码难以理解和跟踪。

  5. 不灵活：继承不支持多重继承，这限制了从多个父类继承不同功能的能力。

  6. 滥用：继承有时被滥用，例如，为了获得一些工具方法而继承一个不相关的类，这违反了OOP的基本原则。

  7. 隐藏细节：继承可能会隐藏实现细节，使得代码阅读者难以理解代码的真正行为。

  8. 修改限制：如果父类的方法被声明为final，则子类无法重写该方法，这限制了子类的扩展性。

  9. 继承而非组合：有时开发者可能会优先使用继承而不是组合，这可能导致设计问题，因为继承并不总是实现代码复用的最好方式。

总的来说，继承是一个强大的工具，但应该谨慎使用。在某些情况下，组合或其他设计模式可能是更好的选择。正确使用继承可以带来代码复用和清晰的层次结构，但也需要考虑到它可能引入的耦合性和维护挑战。

Object类

在Java中，Object 类是所有Java类的根类，位于类继承层次结构的顶端。这意味着Java中的每个类都隐式地继承了Object 类，除非你使用final关键字明确地阻止进一步继承。Object 类位于java.lang包中，它是Java语言的基础。

Object类的特点：

  1. 通用性：作为根类，Object 类定义了所有Java对象共有的基本行为。

  2. 方法：

    • equals(Object obj): 用于比较两个对象的等价性，默认实现比较对象的内存地址，但通常被重写以提供有意义的等价性比较。
    • hashCode(): 返回对象的哈希码，通常与equals方法一起重写，以确保相等的对象有相同的哈希码。
    • toString(): 返回对象的字符串表示，默认实现返回对象的类名和内存地址的无符号十六进制表示，但通常被重写以提供更有意义的信息。
    • clone(): 创建并返回对象的一个副本，具体行为依赖于Cloneable接口的实现。
    • finalize(): 在对象被垃圾回收器回收前进行清理操作，但不推荐使用，因为Java 9开始已被标记为过时，并在Java 14中被移除。

  3. 序列化：Object 类实现了Serializable接口，这意味着所有Java对象都可以被序列化和反序列化。

  4. 等待和通知机制：

    • wait(): 导致当前线程等待，直到另一个线程调用对象的notify()或notifyAll()方法。
    • notify(): 唤醒在此对象上等待的单个线程。
    • notifyAll(): 唤醒在此对象上等待的所有线程。

  5. 内存管理：Object 类的方法支持Java的内存管理机制，特别是垃圾回收。

  6. 根类：由于Object类是所有Java类的父类，它为所有对象提供了一个公共的类型。

  7. 反射：Object 类是反射的起点，因为所有类都隐式地继承自Object，所以Object类的属性和方法在反射API中是可用的。

  8. 实例创建：使用new关键字创建对象时，所有对象都会隐式地调用Object类的构造器。

示例：

public class MyClass {
    private int value;

    public MyClass(int value) {
        this.value = value;
    }

    @Override
    public String toString() {
        return "MyClass{" + "value=" + value + '}';
    }

    public static void main(String[] args) {
        MyClass myObject = new MyClass(42);
        System.out.println(myObject.toString()); // 重写Object类的toString()方法
    }
}

在这个例子中，MyClass 隐式地继承了Object 类，因此可以使用Object 类的toString()方法。MyClass 重写了toString()方法，以提供更具体的字符串表示。

作为根类，Object 类为Java语言提供了一个统一的基础，确保了所有对象都具有一些基本的行为和特性。

常用方法有哪些

Java的Object类定义了一些常用方法，这些方法在Java编程中非常普遍，经常被重写以提供特定功能。

  1. equals(Object obj)：

    • 用于比较两个对象的等价性。默认实现检查对象的内存地址是否相同，但通常被重写以提供基于属性的比较。

  2. hashCode()：

    • 返回对象的哈希码，用于在哈希表中定位对象。如果equals方法被重写，通常也需要重写hashCode方法，以维护equals和hashCode的一致性。

  3. toString()：

    • 返回对象的字符串表示。默认实现返回对象的类名和内存地址的无符号十六进制表示，但通常被重写以提供更有意义的信息。

  4. `clone()``：

    • 创建并返回对象的一个副本。这个方法是受保护的，需要在子类中被重写为public，并且通常还要实现Cloneable接口。

  5. `finalize()``（已在Java 14中移除）：

    • 允许对象在被垃圾回收器回收前进行清理操作。由于不可预测性和替代机制的存在，此方法不推荐使用。

  6. `getClass()``：

    • 返回对象的Class对象，表示对象的运行时类。

  7. `wait()``：

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

  8. `notify()``：

    • 唤醒在此对象上等待的单个线程，选择是任意的。

  9. `notifyAll()``：

    • 唤醒在此对象上等待的所有线程。

示例：

public 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 +
                '}';
    }

    // 其他方法...
}

在这个Person类的例子中，我们重写了equals、hashCode和toString方法。equals方法用于比较两个Person对象是否相等，基于它们的name和age属性。hashCode方法返回一个基于属性的哈希码。toString方法提供了Person对象的字符串表示，这对于调试和记录日志非常有用。

方法重写

方法重写（Method Overriding）是面向对象编程中的一个概念，它发生在子类中，子类提供一个已在父类中定义的方法的新实现。方法重写使得子类可以改变从父类继承来的方法的行为。

方法重写的特点：

  1. 方法签名相同：被重写的方法必须具有与父类中相同的方法签名，即方法名、参数列表和返回类型（协变返回类型除外）必须一致。

  2. 访问级别：子类中重写的方法不能有比父类更严格的访问级别。

  3. 非静态方法：只能重写父类中的非静态方法。静态方法不能被子类重写。

  4. 重写注解：在Java中，可以使用@Override注解来明确地表示一个方法是重写自父类的方法。如果方法没有正确地重写父类方法，编译器会报错。

  5. 多态性：方法重写是多态性的一个重要方面，它允许通过父类引用调用子类重写的方法。

  6. 调用super方法：在子类的方法中，可以使用super关键字调用父类中被重写的方法。

  7. 方法的可见性：如果子类重写的方法使用了更宽松的访问修饰符，那么子类的这个方法可以被子类的子类访问。

  8. 抽象类和接口：如果父类是一个抽象类或实现了接口，子类必须重写所有抽象方法。

示例：

class Animal {
    public void sound() {
        System.out.println("Animal makes a sound");
    }
}

class Dog extends Animal {
    @Override
    public void sound() {
        System.out.println("Dog barks");
    }
}

public class Main {
    public static void main(String[] args) {
        Animal myAnimal = new Dog(); // 多态性
        myAnimal.sound(); // 输出: Dog barks
    }
}

在这个示例中，Dog 类重写了 Animal 类的 sound 方法。Dog 类的 sound 方法提供了一个新的实现，当通过 Animal 类型的引用调用时，实际执行的是 Dog 类中重写的方法。这展示了多态性，即同一个接口可以有不同的实现。

方法重写规则

  1. 方法重写（Method Overriding）在面向对象编程中遵循一系列规则，确保继承体系中方法的正确调用和行为。

    1. 继承：方法重写发生在子类与其父类之间。子类必须继承父类的方法才能重写它。

    2. 方法签名：重写的方法必须具有与被重写方法相同的方法签名，即相同的方法名、参数列表和返回类型（对于返回类型，子类的方法可以返回父类方法返回类型的子类型，这称为协变返回类型）。

    3. 访问级别：重写的方法不能缩小访问级别。例如，如果父类中的方法声明为public，则子类中的重写方法不能声明为protected或private。

    4. 非静态方法：只能重写父类中的非静态方法。静态方法不能被子类重写，但可以被子类隐藏（Hide）。

    5. 重写注解：使用@Override注解可以帮助编译器检查方法是否正确重写了父类的方法。如果方法没有正确重写父类中的方法，编译器将报错。

    6. final关键字：如果父类的方法被声明为final，则不能被子类重写。

    7. super调用：在子类的重写方法中，可以使用super关键字来调用父类中被重写的方法。

    8. 多态性：方法重写是多态性的一个重要方面。当通过父类的引用调用重写的方法时，实际执行的是子类中的方法。

    9. 抽象方法：如果父类是一个抽象类，子类必须重写所有抽象方法，除非子类也是抽象类。

    10. 方法的可见性：如果子类重写的方法使用了比父类更宽松的访问修饰符，那么子类的这个方法可以被子类的子类访问。

    11. 接口方法：如果父类是一个接口，那么实现该接口的类必须提供接口中所有方法的具体实现。

    12. 构造器：构造器不能被重写，但可以被子类通过调用父类的构造器来扩展。

    13. 私有方法：私有方法不能被子类重写，因为它们在类的外部不可见。

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

方法重写（Method Overriding）和方法重载（Method Overloading）是面向对象编程中的两个不同的概念，它们在Java等语言中有着不同的应用和规则：

方法重写（Method Overriding）：

  1. 定义：发生在子类和父类之间，子类提供一个已在父类中定义的方法的新实现。

  2. 目的：改变继承自父类的行为。

  3. 方法签名：必须与被重写的方法具有相同的方法签名（方法名、参数列表和返回类型）。

  4. 访问控制：子类重写的方法不能有比父类更严格的访问控制。

  5. 使用场景：实现多态性，允许通过父类引用调用子类的方法。

  6. 例子：

    class Animal {
    void sound() {
        System.out.println("Animal makes a sound");
    }
}
class Dog extends Animal {
    @Override
    void sound() {
        System.out.println("Dog barks");
    }
}

方法重载（Method Overloading）：

  1. 定义：在同一个类中，存在多个同名方法，但它们的参数列表不同（参数数量、类型或顺序至少有一项不同）。

  2. 目的：提供相同功能的多个变体，允许调用者根据参数的不同选择不同的方法。

  3. 方法签名：必须有所不同，至少在一个方面（参数的数量、类型或顺序）。

  4. 访问控制：各个重载方法可以有不同的访问控制修饰符。

  5. 使用场景：提供多种方法调用选项，使得调用者可以根据需要选择最合适的方法。

  6. 例子：

    class Calculator {
    int add(int a, int b) {
        return a + b;
    }
    
    double add(double a, double b) {
        return a + b;
    }
}

主要区别：

  • 继承：方法重写需要继承关系，发生在子类和父类之间；方法重载发生在同一个类中。
  • 方法签名：方法重写要求方法签名相同；方法重载要求方法签名不同。
  • 返回类型：方法重写要求返回类型与被重写的方法一致或为其子类型；方法重载的方法可以有不同的返回类型。
  • 访问级别：方法重写不能缩小访问级别；方法重载的各个方法可以独立设置访问级别。
  • 多态性：方法重写是实现多态性的一种方式；方法重载不是多态性。

super关键字

在Java中，super 关键字是一种特殊的引用，它指向当前对象的直接父类实例。

super 的作用：

  1. 访问父类的成员：
    使用 super 可以访问直接父类中的成员变量和方法，特别是当子类中有同名成员时。

    public class Parent {
    protected int value = 10;
    
    public void printValue() {
        System.out.println(value);
    }
}

public class Child extends Parent {
    private int value = 20;
    
    public void printValue() {
        super.printValue(); // 访问父类的方法
        System.out.println(value); // 访问子类的变量
    }
}

  2. 调用父类的构造器：
    使用 super() 可以显式调用父类的构造器，这通常在子类的构造器中进行。

    public class Parent {
    public Parent() {
        // 父类的构造代码
    }
}

public class Child extends Parent {
    public Child() {
        super(); // 调用父类的构造器
        // 子类的构造代码
    }
}

  3. 在重写的方法中调用父类的方法：
    使用 super 可以在子类重写的方法中调用父类被重写的方法。

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

public class Child extends Parent {
    @Override
    public void show() {
        super.show(); // 在重写的方法中调用父类的方法
        System.out.println("Child's show()");
    }
}

  4. 区分成员变量和参数：
    当方法参数与类的成员变量同名时，super 可以用来引用父类的成员变量。

    public class Parent {
    protected int value;
}

public class Child extends Parent {
    public Child(int value) {
        super.value = value; // 将传入的参数赋值给父类的成员变量
    }
}

  5. 静态上下文中使用：
    在静态方法中，super 关键字不能用来引用非静态成员，因为静态方法不属于类的实例。但是，它可以用于调用父类的静态方法。

    public class Parent {
    public static void staticMethod() {
        System.out.println("Parent's static method");
    }
}

public class Child extends Parent {
    public static void staticMethod() {
        super.staticMethod(); // 调用父类的静态方法
    }
}

super 关键字是Java中实现继承和多态的重要工具，它允许子类访问和调用父类的成员，即使在子类中存在同名的成员或方法。正确使用 super 可以提高代码的可读性和维护性。

final关键字

final 关键字的作用：

  1. 创建不可继承的类：

    • 将类声明为 final 可以阻止其他类继承它。这通常用于工具类或者那些不应该被继承的类。
    public final class UtilityClass {
    // 工具类方法
}

  2. 定义不可重写的方法：

    • 将方法声明为 final 可以防止子类重写该方法。这有助于保护方法的核心行为不被改变。
    public final void criticalMethod() {
    // 重要的方法实现
}

  3. 声明常量：

    • 将变量声明为 final 并结合 static 关键字，可以创建类级别的常量。这些常量的值在初始化后不能被改变。
    public static final int MAX_VALUE = 100;

  4. 保证变量不可变：

    • 对于实例变量，声明为 final 意味着它们只能在对象构造时被初始化一次，之后不能被重新赋值。这有助于创建不可变对象。
    public final int instanceVariable;

  5. 优化性能：

    • final 关键字可以作为编译器优化的提示，因为 final 变量的值是固定的，编译器可以在某些情况下进行更有效的优化。

  6. 限制匿名内部类对外部局部变量的访问：

    • 在匿名内部类中，只有被声明为 final 或不可变的局部变量才能被访问。
    final int value = 10;
new Thread(() -> {
    System.out.println(value);
}).start();

  7. Lambda表达式中的变量捕获：

    • 在Lambda表达式中，如果外部的局部变量被声明为 final 或事实上不可修改（effectively final），则它可以在Lambda表达式中被捕获。
    final int value = 10;
Runnable runnable = () -> System.out.println(value);

  8. 限制方法的覆盖：

    • 当一个方法被声明为 final 时，它不能被子类覆盖，这可以用来实现特定的方法行为不被改变。

使用 final 关键字有助于明确代码的意图，提高代码的可读性和可维护性，同时也为编译器提供了优化的机会。

标签：继承,重写,子类,父类,方法,public
From： https://www.cnblogs.com/czj03/p/18336316

相关文章

  • 继承
    继承1.继承的定义在Java中，继承是一个面向对象编程的基本概念，它允许我们根据一个已存在的类（称为父类或基类）来定义一个新的类（称为子类或派生类）。继承使得子类可以继承父类的属性和方法，从而避免了代码的重复，提高了代码的复用性。子类可以拥有父类的所有成员（属性和方法），除非这些成员......
  • 代码大全继承派生覆盖子程序，但没有任何操作
    派生后覆盖了某个子程序,但在其中没做任何操作,这种情况也值得怀疑这通常表明基类的设计中有错误。 举例来说，假设你有一个Cat(猫)类，它有一个Scratch()(抓)成员函数，可是最终你发现有些猫的爪尖儿没了，不能抓了。你可能想从Cat类派生一个叫scratchiesscat(不能抓的猫)的类，然......
  • js中两种设置子类原型（prototype）来实现原型式继承的本质区别
    在JavaScript中，这两种设置子类（Child）原型（prototype）的方法虽然都能实现继承的基本功能，但它们之间存在一些重要的区别和潜在的陷阱。1. Child.prototype=Object.create(Parent.prototype);这个方法使用Object.create()来创建一个新对象，其原型（__proto__）被设置为Parent.prototy......
  • Java多态----继承
    一、基本概念关键字：extends    在java中，一个类（类A）继承另一个类（类B）是指类A能够直接使用类B的所有非构造方法和所有非私有属性（注意：不是不能使用是不能直接使用），并在类B原有的基础上继续进行扩充和延伸，即关键字extends的含义。通常，我们称类A与类B的关系为继承关系，继承方（......
  • vue模板中使用临时变量实例，for 循环中使用临时变量继承函数运行结果示例，函数运行结果
    示例代码<!--vue模板中使用临时变量测试示例--><template><divclass="component-name"><!--vue模板中循环定义临时变量实现--><divv-for="iteminitems":key="item.id":data-item="(itemTemp=formatter......
  • Python TypedDict：继承另一个TypedDict时的函数语法
    给定这种类型：classTPerson(TypedDict):name:straddress:str我想要另一个TypedDict继承前一个，例如：classTDealer(TPerson):db-id:intpolice_record:strarrested_now:boolclassTConsumer(TPerson):db-id:intpreferred_product:......
  • Python：指定与继承一起使用的类方法的返回类型
    我一直在尝试了解如何在Python中指定类方法的返回类型，以便即使对于子类也能正确解释它（例如在我的Sphinx文档中）。假设我有：classParent:@classmethoddefa_class_method(cls)->'Parent':returncls()classChild(Parent):pass什么如......
  • 自定义异常 - 捕获不继承自 BaseException 的类
    我正在尝试编写一些自定义异常处理，但不断遇到“TypeError：不允许捕获不从BaseException继承的类”错误的问题。我有一个名为NodeError的异常基类，它继承自Exception。从那里，我有几个继承自NodeError的自定义异常。web3模块使用requests模块与节点进行通信。我......
  • 如何在Python中继承类型提示？
    所以我的问题是，当我有一个A类型的类来做事情并且我使用这些函数作为subclass(B)时，它们仍然是类A的类型，并且不接受我的类B对象作为参数或作为函数签名。我的问题简化了：fromtypingimportTypeVar,Generic,CallableT=TypeVar('T'......
  • 模块3 面向对象编程高级 --- 第八章：实现继承
    第八章实现继承主要知识点1、继承的概念2、继承的实现3、用this和super关键字实现继承4、抽象类的实现学习目标掌握继承和抽象类的定义和实现方法。借助集成，可以扩展原有的代码，应用到其他程序中，而不必要重新编写这些代码。扩展声明的新类称为子类，原有......

赞助商

阅读排行

网站主页关于我们联系我们网站地图

本网站内容转载自其他媒体，侵权联系[admin##ips99.com]。

Copyright © 2020-2023 IPS99 版权所有 IPS99