继承 - IPS99技术分享

继承

一.继承的概念

继承是面向对象编程（OOP）中的一个核心概念，它允许我们定义一个类（称为子类或派生类）来继承另一个类（称为父类或基类）的属性和方法。通过这种方式，子类可以复用父类的代码，并且可以在此基础上添加或修改功能。继承的主要目的是实现代码的重用，并使得类之间的关系更加清晰。

继承的主要特点包括：

代码重用：子类可以直接使用父类中定义的属性和方法，无需重新编写相同的代码。
扩展性：子类可以在继承父类的基础上，增加新的属性或方法，也可以重写（Override）父类中的方法，以适应更具体的需求。
多态性：继承是实现多态性的基础。多态性允许我们以统一的接口去调用不同的实现，增强了程序的灵活性和可扩展性。

继承的几种类型（以C++、Java等语言为例）：

单继承：一个子类只能有一个直接父类。这是最常见的继承方式。
多继承：一个子类可以有多个直接父类。然而，多继承会带来一些问题，如菱形继承问题（即多个父类继承自同一个更上层的基类），因此在一些语言中（如Java）并不支持多继承，而是通过接口等其他机制来实现类似的功能。
多层继承：子类可以继承一个父类，而该父类也可以作为另一个类的子类，以此类推，形成多层继承结构。
接口继承：在一些语言中（如Java），接口（Interface）也被视为一种特殊的类，它可以被其他类实现（或继承）。接口继承与类继承的主要区别在于，接口只定义方法声明，不提供具体的实现，实现接口的类必须提供接口中所有方法的具体实现。

二.继承的优点和缺点

继承的优点

代码重用

：
- 继承允许子类继承父类的属性和方法，避免了代码的重复编写。这不仅可以减少代码量，还可以提高代码的可维护性，因为当父类中的代码需要修改时，所有继承自该父类的子类都会自动继承这些修改。
扩展性

：
- 子类可以在继承父类的基础上，通过添加新的属性和方法或重写父类中的方法来扩展功能。这种扩展性使得类之间的关系更加灵活，能够适应更复杂的业务需求。
多态性

：
- 继承是实现多态性的基础。多态性允许我们以统一的接口去调用不同的实现，增强了程序的灵活性和可扩展性。通过继承，子类可以覆盖（Override）父类中的方法，从而在运行时根据对象的实际类型来调用相应的方法。
易于理解和维护

：
- 在一个清晰的继承体系中，类的结构和它们之间的关系是显而易见的。这有助于开发人员更快地理解代码，并在需要时进行修改和维护。

继承的缺点

破坏封装性

：
- 继承可能会破坏封装性，因为子类可以访问父类的受保护（Protected）或默认（Package-private）成员。这可能导致子类依赖于父类的内部实现细节，从而降低了代码的模块性和可维护性。
耦合度高

：
- 继承会导致类之间的耦合度增加。当父类发生变化时，所有继承自该父类的子类都可能受到影响。这种高耦合度可能会使系统变得更加脆弱和难以维护。
继承层次过深

：
- 如果继承层次过深，将会导致系统结构变得复杂，难以理解。此外，过深的继承层次还可能导致“组合爆炸”问题，即随着继承层次的增加，子类的数量呈指数级增长。
难以扩展

：
- 当需要在系统中添加新的功能时，如果通过继承来实现，可能会导致类的数量急剧增加，从而使得系统变得更加复杂和难以管理。此外，如果新功能与现有类之间的关系不够清晰，还可能导致“上帝类”或“万能类”的出现。
限制了设计灵活性

：
- 继承在某种程度上限制了设计的灵活性。因为一旦确定了类的继承关系，就很难在不破坏现有代码的情况下对其进行修改。这可能会使得系统难以适应新的业务需求或技术变化。

因此，在使用继承时，我们需要权衡其优点和缺点，并根据具体情况来选择是否使用继承以及如何使用继承来构建我们的软件系统。在某些情况下，可能需要考虑使用其他设计模式（如组合、代理等）来替代继承以实现类似的功能。

三.object类

在Java中，Object类是一个极其重要且特殊的类，它位于java.lang包中，是所有Java类的根类。以下是对Object类的详细解析：

一、Object类的特点

所有类的超类：在Java中，任何类如果没有明确指定其父类，则默认继承自Object类。这意味着所有Java对象都可以使用Object类中定义的方法。
方法的统一性：Object类提供了一系列通用的方法，如equals()、hashCode()、toString()、getClass()等，这些方法可以被所有Java对象调用，用于处理对象的基本操作，如比较、哈希码计算、转换为字符串等。
提供基础功能：Object类还包含了一些用于线程同步的方法，如wait()、notify()和notifyAll()，这些方法主要用于在多线程环境下实现对象间的通信和同步。

二、Object类的主要方法

equals(Object obj)
- 默认情况下，equals()方法比较的是两个对象的引用地址是否相同（即是否是同一个对象）。但在实际开发中，经常需要比较两个对象的内容是否相等，因此通常会重写equals()方法。
- 重写equals()方法时，需要遵循一定的原则，如自反性、对称性、传递性、一致性和对于任何非null的引用值x，x.equals(null)必须返回false。
toString()
- 返回该对象的字符串表示。默认情况下，toString()方法返回的是对象的类名加上@符号和无符号十六进制表示的哈希码的无符号整数表示。但在实际开发中，通常会重写toString()方法，以返回对象的实际内容。
hashCode()
- 返回该对象的哈希码值。哈希码是对象的内存地址通过哈希算法转换得到的一个整数，主要用于哈希表的快速存取。当重写equals()方法时，通常也需要重写hashCode()方法，以保证相等的对象具有相等的哈希码。
getClass()
- 返回表示该对象运行时类的Class对象。该方法主要用于反射（Reflection）编程中，以获取对象的类型信息。
wait()、notify()和notifyAll()
- 这三个方法主要用于多线程编程中，用于实现线程间的通信和同步。wait()方法使当前线程等待该对象的监视器锁被释放，notify()方法唤醒在此对象监视器上等待的单个线程，notifyAll()方法唤醒在此对象监视器上等待的所有线程。

三、Object类的应用

多态性：由于所有类都继承自Object类，因此可以使用Object类型的变量来引用任何Java对象，这体现了Java的多态性。
类型转换：在需要时，可以将Object类型的变量强制转换为具体类型的变量，但需要注意类型转换的安全性。
重写方法：在自定义类中，经常需要重写Object类中的equals()、hashCode()和toString()等方法，以提供更适合该类对象的操作。

四.方法重写

方法重写（Override）是面向对象编程中的一个重要概念，它允许子类提供一个特定签名的方法，该方法可以重写（即替换）父类中具有相同签名的方法。这意呀着，当通过子类对象调用该方法时，将执行子类提供的方法实现，而不是父类中的实现。

方法重写的规则

方法名相同：子类中的方法名必须与父类中被重写的方法名完全相同。
参数列表相同：子类方法的参数列表（包括参数的类型、顺序和数量）必须与父类中被重写的方法的参数列表完全相同。
返回类型兼容：子类方法的返回类型应该与父类中被重写的方法的返回类型相同，或者是其子类（在Java 5及更高版本中，如果父类方法返回类型是协变的，则子类方法可以返回更具体的类型，这被称为协变返回类型）。
访问权限不能更严格：子类方法的访问权限不能比父类中被重写的方法的访问权限更严格（例如，如果父类方法是public的，则子类重写的方法也必须是public的）。但是，子类方法的访问权限可以更加宽松。
抛出异常限制：子类重写的方法可以抛出与父类方法相同的异常，或者其子类异常，但不能抛出新的或更广泛的检查型异常（除非这些异常在父类方法的签名中被声明）。对于运行时异常（RuntimeException及其子类），则没有这样的限制。
非静态方法：只有非静态方法才能被重写。如果父类中的方法是静态的，子类中的同名方法将被视为隐藏（Hiding）而不是重写。
构造方法不能被重写：构造方法是特殊的，它们不能被继承，因此也就不能被重写。但是，子类可以通过调用父类的构造方法来初始化父类部分。

示例

class Animal {  
    public void eat() {  
        System.out.println("This animal eats food.");  
    }  
}  
  
class Dog extends Animal {  
    @Override // 可选，但推荐加上，用于指示该方法是一个重写的方法  
    public void eat() {  
        System.out.println("This dog eats dog food.");  
    }  
}  
  
public class Test {  
    public static void main(String[] args) {  
        Animal myDog = new Dog(); // 向上转型  
        myDog.eat(); // 输出：This dog eats dog food.  
    }  
}

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

方法重写（Override）和方法重载（Overload）是面向对象编程中的两个重要概念，它们之间存在显著的区别。以下是对两者区别的详细阐述：

1. 定义与目的

方法重写：子类提供一个特定签名的方法，该方法可以重写（即替换）父类中具有相同签名的方法。重写的目的是让子类能够提供一个更具体或适应特定情况的方法实现，以实现多态性。
方法重载：在同一个类中定义多个同名的方法，但这些方法具有不同的参数列表（包括参数的类型、顺序或数量不同）。重载的目的是增强代码的复用性、灵活性和可读性，允许以不同的方式执行相似的操作。

2. 发生的范围

方法重写：发生在有继承关系的子类和父类之间。子类重写父类中的方法。
方法重载：发生在同一个类中。通过定义多个同名但参数列表不同的方法来实现。

3. 方法的参数

方法重写：子类重写的方法必须与父类中被重写的方法具有完全相同的参数列表（包括参数的类型、顺序和数量）。
方法重载：重载的方法具有相同的名称，但参数列表不同（参数的类型、顺序或数量至少有一项不同）。

4. 方法的返回类型

方法重写：子类重写的方法的返回类型必须与父类中被重写的方法的返回类型相同，或者是其子类（在Java中，从Java 5开始支持协变返回类型）。
方法重载：重载的方法的返回类型可以相同，也可以不同。返回类型不是重载方法的决定性因素，关键在于参数列表的不同。

5. 方法的访问权限

方法重写：子类重写的方法的访问权限不能比父类中被重写的方法的访问权限更严格（但可以更宽松）。
方法重载：重载的方法的访问权限没有特别的限制，可以相同也可以不同。

6. 运行时行为

方法重写：是运行时的多态性体现。当通过父类类型的引用调用被重写的方法时，实际执行的是子类中的方法实现。
方法重载：是编译时的多态性体现。编译器在编译时根据方法的参数类型和数量来决定调用哪个方法。

7. 静态方法与实例方法

方法重写：只适用于实例方法。静态方法不能被重写，但可以被隐藏（如果子类和父类有相同签名的静态方法，则子类的方法会隐藏父类的方法）。
方法重载：适用于实例方法和静态方法。

总结

方法重写和方法重载都是为了提高代码的复用性和灵活性，但它们在定义、目的、发生的范围、方法的参数、返回类型、访问权限、运行时行为以及是否适用于静态方法等方面存在明显的区别。理解这些区别对于编写清晰、可维护的面向对象代码至关重要。

五.super关键字

在Java中，super是一个关键字，它主要用于在子类中引用父类的成员（包括字段、方法和构造方法）。以下是super关键字的主要用法：

1. 访问父类的成员

成员变量：当子类和父类有同名的成员变量时，可以使用super关键字来明确访问父类中的成员变量。例如，super.x表示访问父类的x成员变量。
成员方法：在子类中可以使用super关键字来调用父类的成员方法，即使子类中有相同的方法名。例如，super.method()表示调用父类的method方法。

2. 调用父类的构造方法

在子类的构造方法中，可以使用super关键字来调用父类的构造方法。这通常用于在子类构造对象时初始化从父类继承的成员变量或执行父类的构造逻辑。例如，super()表示调用父类的无参构造方法，super(x)表示调用父类的带有参数x的构造方法。
注意：super()调用必须是子类构造方法的第一条语句（如果存在的话）。如果子类构造方法中没有显式调用父类的构造方法，则默认调用父类的无参构造方法（如果父类中存在无参构造方法的话）。

3. 在接口中的使用

在实现接口的类中，如果接口的默认方法与类的方法发生冲突，可以使用super关键字来调用接口的默认方法。例如，MyInterface.super.myMethod()表示调用接口的默认myMethod方法。

4. 注意事项

super关键字只能在子类中使用，并且只能用于直接调用父类的成员。
super和this都是Java中的关键字，但它们用途不同：this指向当前对象，用于区分成员变量和局部变量，或者在构造方法中调用另一个重载的构造方法；而super指向当前对象的父类部分，用于在子类中调用父类的方法或变量。

示例代码

class Parent {  
    int x = 10;  
    void display() {  
        System.out.println("Parent class");  
    }  
      
    Parent(int x) {  
        this.x = x;  
    }  
}  
  
class Child extends Parent {  
    int x = 20;  
    void display() {  
        System.out.println("Child class");  
        System.out.println("Child's x: " + x);  
        System.out.println("Parent's x: " + super.x); // 访问父类的字段  
        super.display(); // 调用父类的方法  
    }  
      
    Child(int x, int y) {  
        super(x); // 调用父类构造方法  
        // 其他初始化代码  
    }  
}  
  
public class Test {  
    public static void main(String[] args) {  
        Child child = new Child(5, 15);  
        child.display();  
    }  
}

在这个示例中，Child类继承了Parent类，并通过super关键字访问了父类的成员变量和方法，同时在子类构造方法中调用了父类的构造方法。

六.final关键字

在Java编程语言中，final是一个关键字，它代表“最终的”或“不可改变的”含义。final关键字具有多种用法，包括修饰类、方法、成员变量和局部变量。以下是final关键字的详细用法：

1. 修饰类

当final关键字用来修饰一个类时，这个类就被定义为最终类，不能被其他类继承。这通常用于确保类的安全性和不可变性，防止其他类通过继承来修改该类的行为。例如：

public final class MyClass {  
    // 类体  
}

2. 修饰方法

当final关键字用来修饰一个方法时，这个方法就被定义为最终方法，不能被子类重写。这有助于保持方法的稳定性和预期行为。例如：

public class MyClass {  
    public final void myMethod() {  
        // 方法体  
    }  
}

3. 修饰成员变量

final关键字修饰成员变量时，表示该变量的值一旦被初始化之后就不能被改变。对于基本数据类型，这意味着变量的值将保持不变；对于引用类型，这意味着引用不能改变，即不能指向另一个对象，但对象本身的状态（成员变量）是可以修改的。例如：

public class MyClass {  
    private final int myNumber = 10; // 基本数据类型  
    private final MyClassReference myObject = new MyClassReference(); // 引用类型  
  
    // 注意：myObject不能指向另一个MyClassReference实例，但myObject的成员可以被修改  
}

4. 修饰局部变量

在方法内部，final关键字也可以用来修饰局部变量。这意味着局部变量一旦初始化之后就不能被重新赋值。这通常用于确保变量的不可变性，从而提高代码的可读性和安全性。例如：

public void myMethod() {  
    final int myLocalNumber = 10; // 局部变量  
    // myLocalNumber = 20; // 这将导致编译错误  
}

5. 注意事项

final修饰的类中的成员方法默认也是final的，但这并不意味着这些成员方法不能被调用或执行。
final修饰的变量必须在声明时或构造方法中被初始化（对于成员变量而言）。
final修饰的引用类型变量不能指向另一个对象，但对象本身的状态是可以修改的。
final关键字不能用于修饰抽象类中的抽象方法，因为抽象方法必须被子类实现（即重写）。

结论

final关键字在Java中是一个非常重要的概念，它用于确保类的不可继承性、方法的不可重写性以及变量的不可变性。通过合理使用final关键字，可以提高代码的安全性、稳定性和可读性。

标签：重写,构造方法,继承,子类,父类,方法
From： https://www.cnblogs.com/yhy373286277/p/18338192

继承

继承