将一个类定义在另一个类里面,就是内部类。

基本的内部类。
public class InnerBasic {

    private int id;
    protected String name;
    static int age;

    abstract class Inner {
        public String inner;

        void test() {
            this.inner = name;
        }
    }

    private class PInner {

    }

    final class Inners {
        String iname = name;
        int id = new InnerBasic().id;

        InnerBasic getOut() {
            return InnerBasic.this; // 返回对外部类对象的引用
        }
    }

    static class Innert {
        int idt = age;
        String s = new InnerBasic().name;

        Object test() {
            class Testt {
                void xxx() {
                    System.out.println("xxx");
                }
            }
            return new Testt();
        }

    }

    public static void test1() {
        Innert inner = new Innert(); // static
        Inners inners = new InnerBasic().new Inners();
    }

    public void test() {
        Innert innert = new Innert(); // static
        InnerBasic.Inners inner = new InnerBasic.Inners();
    }
}


局部内部类
package com.javase.innerclass;

public class MethodInnerClass {
    public IService getService (final String s) {
        final int count = 100; // 可以使用count 不能修改,final/这里看起来像闭包, 但是完全不同。 这个方法结束,count作用域结束.
        final Person person = new Person();
        class InnerService implements IService {
            String name;
            InnerService(String name) {
                this.name = name;
            }
            
            @Override
            public void test() {
                this.name = s;
                System.out.println("method inner test" + count + name +person.province);
            }
        }
        return new InnerService(s);
    }
}

匿名内部类// 对于匿名类而言,实例初始化的实际效果就是构造器,。不能重载实例初始化方法,所以只能有一个构造器。
匿名内部类与正规的继承相比有些受限,因为匿名内部类可以扩展类, 也可以实现接口,但不能两者兼备。
public class AnonymityClass {
    
    public void print() {
        System.out.println("print");
    }
    
    IService test() {
        new AnonymityClass() {        
            
        }.print();
        
        Comparator<Person> comparator =    new Comparator<Person>() {
            @Override
            public int compare(Person o1, Person o2) {
                return (o1.id > o2.id ? 1 : -1);
            }
        };
        
        List<Person> list = new ArrayList<Person>();
        Collections.sort(list, comparator);
        
        return new IService() {
            @Override
            public void test() {
                
            }
        };
    }
}

Java内部类