Java方法内部类的介绍，代码演示

/**
内部类就是在一个类的内部定义的类
//成员
1.
成员内部格式如下:
class Outer{
    class inner{}
}
编译上述代码会产生两个文件:
Out.class和Out$Inner.class

2.方法内部类
 方法内部类只能定义该内部类的方法内实例化，不能再此方法外对其实例化
 方法内部类对象不能使用该内部类所在党法的非final局部变量


 //局部
 3.静态内部类
  静态的含义是该内部类可以像其他静态成员一样，没有外部类对象时，也能够访问它
  静态嵌套类仅能访问外部类的静态成员和发放

4.匿名内部类就是没有名字的内部类。
匿名内部类的三种情况
1.继承式的匿名内部类
2.接口式的匿名内部类
3.参数式的匿名内部类

注意：
1.不能有构造方法
2.不能定义任何静态成员、静态方法
3.不能是public,protect,private,static
4.一定是在new的后面，用其隐含实现一个接口或实现一个类。
5.匿名内部类为局部的，所以局部内部类的所有限制都对其生效

项目如何选择
1.优先静态内部类，静态内部类不依赖外部类的对象(内存泄漏)
 */
public class neibulei{
    public static void main(String[] args) {
        Outer outer=new Outer();
        outer.show(11);
       
        //在外部创建成员内部内的实例,因为成员内部需要依赖外部类的对像，
        //通常情况下不建议这样来实例化内部的对象
       Outer.Inner inner=outer.new Inner();
      inner.print();
        Outer.Inner3 inner3=new Outer.Inner3();
        inner3.print();
         outer.print1();
         outer.print2();
         outer.print3(new Eat(){
             public void eat(){
                 System.out.println("参数匿名式内部类");
             }
         });
    }
}
class Outer{
    private String name;
    public Outer(){}
    //------------成员内部类----------
    //内部封装，建议private,对外提供访问内部类的接口
    private void innerPrinta(){
        Inner inner=new Inner();
        inner.print();
    }
    //成员内部类
    class Inner{
        public void print(){
            System.out.println("成员内部类");
        }
    }
    //--------------方法内部类---------
    //show方法的局部变量或方法的参数，实际上必须是常量final,jdk1.8,x默认为final
    public void show(final int x){
        //final int x=10;
        class Inner2{
            public void print(){
                System.out.println("方法内部类"+x);
            }
        
        }
        Inner2 inner2=new Inner2();
        inner2.print();
    }
    //------------静态内部类-------
    static class Inner3{
        public void print(){
            System.out.println("静态内部类");
        }
    }



    //-----------匿名内部类------------

    //继承式
    public void print1(){
        Cat cat =new Cat(){
            public void eat(){
                System.out.println("eat:继承式匿名内部类");
            }
        };
        cat.eat();
    }
     //接口式
     public void print2(){
         Eat eat =new Eat(){
            public void eat(){
                System.out.println("eat:接口式匿名内部类");
            }
         };
         eat.eat();
     }
     //参数式
     public void print3(Eat eat){
        eat.eat();
     }
}
abstract class Cat{
    public abstract void eat();
}
interface Eat{
    public void eat();
}