Java基础--接口，内部类，注解

Summer冬天

已于 2024-01-30 21:28:41 修改

阅读量836

点赞数 11

分类专栏： Java基础文章标签： java 开发语言

于 2024-01-29 09:51:21 首次发布

本文链接：https://blog.csdn.net/eci__/article/details/135407573

版权

Java基础专栏收录该内容

10 篇文章 0 订阅

订阅专栏

接口

接口就是给出一些没有实现的方法，封装到一起，到某个类要使用的时候，在根据具体情况把这些方法写出来。在Java中，接口（Interface）是一种抽象类型，它定义了一组抽象方法，但不提供这些方法的具体实现。接口是Java编程语言中实现多继承的主要机制之一，它允许一个类实现多个接口，从而具有多个行为。

nterface 接口名{

//属性

//方法（1 抽象方法 2 默认实现方法 3 静态方法）

}

public interface MyInterface {
    // 抽象方法
    void abstractMethod();

    // 常量（默认为 public static final）
    int MY_CONSTANT = 42;

    // 默认方法（Java 8+）
    default void defaultMethod() {
        System.out.println("Default method implementation");
    }

    // 静态方法（Java 8+）
    static void staticMethod() {
        System.out.println("Static method implementation");
    }
}

类通过 implements 关键字实现接口，并提供接口中定义的抽象方法的具体实现。

class 类名 implements 接口{

自己属性

自己方法

必须实现的接口的抽象方法

}

public class MyClass implements MyInterface {
    @Override
    public void abstractMethod() {
        System.out.println("Abstract method implementation");
    }
}

接口的作用：

实现多继承： 类可以实现多个接口，从而具有多个接口定义的行为。这解决了Java中单继承的限制。
定义规范： 接口定义了一组规范，实现类必须提供接口中定义的方法的具体实现。这有助于代码的规范性和可维护性。
实现代码的组织和模块化： 接口有助于将代码分解为模块，提供了一种良好的组织结构，使得代码更易于理解和维护。
默认方法和静态方法（Java 8+）： 接口可以包含默认方法和静态方法，为接口的演变提供了更大的灵活性，同时也提供了在接口中添加新功能而不破坏实现类的机制。
实现回调机制： 接口可以用于实现回调（Callback）机制，其中一个类实现接口的方法，而另一个类在需要时调用这些方法。

注意事项和细节：

1.接口不能被实例化

2.接口中所有方法是 public 方法，接口中抽象方法，可以不用 abstract 修饰

3.一个普通类实现接口，就必须将该接口的所有方法都实现

4.抽象类实现接口，可以不用实现接口的方法

5.一个类可以实现多个接口

6.接口中的属性，只能是 final 的，而且是 public static final 修饰符

7.接口中属性的访问形式：接口名.属性名

8.一个接口不能继承其他的类，但是可以继承多个别的接口（接口和接口之间是继承的关系）

9.接口的修饰符只能是 public 和默认，这点和类的修饰符是一样的

小结：当子类继承了父类，就自动的拥有了父类的功能。

如果子类需要扩展功能，可以通过实现接口的方式扩展。

可以理解实现接口是对 Java 单继承机制的一种补充。

接口的多态

多态参数

public class jkCanshuDuotai {
    public static void main(String[] args) {
//      接口的多态体现
//      接口类型的变量 if01 可以指向 实现了 IF 接口类的对象实例
        IF if01 = new Monster();
        if01 = new Car();
        
//      继承体现的多态
//      父类类型的变量 a 可以指向 继承 AAA 的子类的对象实例
        AAA a = new BBB();
        a = new CCC();
    }
}


interface IF {}
class Monster implements IF {}
class Car implements IF {}

class AAA {}

class BBB extends AAA {}
class CCC extends AAA {}

多态数组

public class jkDuoTai {
    public static void main(String[] args) {
        Usb[] usbs = new Usb[2];
        usbs[0] = new Phone_();
        usbs[1] = new Camera();
        for (int i = 0;i <usbs.length;i++) {
            usbs[i].work();
            //需要进行向下转型
            if (usbs[i] instanceof Phone_) {    //判断他的运行类型是否是Phone_
                ((Phone_) usbs[i]).call();
            }
        }
    }
}


interface Usb {
    void work();
}

class Phone_ implements Usb {
    
    public void call() {
        System.out.println("手机可以打电话...");
    }

    @Override
    public void work() {
        System.out.println("手机正在工作...");
    }
}

class Camera implements Usb {

    @Override
    public void work() {
        System.out.println("相机正在工作...");
    }

}

内部类

一个类的内部又完整的嵌套了另一个类结构。被嵌套的类称为内部类，嵌套其他类的类称为外部类。是我们类的第五大成员（属性，方法，构造器，代码块，内部类），内部类最大的特点就是可以直接访问私有属性，并且体现类与类之间的包含关系。

基本语法：

class Out { //外部类

class In { //内部类

}

class Other { //外部其他类

}

Java内部类有四种类型：成员内部类（Member Inner Class）、局部内部类（Local Inner Class）、匿名内部类（Anonymous Inner Class）和静态嵌套类（Static Nested Class）。

成员内部类

public class OuterClass {
    // 外部类的成员和方法...

    // 成员内部类
    public class InnerClass {
        // 内部类的成员和方法...
    }
}

作用：

封装性和可读性： 内部类可以访问外部类的私有成员，从而提高封装性。同时，它可以使代码更有层次感，增强可读性。
关联性： 内部类与外部类之间建立了一种关联关系，可以更方便地访问外部类的成员。
实现多继承： 内部类使得一个类可以有多个不同的实现，从而实现多继承的一种形式。

局部内部类

public class OuterClass {
    // 外部类的方法...

    public void someMethod() {
        // 局部内部类
        class LocalInnerClass {
            // 内部类的成员和方法...
        }

        // 在方法中创建局部内部类的对象
        LocalInnerClass a = new LocalInnerClass();
    }
}

作用：