类（成员内部类，局部内部类）

public class Outer {
    private int num = 20;

    public class Inner {
        //        public void show(){
//            System.out.println(num);
//        }
        private void show() {
            System.out.println(num);
        }

        public void method() {
            show();
        }
    }
}

public class InnerDemo {
    public static void main(String[] args) {
        //创建内部对象，但是这种只是针对修饰为public，如果内部类是private就不行了
        Outer.Inner inner = new Outer().new Inner();
//        inner.show();   因为show为私有的，所以不能直接调用
        inner.method(); //show是私有的但是在一个外部类就可以互相调用，又因为method是公共的，所以可以调用method到达调用show
    }
}

上边是成员内类：成员内部就是直接外部类里面的，如果那个内部类是public的，那么在main中就，想要调用内部类的方法然后让他输出出来就需要创建对象，可以这样创建：

Outer.Inner inner = new Outer().new Inner(); 

这个是内部类，所以可以直接调用里面的方法，但是如果private的那么就无法在main中调用了，因为私有的只能在一个类中用所以这个时候就需要在内部类弄一个public的方法去调用那个私有的然后再到main中调用public的。

注意：为什么在Outer中的num也是私有的但是可以在Inner中调用？
           答：个人理解是因为num是成员变量在外部类，而内部类也是属于外部类他两个是同级别的，所以就可以调用。

局部变量类：就是外部类里面有个方法，然后在方法里，而不是直接属于外部类，只能在方法里面用这个类，想要用这个类需要先调用这个方法所以称为局部变量；

public class Outer {
    private int num = 25;

    public void method() {
        //因为方法需要用对象来调用，所以OutDemo中想要调用让他输出出来就需要先把这个方法弄个对象再调他的方法
        class Inner {
            public void show() {
                System.out.println(num);
            }
        }
        Inner inner = new Inner();
        inner.show();
    }
}

public class OutrDemo {
    public static void main(String[] args) {
        Outer outer = new Outer();
        outer.method();
    }
}

如上代码是局部内部类的代码：因为想要用类里面的东西，必须要先把类弄成一个对象然后再调用，所以就有了在Outer这个类中的method方法的Inner的对象处理然后调用Inner对象的show方法。如果直接不创建内部类的对象直接调用Inner就会什么都输出不出来

匿名内部类：
        

/*
     前提：
          存在一个类或者接口
          这里的类可以是具体类也可以是抽象类
     格式：
          new 类名或者接口名(){
              重写方法
          };
      本质是什么？
           是一个继承了该类或者实了该类的子接口匿名对象
 */
public class Outer {
    public void method() {
//        new Inter() {
//            @Override
//            public void show() {
//                System.out.println("匿名内部类");
//            }
//        }.show(); //这个Inter上边也说了本质就是对象，所以可以直接.方法名称()
        /*
        如多次需要调用匿名类的方法就需要如下操作,直接将这个对象赋值给接口，然后调用重命名的
         */
       Inter inter = new Inter() {
            @Override
            public void show() {
                System.out.println("匿名内部类");
            }
        }; //这个Inter上边也说了本质就是对象，所以可以直接.方法名称()
        inter.show();
    }
}

public class OuterDemo {
    public static void main(String[] args) {
        Outer outer = new Outer();
        outer.method();
    }
}

public interface Inter {
    void show();
}

以上是匿名内部类的代码：因为它的前提就是有个接口或者类然后格式是new 这个存在的接口，所以就有了Inter这个接口在Outer中被这样操作：new Inner（）｛｝

注意：这个new Inner｛｝本身就是一个对象在本质中也提到了，所以比如在Outer中操作完然后想要调用Inner的show方法可以直接new Inner{.....注意这里是继承的方法然后重写的}.show();这样就可以，但是如果Inner有多个方法想要都调用这样就太麻烦了，这时候可以将new Inner赋值给 Inner然后起一个名字为inter，然后就可以inter.show()来完成了，就方便了很多