java面对对象知识点三----接口

在Java中，接口（Interface）是一种特殊的引用类型，它定义了一组方法的规范，但并不提供方法的具体实现。
接口可以看作是一个约定或契约，表示某个类拥有一组特定的方法。

接口特点：

1、接口定义：

• 使用关键字interface来定义接口。

其语法为：

interface InterfaceName {
    // 声明方法
}

2、变量的声明：

• 在接口中声明的变量都是隐式的常量（final），即接口中的变量声明默认为 public static final 类型。
• 接口中的变量必须初始化，并且在声明时通过赋值来指定其值。

以下是接口中变量声明的示例：

public interface MyInterface {
    int MAX_VALUE = 100;    // 常量声明，相当于 public static final int MAX_VALUE = 100;
    String DEFAULT_NAME = "John";    // 常量声明，相当于 public static final String DEFAULT_NAME = "John";
}

3、方法声明：

• 接口中的方法只有方法签名（包括方法名、参数类型和返回类型），没有方法体。
• 接口中的方法默认为public和abstract，因此可以被其他类实现（implement）。
  
  
  
  

4、 实现接口：

• 一个类通过使用implements关键字来实现一个或多个接口，从而满足接口的方法规范。
• 实现接口的类必须提供接口中所有方法的具体实现。
• 一个类可以实现多个接口，通过逗号分隔。
  
  
  
  

5、接口继承：

• 接口可以通过extends关键字来继承其他接口，从而扩展方法规范。
• 一个接口可以继承多个接口，通过逗号分隔。

下面是一个简单的接口示例：

interface Animal {
    void eat();
    void sleep();
}

class Cat implements Animal {
    @Override
    public void eat() {
        System.out.println("Cat is eating.");
    }

    @Override
    public void sleep() {
        System.out.println("Cat is sleeping.");
    }
}

在上面的示例中，Animal接口定义了eat()和sleep()方法的规范。Cat类通过implements关键字实现了Animal接口，提供了这两个方法的具体实现。这样，Cat类就符合了Animal接口的约定。

重写接口中声明的方法时，需要注意以下规则：

• 类在实现接口的方法时，不能抛出强制性异常，只能在接口中，或者继承接口的抽象类中抛出该强制性异常。
• 类在重写方法时要保持一致的方法名，并且应该保持相同或者相兼容的返回值类型。
• 如果实现接口的类是抽象类，那么就没必要实现该接口的方法。
  
  
  
  

在实现接口的时候，也要注意一些规则：

• 一个类可以同时实现多个接口。
• 一个类只能继承一个类，但是能实现多个接口。
• 一个接口能继承另一个接口，这和类之间的继承比较相似。
  
  
  
  

使用接口的好处包括：

• 实现类可以通过实现接口来符合某种约定或规范，并确保实现了接口中声明的方法。
• 接口可以实现多重继承，一个类可以实现多个接口，从而具备多个接口的功能。
• 接口提供了一种松耦合的设计方式，让类之间的关系更加灵活和可扩展。
  
  
  
  

接口（Interface）和类（Class）区别

1、定义和实现方式：

• 类是具体的实现，类通过关键字class来定义，可以直接创建对象并提供具体的方法和属性。
• 而接口通过关键字interface来定义，是一种抽象的定义，它定义了一组方法的签名但没有具体的实现。

2、继承关系：

• 一个类可以继承一个类（单继承），即一个子类只能继承自一个父类，通过继承可以获取父类的属性和方法。

• 接口之间可以进行多继承，即一个接口可以继承自多个接口，通过实现接口可以获得多个接口定义的方法。

3、构造方法：

• 类可以有构造方法，用于创建对象并进行初始化操作。
• 接口不能有构造方法，在实现接口的类中通过构造方法来创建对象。

4、数据成员：

• 类可以定义和使用数据成员（属性），并对其进行访问控制。

• 接口不能定义数据成员，只能定义方法签名。

5、用途和设计思想：

• 类用于描述具体的对象和其行为，通过继承和封装实现代码的重用和扩展。

• 接口用于定义一组方法的规范，通过实现接口实现对象的多态和代码的灵活性。

总而言之，类用于描述具体对象的实现，而接口用于定义行为规范，类和接口可以结合使用，通过继承和实现接口来实现代码的灵活性和可扩展性。

接口（Interface）和抽象类（Abstract Class）区别

1、实现方式：

• 接口只能定义方法的签名或者常量的声明，不包含具体的方法实现。
• 而抽象类可以包含抽象方法（没有具体实现）和具体方法（有实现）。
• 类通过实现接口或继承抽象类来达到抽象化的效果。
  2、多继承：
  一个类可以实现多个接口，但是只能继承一个抽象类。Java不支持类的多继承，因为多个父类的实现可能会引起冲突，而接口的实现则可以通过实现不同的接口来达到多继承的效果。

3、构造方法：

• 接口不能包含构造方法，因为接口本身不能被实例化。
• 而抽象类可以包含构造方法，并且在实例化子类的时候会调用父类的构造方法。

4、访问修饰符：

• 接口中的方法默认为 public。
• 抽象类中的方法可以有不同的访问修饰符（public、protected、default、private）。

5、设计目的和使用场景：

• 接口的设计目的是定义类之间的协议或契约，强调类的行为和能力，用于实现多态和解耦。
• 抽象类的设计目的是为了提供一个通用的基类，强调类的层次结构，用于代码复用和共享通用的方法。

总结起来，接口适用于定义契约、实现多态、解耦和插件式开发；而抽象类适用于构建层次结构、代码复用和共享通用的实现。根据具体的设计需求和使用场景，我们可以选择使用接口或抽象类来实现代码的抽象化。

函数式接口

Java 8引入了函数式接口的概念，并且通过Lambda表达式和方法引用等语法来实现函数式编程的支持。

函数式接口特点：

• 只包含一个抽象方法。
• 可以有默认方法和静态方法，用于提供额外的功能。
• 可以使用@FunctionalInterface注解显式声明为函数式接口，这是一种约定，用于提示接口的用途。

Java标准库中的一些常见函数式接口

• Runnable：无参无返回值的函数式接口。
• Consumer：接收一个参数，没有返回值的函数式接口。
• Supplier：不接收参数，只返回结果的函数式接口。
• Function：接收一个参数，返回一个结果的函数式接口。
• Predicate：接收一个参数，返回一个布尔值的函数式接口。
  
  
  
  

Lambda表达式

Lambda表达式是Java 8引入的一种函数式编程特性，它提供了一种简洁而灵活的方式来表示匿名函数（即没有名字的函数）。
Lambda表达式可以作为参数传递给函数或方法，或者以内联的方式定义在代码中。

Lambda表达式的语法如下所示：

(parameters) -> expression

或

(parameters) -> { statements; }

Lambda表达式由以下几个部分组成：

• 参数列表（parameters）：对于没有参数的情况，可以使用空括号 () 表示。对于有一个参数的情况，可以简写为参数名称。对于有多个参数的情况，使用逗号分隔。
• 箭头符号（->）：用于分隔参数列表和Lambda表达式的主体。
• 表达式或语句块（expression或statements）：Lambda表达式的主体部分，可以是一个表达式或一组语句块。

例如，下面是一个简单的Lambda表达式的示例，用于对一个整数列表进行遍历并打印每个元素：

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
numbers.forEach((n) -> System.out.println(n));

在上面的示例中，(n) -> System.out.println(n)
是一个Lambda表达式，表示一个接受一个整数参数并打印它的函数。通过调用forEach方法，并将Lambda表达式作为参数传递给它，可以对列表中的每个元素执行相应的操作。

Lambda表达式可以与函数式接口（Functional Interface）一起使用，Lambda表达式可以直接赋值给函数式接口，而不需要显式地实现接口的方法。

下面以一个简单的例子说明函数式接口和Lambda表达式的使用：

// 定义一个函数式接口
@FunctionalInterface
interface MyFunctionalInterface {
    void doSomething();
}

public class Main {
    public static void main(String[] args) {
        // 使用Lambda表达式创建函数式接口的实例
        MyFunctionalInterface myFunc = () -> {
            System.out.println("Lambda表达式执行了");
        };

        // 调用函数式接口的方法
        myFunc.doSomething();
    }
}

在上面的例子中，我们首先定义了一个函数式接口MyFunctionalInterface，它只包含一个抽象方法doSomething()。接着，在main方法中使用Lambda表达式创建了该接口的实例myFunc，并通过doSomething()方法调用了Lambda表达式中的逻辑。