接口，匿名内部类-CSDN博客

一、接口（Interface）

接口不能实例化，实现类必须重写所有抽象方法
接口中默认成员：public static final 常量、public abstract 抽象方法

// 1. 定义接口
interface Animal {
    // 常量：默认 public static final
    int LEG_NUM = 4;

    // 抽象方法：默认 public abstract
    void eat();
    void sleep();
}

// 2. 类实现接口（必须重写所有抽象方法）
class Dog implements Animal {
    // 重写抽象方法
    @Override
    public void eat() {
        System.out.println("小狗吃骨头");
    }

    @Override
    public void sleep() {
        System.out.println("小狗趴着睡");
    }
}

// 测试
public class InterfaceTest {
    public static void main(String[] args) {
        Animal dog = new Dog(); // 多态：接口引用指向实现类对象
        dog.eat();
        dog.sleep();
        System.out.println(Animal.LEG_NUM); // 调用接口常量
    }
}

JDK8+ 接口新特性

JDK8 打破了接口只能有抽象方法的限制，新增：

默认方法（default）：带方法体，实现类可直接用 / 重写

静态方法（static）：带方法体，接口名直接调用，实现类不能继承

私有方法（private，JDK9+）：供接口内部默认 / 静态方法复用，外部无法调用

interface Car {
    // 1. 默认方法
    default void run() {
        System.out.println("汽车在行驶");
        start(); // 调用私有方法
    }

    // 2. 静态方法
    static void stop() {
        System.out.println("汽车熄火");
    }

    // 3. 私有方法（JDK9+）
    private void start() {
        System.out.println("发动机启动");
    }
}

// 实现类
class BMW implements Car {}

// 测试
class Test {
    public static void main(String[] args) {
        Car bmw = new BMW();
        bmw.run(); // 调用默认方法
        Car.stop(); // 调用静态方法（必须用接口名）
    }
}

二、内部类（Inner Class）

1. 内部类概念

定义在类内部、方法内部的类，称为内部类
内部类可以直接访问外部类的私有成员，外部类需要创建内部类对象访问内部成员
分类：成员内部类、静态内部类、局部内部类、匿名内部类

三、成员内部类（最常用）

1. 定义

定义在外部类成员位置（和成员变量、方法同级），无 static 修饰

2. 特点

可以直接访问外部类所有成员（包括私有）
外部类访问内部类：必须创建内部类对象
成员内部类不能定义静态成员（除了静态常量）

3. 代码示例

// 外部类
class Outer {
    private String outerName = "外部类私有成员";

    // 成员内部类
    class Inner {
        private int innerAge = 20;

        // 内部类方法：访问外部类私有成员
        public void show() {
            System.out.println(outerName); // 直接访问外部私有成员
            System.out.println("内部类年龄：" + innerAge);
        }
    }

    // 外部类方法：访问内部类
    public void test() {
        Inner inner = new Inner();
        System.out.println(inner.innerAge);
    }
}

// 测试
class MemberInnerTest {
    public static void main(String[] args) {
        // 【创建成员内部类对象格式】：外部类.内部类 对象名 = new 外部类().new 内部类();
        Outer.Inner inner = new Outer().new Inner();
        inner.show();

        // 调用外部类方法
        Outer outer = new Outer();
        outer.test();
    }
}

四、匿名内部类（开发 / Android 高频）

1. 定义

没有名字的局部内部类，本质是继承了类 / 实现了接口的子类对象

2. 使用场景

接口 / 抽象类只使用一次，不想单独写实现类
简化代码，快速创建对象

3.格式

new 父类/接口() {
    // 重写方法
};

4. 代码示例

// 接口
interface Fly {
    void fly();
}

// 测试
public class AnonymousInnerTest {
    public static void main(String[] args) {
        // 匿名内部类：直接创建接口的实现类对象（无需单独写类）
        Fly bird = new Fly() {
            // 重写抽象方法
            @Override
            public void fly() {
                System.out.println("小鸟在飞");
            }
        };
        bird.fly();

        // 简化写法：直接作为方法参数
        testFly(new Fly() {
            @Override
            public void fly() {
                System.out.println("飞机在飞");
            }
        });
    }

    public static void testFly(Fly f) {
        f.fly();
    }
}