Java面对对象（三）-CSDN博客

本文链接：https://blog.csdn.net/weixin_65789931/article/details/132214423

接口

Java接口是Java中一个重要的概念，它是一种特殊的抽象类，它只包括常量和抽象方法。接口是一种规范，它描述了类应该具有的方法和属性，但不提供实现。接口用于定义类之间的协议，让类之间可以互相通信和交互。

接口中的方法必须是抽象方法，不能有方法体。接口中的变量必须是常量，也就是使用final关键字修饰的变量。接口中的方法和变量默认都是public的。

Java中的一个类可以实现一个或多个接口，实现接口的类必须要实现接口中的所有抽象方法。一个类可以继承一个类同时实现多个接口，实现接口的类可以被向上转型成接口类型。

Java中的接口有助于实现多态，通过接口可以达到组件之间的松耦合，提高程序的可扩展性和可维护性。常见的Java接口包括List、Map、Runnable等。

一个简单的Java接口例子如下：

public interface Shape {
    double getArea();
    double getPerimeter();
}

这个接口定义了两个方法getArea()和getPerimeter()，用于计算形状的面积和周长。任何实现了这个接口的类都必须实现这两个方法。

下面是一个实现接口的类的例子：

public class Circle implements Shape {
    private double radius;

    public Circle(double radius) {
        this.radius = radius;
    }

    public double getArea() {
        return Math.PI * radius * radius;
    }

    public double getPerimeter() {
        return 2 * Math.PI * radius;
    }
}

这个类实现了Shape接口，它具有计算圆形面积和周长的方法。注意该类必须实现Shape接口中的所有方法，因为它实现了该接口。

可以看到，通过实现接口，我们可以创建具有类似功能（在本例中是计算面积和周长）的不同类型的对象，即圆形和其他形状。这样就可以方便地对这些不同类型的对象进行处理和比较。

Java接口的特点如下：

接口只包含方法声明，没有方法体。
接口中的方法默认为public和abstract，不需要使用关键字显式声明。
接口中可以定义常量，常量必须是public、static、final类型的。
接口中不能定义实例变量，也不能使用非静态初始化块。
一个类可以实现多个接口。
实现接口的类必须实现接口中的所有方法。
接口可以继承多个接口。
接口中的方法不可以被标记为final、static、private或protected。
接口中的方法可以被默认方法（default）和静态方法（static）修饰。

多态

Java多态是指通过一个超类或接口的引用来调用子类实例的方法。在Java中，多态性是面向对象编程中的一个关键概念。它使得程序员可以编写出更灵活、可扩展和可维护的程序。

在Java中，多态性可以通过继承、接口和方法重载等方式实现。当一个对象被声明为父类或接口类型，并且实际上它是子类对象时，就可以使用多态性来调用子类的方法。这种方法调用是在运行时确定的，而不是在编译时确定的。

Java中的多态性有以下几种形式：

方法重载：在同一个类中可以定义多个同名的方法，但是它们的参数列表不同。
方法重写：子类可以重写继承自父类的非私有方法。当子类对象调用该方法时，将优先调用子类中的方法。
向上转型：将子类对象赋值给父类引用变量。
动态绑定：在运行时根据对象的类型动态地调用方法。

Java的多态性允许程序员编写出更加灵活和具有扩展性的代码。通过使用多态性，可以减少代码的重复性，并使程序更加易于维护。

以下是一个简单的Java多态案例：

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

public class Dog extends Animal {
   public void animalSound() {
      System.out.println("The dog says: bark bark");
   }
}

public class Cat extends Animal {
   public void animalSound() {
      System.out.println("The cat says: meow");
   }
}

public class Main {
   public static void main(String[] args) {
      Animal myAnimal = new Animal();  // 创建一个Animal对象
      Animal myDog = new Dog();  // 创建一个Dog对象
      Animal myCat = new Cat();  // 创建一个Cat对象

      myAnimal.animalSound();  // 调用Animal类的方法
      myDog.animalSound();  // 调用Dog类的方法
      myCat.animalSound();  // 调用Cat类的方法
   }
}

输出：

The animal makes a sound
The dog says: bark bark
The cat says: meow

该案例中，Animal是基类，而Dog和Cat都是Animal的子类。Dog和Cat继承了Animal类的animalSound()方法，但它们分别重写了该方法，以便可以发出不同的声音。在Main类中，我们创建了一个Animal对象，以及一个Dog和Cat对象，各自调用它们的animalSound()方法。其中，myAnimal对象调用的是Animal类的animalSound()方法，而myDog和myCat调用的是Dog和Cat类所重写的animalSound()方法。这就是多态的概念，即同一个方法在不同的对象上有不同的行为。

注意事项：

父类引用可以指向子类对象，但子类引用不能指向父类对象。
子类继承父类后，可以覆写父类中的方法，实现多态效果。
父类中声明的私有方法不能被子类覆盖，因此不能实现多态效果。
静态方法不能被覆盖，因此也不能实现多态效果。
如果父类中存在被覆盖的方法，子类覆盖后调用时会自动调用子类的方法，即动态绑定。
父类中不存在的方法无法在子类中被覆盖，因为子类中无法继承父类中不存在的方法。
如果父类和子类都有相同的方法名和参数列表，但返回值不同，则不符合方法重写的规则，编译会报错。

异常

Java 异常是在程序执行期间发生的意外情况，它破坏了程序的正常执行流程。Java 异常按照它们的产生原因可以分为三种类型：

检查性异常（Checked Exception）：这是一种在编译期间必须被检查的异常。Java编译器会检查代码是否能够处理这种异常，如果未处理，则会发出编译错误。例如：IOException 和 SQLException 等。
运行时异常（Unchecked Exception）：这种异常时程序错误引起的，它们在编译期间不会被检查，而是在程序运行期间由 Java 虚拟机（JVM）检测到。例如：NullPointerException、ArrayIndexOutOfBoundsException 等。
错误（Error）：错误是指在程序运行期间发生的一些灾难性事件，它们通常无法被处理，而只能够被 Java 虚拟机处理。例如：OutOfMemoryError 和 StackOverflowError 等。

为了处理异常，Java 提供了一组关键字（try、catch 和 finally）和异常类库。在代码中，可以将可能抛出异常的代码放在 try 块中，并使用 catch 关键字捕捉可能抛出的异常。finally 块中包含的代码在执行完 try 或 catch 块中的代码后被执行，无论是否发生异常。

Java异常处理是一种机制，用于在程序运行时处理意外的情况，如程序发生错误或无法正常运行。

在Java中，异常可以分为两种类型：检查型异常和非检查型异常。检查型异常必须在代码中进行处理或传递（使用throws关键字），否则程序无法编译。非检查型异常则可以不进行处理或传递，但一般来说最好进行处理以保证程序的稳定性。

以下是Java异常处理的一般流程：

抛出异常：当程序出现异常情况时，可以使用throw关键字抛出异常对象。
捕获异常：在可能出现异常的地方使用try-catch块捕获异常。如果try块中的代码引发了异常，程序会跳转到catch块处理异常。
处理异常：在catch块中，可以对所捕获的异常进行相应的处理，如输出异常信息、记录日志、重新抛出异常或进行其他操作。
抛出finally块：无论try和catch块中的代码是否引发异常，finally块中的代码都会被执行。一般用于释放资源或进行清理操作。

以下是一个简单的示例：

try {
    // 可能引发异常的代码
} catch (ExceptionType e) {
    // 处理异常的代码
} finally {
    // 释放资源或进行清理操作
}

Java还提供了一些常见的异常类型，如NullPointerException（空指针异常）、IndexOutOfBoundsException（下标越界异常）、ArithmeticException（算术异常）等。

在使用Java异常处理时，需要注意以下几点：

不要过多地使用捕获异常，尽可能避免出现异常。
在try块中尽可能放置最可能出现异常的代码。
捕获异常时，要尽可能具体地指定异常类型，防止捕获到意外的异常。
异常处理应该考虑到程序的整体逻辑，不应该只处理当前出现的异常。

Java中可以通过关键字throw手动抛出异常。通常情况下，异常的类型应该是Throwable类或其子类中的一个。例如，下面的代码手动抛出一个运行时异常：

public void divide(int a, int b) {
    if (b == 0) {
        throw new RuntimeException("除数不能为0");
    }
    int result = a / b;
    System.out.println(result);
}

在上面的方法中，如果除数为0，则手动抛出一个运行时异常，并输出对应的错误信息。程序在执行到throw语句时会停止执行，并且将异常抛出到调用方的代码中处理。在调用方法时，可以使用try-catch语句捕获异常并进行处理。