Java中的内部函数：如何使用内部类和匿名类定义函数？

Java中内部函数指的是在一个类的内部定义的函数，可以使用内部类和匿名类来实现。内部函数相比于普通函数，可以访问外部类的私有变量和方法，也可以方便地调用外部类的方法。

内部类

内部类是一种定义在另一个类中的类，在Java中可以使用内部类来定义内部函数。内部类有四种类型：成员内部类、局部内部类、匿名内部类和静态内部类。

1. 成员内部类

成员内部类是定义在另一个类的内部的普通类。一个成员内部类可以访问外部类的所有成员变量和方法，即使是私有的。

定义成员内部类的语法如下：

public class OuterClass {
    //外部类成员变量
    private int data = 100;
    
    //成员内部类
    public class InnerClass {
        //内部类方法
        public void display() {
            System.out.println("Data = " + data);
        }
    }
    
    //主方法
    public static void main(String[] args) {
        //创建外部类对象
        OuterClass outer = new OuterClass();
        //通过外部类对象创建内部类对象
        InnerClass inner = outer.new InnerClass();
        //调用内部类方法
        inner.display();
    }
}

在这个例子中，InnerClass是一个成员内部类，可以直接访问外部类的私有变量data。在主方法中通过创建外部类对象outer，然后使用outer.new InnerClass()创建内部类对象inner，最后调用内部类方法display()。

2. 局部内部类

局部内部类是定义在一个方法或代码块中的类，局部内部类只在它所在的方法或代码块中有效，不能被外部类的其他方法访问。

定义局部内部类的语法如下：

public class OuterClass {
    //外部类方法
    public void display() {
        //局部内部类
        class InnerClass {
            //内部类方法
            public void print() {
                System.out.println("Hello World");
            }
        }
        //创建内部类对象
        InnerClass inner = new InnerClass();
        //调用内部类方法
        inner.print();
    }
    
    //主方法
    public static void main(String[] args) {
        //创建外部类对象
        OuterClass outer = new OuterClass();
        //调用外部类方法
        outer.display();
    }
}

在这个例子中，InnerClass是一个局部内部类，定义在display()方法中，只能在这个方法内部使用。在display()方法中通过创建内部类对象inner，然后调用内部类方法print()。

3. 匿名内部类

匿名内部类是没有名字的内部类，它在声明和定义同时完成，通常用来创建某个接口或抽象类的对象。

定义一个匿名内部类的语法如下：

public interface Greeting {
    public void sayHello();
}

public class OuterClass {
    //外部类方法
    public void display() {
        //匿名内部类
        Greeting greeting = new Greeting() {
            //实现接口方法
            public void sayHello() {
                System.out.println("Hello World");
            }
        };
        //调用接口方法
        greeting.sayHello();
    }
    
    //主方法
    public static void main(String[] args) {
        //创建外部类对象
        OuterClass outer = new OuterClass();
        //调用外部类方法
        outer.display();
    }
}

在这个例子中，Greeting是一个接口，定义了一个抽象方法sayHello()。然后在display()方法中使用了一个匿名内部类来实现Greeting接口的sayHello()方法，创建一个Greeting对象greeting，然后调用接口方法greeting.sayHello()。

4. 静态内部类

静态内部类是定义在一个类内部的静态类，它可以访问外部类的静态成员和方法，但不能访问外部类的非静态成员和方法。

定义静态内部类的语法如下：

public class OuterClass {
    //外部类静态变量
    private static int data = 100;
    
    //静态内部类
    public static class InnerClass {
        //静态内部类方法
        public static void display() {
            System.out.println("Data = " + data);
        }
    }
    
    //主方法
    public static void main(String[] args) {
        //调用静态内部类方法
        InnerClass.display();
    }
}

在这个例子中，InnerClass是一个静态内部类，定义在OuterClass中，并且是静态的。在主方法中可以通过OuterClass.InnerClass.display()来调用静态内部类的方法。

匿名类

匿名类是一种没有名字的类，可以在声明和定义同时完成。在Java中，使用匿名类可以轻松地实现接口、抽象类和父类的方法。

1. 实现接口

实现一个接口并创建接口对象的语法如下：

public interface Greeting {
    public void sayHello();
}

public class OuterClass {
    //外部类方法
    public void display() {
        //匿名类实现接口
        Greeting greeting = new Greeting() {
            //实现接口方法
            public void sayHello() {
                System.out.println("Hello World");
            }
        };
        //调用接口方法
        greeting.sayHello();
    }
    
    //主方法
    public static void main(String[] args) {
        //创建外部类对象
        OuterClass outer = new OuterClass();
        //调用外部类方法
        outer.display();
    }
}

2. 继承父类

继承一个父类并创建父类对象的语法如下：

public class Person {
    //父类方法
    public void display() {
        System.out.println("I am a person");
    }
}

public class OuterClass {
    //外部类方法
    public void display() {
        //匿名类继承父类
        Person person = new Person() {
            //重写父类方法
            public void display() {
                System.out.println("I am a boy");
            }
        };
        //调用父类方法
        person.display();
    }
    
    //主方法
    public static void main(String[] args) {
        //创建外部类对象
        OuterClass outer = new OuterClass();
        //调用外部类方法
        outer.display();
    }
}

3. 实现抽象类

实现一个抽象类并创建抽象类对象的语法如下：

public abstract class Shape {
    //抽象方法
    public abstract void draw();
}

public class OuterClass {
    //外部类方法
    public void display() {
        //匿名类实现抽象类
        Shape shape = new Shape() {
            //实现抽象方法
            public void draw() {
                System.out.println("Draw a circle");
            }
        };
        //调用抽象方法
        shape.draw();
    }
    
    //主方法
    public static void main(String[] args) {
        //创建外部类对象
        OuterClass outer = new OuterClass();
        //调用外部类方法
        outer.display();
    }
}

匿名类的缺点是，由于它没有名字，所以不能再其他地方使用它的实例。如果需要在多个地方使用相同类型的匿名类，就需要创建多个相同的匿名类实例。