Java 内部类-CSDN博客

本文链接：https://blog.csdn.net/2301_78671299/article/details/135822472

内部类概念

在一个类中定义一个类。

内部类定义格式

格式：
class 外部类名{
    修饰符 class 内部类名{
    }
}

内部类访问特点

内部类可以直接访问外部类的成员，包括私有

外部类要访问内部类的成员，必须创建对象

成员内部类

成员内部类定义在类中，跟成员变量是一个位置

外界创建成员内部类格式

格式：外部类名.内部类名 对象名 = 外部类对象.内部类对象；
举例：Outer.Inner oi = new Outer().new Inner();

私有成员内部类

将一个类，设计为内部类的目的，大多数都是不想让外界去访问，所以内部类的定义应该私有化，私有化之后，再提供一个可以让外界调用的方法，方法内部创建内部类对象并调用。

静态成员内部类

静态成员内部类访问格式：外部类名.内部类名 对象名 = new 外部类名.内部类名（）；
Outer.Inner oi = new Outer.Inner();
静态成员内部类中的静态方法：外部类名.内部类名.方法名（）；
Outer.Inner.method();

局部内部类

局部内部类定义在方法中的类

局部内部类访问方式

局部内部类，外界无法直接使用，需要在方法内部创建对象并使用

该类可以直接访问外部类的成员，也可以访问方法内的局部变量

匿名内部类

匿名内部类前提

存在一个类或者接口，这里的类可以是具体类也可以是抽象类

匿名内部类的格式

格式：new 类名（）{重写方法}   new 接口名（）{重写方法}
举例
new Inter(){
    @Override
    public void method(){}
}

匿名内部类本质

本质：是一个继承了该类或实现了该接口的子类匿名对象

匿名内部类可以通过多态的形式接受

Inter i = new Inter(){
  @Override
    public void method(){
        
    }
}

匿名内部类直接调用方法

interface Inter{
    void method();
}

class Test{
    public static void main(String[] args){
        new Inter(){
            @Override
            public void method(){
                System.out.println("匿名内部类");
            }
        }.method();	// 直接调用方法
    }
}

扩充：

lambda表达式

格式：

(形式参数) -> {代码块}

形式参数：如果有多个参数，参数之间用逗号隔开；如果没有参数，留空即可

->：由英文中画线和大于符号组成，固定写法。代表指向动作

代码块：是我们具体要做的事情，也就是以前我们写的方法体内容

组成Lambda表达式的三要素：

形式参数，箭头，代码块

Lambda省略规则

public interface Addable {
    int add(int x, int y);
}

public interface Flyable {
    void fly(String s);
}

public class LambdaDemo {
    public static void main(String[] args) {
//        useAddable((int x,int y) -> {
//            return x + y;
//        });
        //参数的类型可以省略
        useAddable((x, y) -> {
            return x + y;
        });

//        useFlyable((String s) -> {
//            System.out.println(s);
//        });
        //如果参数有且仅有一个，那么小括号可以省略
//        useFlyable(s -> {
//            System.out.println(s);
//        });

        //如果代码块的语句只有一条，可以省略大括号和分号
        useFlyable(s -> System.out.println(s));

        //如果代码块的语句只有一条，可以省略大括号和分号，如果有return，return也要省略掉
        useAddable((x, y) -> x + y);
    }

    private static void useFlyable(Flyable f) {
        f.fly("风和日丽");
    }

    private static void useAddable(Addable a) {
        int sum = a.add(10, 20);
        System.out.println(sum);
    }
}

Lambda表达式使用前提

使用Lambda必须要有接口

并且要求接口中有且仅有一个抽象方法

Lambda表达式和匿名内部类区别

1. 所需类型不同

匿名内部类：可以是接口，也可以是抽象类，还可以是具体类

Lambda表达式：只能是接口

2. 使用限制不同

如果接口中有且仅有一个抽象方法，可以使用Lambda表达式，也可以使用匿名内部类

如果接口中多于一个抽象方法，只能使用匿名内部类，而不能使用Lambda表达式

3. 实现原理不同

匿名内部类：编译之后，产生一个单独的.class字节码文件