---

一、内部类

一个类的定义出现在另外一个类，那么这个出现的类就叫内部类(Inner)。
内部类所在的类叫做外部类(Outer)。

二、应用特点

一个类对应提供的内容仅仅是为某一个类单独服务
可以直接访问外部类的私有的成员变量

三、分类

3.1、普通内部类：直接将一个类的定义放在另外一个类的类体中

1、定义格式

2、调用方式

3、特点：
普通内部类和普通类一样
普通内部类权限修饰符都可以用
创建调用普通内部类，需要外部类实例对象来创建内部类对象
final可修饰内部类

4、案例

内部类访问外部类的成员变量：外部类类名.this.id
内部类访问内部类的成员变量：this.id
直接访问id：形参中传递的id

package com.company.innerp;

public class NormalInnerDemo {
    //成员变量
    private int id = 1;
    //定义普通内部类
    public class NormalInner{
//    private class NormalInner{
        //内部类的成员变量
        private String name = "inner";
        private int id =2;

        public NormalInner(String name){
            this.name=name;
            System.out.println("普通内部类NormalInner的有参构造方法");
        }
        public NormalInner(){
            System.out.println("普通内部类NormalInner的无参构造方法");
        }
        public void show(){
            //可以直接访问外部类的私有化的成员变量
            System.out.println("外部类NormalInnerDemo变量id"+id);
            System.out.println("普通内部类NormalInner变量name"+name);
        }

        public void show1(int id){
            //可以直接访问外部类的私有化的成员变量
            System.out.println("变量id:"+id);  //形参内容  就近原则
            System.out.println("外部类id:"+ NormalInnerDemo.this.id);  //外部类的id  类名.this.id
            System.out.println("内部类id:"+ this.id);         //内部类的id    this.id
        }
    }
}

package com.company.innerp;

public class innerTest {
    public static void main(String[] args) {
        //1、外部类实例化
        NormalInnerDemo outer = new NormalInnerDemo();
        //2、普通内部类实例化
        NormalInnerDemo.NormalInner inner = outer.new NormalInner();

        //3、调用show方法
        inner.show();

        inner.show1(8);
    }
}

3.2、静态内部类

使用static修饰的内部类，属于类层级。

1、定义格式

2、调用方式

3、特点
静态内部类：不能直接访问外部类的非静态成员。
静态内部类：可以直接创建对象
如果静态内部类访问外部类中与本类同名的成员变量或者方法时，需要使用类名.的方式访问。

案例：静态内部类：不能直接访问外部类的非静态成员。

package com.company.innerp;

public class StaticInnerDemo {
    //成员变量
    private int id = 1;
    private static int sid = 2;

    //定义静态内部类
    public static class StaticInner{
        //内部类的成员变量
        private String name = "inner";
//        private int id =2;
        private static int sid =4;

        public StaticInner(){
            this.name=name;
            System.out.println("静态内部类StaticInner的构造方法");
        }

        public void show(){
            //可以直接访问外部类的私有化的成员变量
            System.out.println("外部类StaticInner的静态变量sid"+ sid);
            System.out.println("内部类StaticInner的成员变量sid"+ sid);

//            System.out.println("外部类StaticInner的成员变量id"+ id);
        }

        public void show1(int sid){
            System.out.println("-----------------------------------------------------");
            System.out.println("形参变量sid:"+sid);   //局部优先
            //内部类的成员id
            System.out.println("静态内部类StaticInner的静态成员变量sid值是："+StaticInner.sid);
            System.out.println("静态外部类StaticInnerDemo的静态成员变量sid值是："+StaticInnerDemo.sid);

        }

    }


    public static void main(String[] args) {
        StaticInnerDemo.StaticInner s=new StaticInnerDemo.StaticInner();
        s.show();
        s.show1(8);
    }
}

执行结果：

静态内部类StaticInner的构造方法
外部类StaticInner的静态变量sid4
内部类StaticInner的成员变量sid4
-----------------------------------------------------
形参变量sid8
静态内部类StaticInner的静态成员变量sid值是：4
静态外部类StaticInnerDemo的静态成员变量sid值是：2

Process finished with exit code 0

3.3、局部内部类

直接将一个类的定义放在方法体的内部
1、定义格式

2、调用

3、特点：
局部内部类只能在方法的内部可以使用
局部内部类可以在方法体内直接创建对应对象

package com.company.innerp;

public class JubuInnerDemo {
    private int aid = 2;

    public void show(){
        //定义局部内部类 局部内部类：只在当前方法体的内部使用 不能用访问修饰符
        class AreaInner{
            private int id = 1;

            public AreaInner() {
                System.out.println("局部内部类AreaInner的构造方法");
            }

            public void testArea(){
                System.out.println("局部内部类AreaInner的id的值："+id);
                System.out.println("AreaInnerDemo的aid的值："+aid);

            }
        }

        //声明局部内部类的引用指向局部内部类的对象
        AreaInner areaInner = new AreaInner();
        areaInner.testArea();

    }
}