1. 成员内部类/非静态嵌套类 (Nested Classes / Inner Classes)

必须依赖外部类对象来创建

成员内部类 不支持静态成员属性(但支持常量)和静态成员方法

• 类的定义

package src.study;

// 外部类
public class OutService {
    public void dump() {
        System.out.println("out service");
    }

    public int value = 10;

    public static int valueStatic = 20;

    public static final int valueStaticFinal = 30;

    // 实例化内部类
    public InnerService getInnerService() {
        return new InnerService();
    }

    // 成员内部类
    public class InnerService {

        public int value = 1;

        //jdk版本需要>=16才可以实现
        //public static int valueStatic = 2;

        public static final int valueStaticFinal = 3;

        public void dump() {
            System.out.println("inner service");
        }
    }
}

• 声明并实例化类

 // 第一种方式
OutService.InnerService innerService1 = new OutService().new InnerService();

// 第二种方式
OutService.InnerService innerService2 = new OutService().getInnerService();

• 访问成员的方式

  • [类名].this.[非静态成员 / 静态成员]
    • OutService.this.value;
  • [类名].[静态成员]
    • OutService.valueStatic;
  • this.[非静态成员 / 静态成员]
    • this.value;
  • [非静态成员 / 静态成员] ：如果是内部类使用该访问方式并且内部类并没有该成员，则会去外部类中查找
    • value;
    • valueStatic;

2. 静态内部类/静态嵌套类 (Static Nested Classes)

可以不依赖外部类对象，直接创建

• 类的定义

package src.study;

// 外部类
public class OutService {
    public void dump() {
        System.out.println("out service");
    }

    public int value = 10;

    public static int valueStatic = 20;

    public static final int valueStaticFinal = 30;


    // 实例化静态内部类
    public StaticNestedService getStaticNestedService() {
        return new StaticNestedService();
    }

    // 静态内部类
    public static class StaticNestedService {

        public int value = 1;

        public static int valueStatic = 2;

        public static final int valueStaticFinal = 3;

        public void dump() {
            System.out.println("staticNestedService service");
        }
    }
}

• 声明并实例化类

// 第一种方式
OutService.StaticNestedService staticNestedService1 = new OutService.StaticNestedService();

// 第二种方式
OutService.StaticNestedService staticNestedService2 = new OutService().getStaticNestedService();

• 访问成员的方式

  • new [类名]().[非静态成员 / 静态成员]

    • new OutService().value;

  • [类名].[静态成员]

    • OutService.valueStatic;

  • this.[非静态成员 / 静态成员]

    • this.value;
    • this.valueStatic;

  • [非静态成员 / 静态成员] ：如果是内部类使用该访问方式并且内部类并没有该成员，则会去外部类中查找

    • value;
    • valueStatic;

3. 方法内部类/本地类 (Local Classes)

只能在定义该内部类的方法内进行使用

• 类的定义

package src.study;

// 外部类
public class OutService {
    public void dump() {
        System.out.println("out service");
    }

    public int value = 10;

    public static int valueStatic = 20;

    public static final int valueStaticFinal = 30;

    public Object getLocalService() {
        // 方法内部类
        class LocalService {
            public int value = 1;

            //jdk版本需要>=16才可以实现
            //public static int valueStatic = 2;

            public static final int valueStaticFinal = 3;

            public void dump() {
                System.out.println("localService service");
            }
        }

        return new LocalService();
    }
}

• 声明并实例化类 (一般都在方法内使用，脱离该方法就无效了)

Object localService = new OutService().getLocalService();

• 访问成员的方式

  • [类名].this.[非静态成员 / 静态成员]
    • OutService.this.value;
  • [类名].[静态成员]
    • OutService.valueStatic;
  • this.[非静态成员 / 静态成员]
    • this.value;
  • [非静态成员 / 静态成员] ：如果是内部类使用该访问方式并且内部类并没有该成员，则会去外部类中查找
    • value;
    • valueStatic;

4. 匿名内部类 (Anonymous Classes)

将类的定义、类的创建放在一起完成

• 类的定义、类的创建

package src.study;

public abstract class BaseService {
    public abstract void dump();
}

import src.study.BaseService;

public class HelloWorld {

    public static void dump(BaseService baseService) {
        baseService.dump();
    }

    public static void main(String[] args) {
        dump(new BaseService() {
            @Override
            public void dump() {
                System.out.println("hello world");
            }
        });
    }
}