内部类：

内部类即在一个类的内部再定义一个类，如在A类中定义一个B类，则B类是A类的内部类。

1.成员内部类
2.静态内部类
3.局部内部类
4.匿名内部类

public class Outer {//最外面的类，即外部类
    private int id;
    public void out(){
        System.out.println("这是外部类的方法");
    }

    class Inner{//内部类
        public void in(){
            System.out.println("这是内部类的方法");
        }
    }
}






public class Application {
    public static void main(String[] args) {
        Outer outer = new Outer();
        //先new外部类
        //通过外部类来实例化内部类：
        
        
        Outer.Inner inner = outer.new Inner();
        //实例化成员内部类inner

        inner.in();
        

    }
}
输出：
    这是内部类的方法

且内部类可以访问外部类的私有属性与私有方法：（但仅限于定义内部类时无static）

public class Outer {//最外面的类，即外部类
    private int id = 10;
    public void out(){
        System.out.println("这是外部类的方法");
    }

    class Inner{//内部类
        public void in(){
            System.out.println("这是内部类的方法");
        }
        //获得私有属性
        public void getID(){
            System.out.println(id);
        }
    }
}

public class Application {
    public static void main(String[] args) {
        Outer outer = new Outer();
        //先new外部类
        //通过外部类来实例化内部类：
        Outer.Inner inner = outer.new Inner();
        //实例化成员内部类inner

        //内部类可以访问外部类的私有属性
        inner.getID();
    }
}
输出：
    10

若内部类public static class Inner，则无法提取外部类的属性：

因为先通过static定义了内部类，而外部类反而在内部类之后才定义完成，因此若在内部类中提取外部类的属性（无论私有还是公有）都会报错。（静态先加载）

即：静态内部类无法访问非静态的属性

public class Outer {//最外面的类，即外部类

}
class A{//也是内部类，但是为java大文件中的内部类，并非Outer的内部类

}

一个java文件中只能有一个public class，但可以多个class

方法中的类：

public class Outer {//最外面的类，即外部类
    
    public void method(){
        class Inner{//局部内部类，类似于局部变量
            public void in(){
                
            }
        }
    }
}

匿名类：无名称的类

正常情况：

public class Test {
    public static void main(String[] args) {
        Apple apple = new Apple();//在方法中new类，即应该在方法中实例化类
    }
}
class Apple{
    public void eat(){
        System.out.println("1");
    }
}

注意：（应该在方法中实例化类）

通过匿名类调用类中的方法：

public class Test {
    public static void main(String[] args) {
        new Apple().eat();//此处并未实例化Apple类，而是直接调用类中的方法，即：匿名类的使用
    }
}
class Apple{
    public void eat(){
        System.out.println("1");
    }
}

没有使用名字来初始化类，不用将实例化的对象保存到变量中。

本身对接口而言不可以在方法中直接new接口，而使用匿名类则可以实现：

public class Test {
    public static void main(String[] args) {
            new UserService(){//这里即会默认返回一个无名的UserService对象，实现接口类
            @Override   //需要重写
            public void method() {
                
            }
        };
    }
}

interface UserService{
    void method();
}

即new接口处为：

UserService userService = new UserService(){//返回一个无名的UserService对象即默认userService，实现接口类
    @Override
    public void method() {

    }
};