java几种内部类的介绍及应用

优点：内部类能访问外部类的私有属性（类内都可操作）

外部类访问内部类需要实例化对象

一、成员内部类

直接实例化内部类

public class Outm {
    private static int id;
    protected static  double money;
   public class Inm{
        public void getid()
        {
            System.out.println(Outm.id);
        }
        public void  setmoney()
        {
            Outm.money=10;
        }
    }

    public static void main(String[] args) {
     Inm eg=new Outm().new Inm();
        eg.getid();
        eg.setmoney();
        System.out.println(Outm.money);
    }
}

外界调用成员内部类（内部类为公共类）：

外类.内类 对象 = new 外类 （）.new 内类（）；

私密内部类（private）：在外类创建方法 使其构建内类对象并调用

二、局部内部类

将内部类定义在外部类的方法中（调用需要类内实例化对象）

类定义：

package lins;

public class Outs {
    private int num =20;
    public void show()
    {
        class Inner
        {
       public void shown()
       {
           System.out.println(num);
       }}
            Inner inner =new Inner();
        inner.shown();
        }
    }

测试：

package lins;

public class Test {
    public static void main(String[] args) {
        Outs outs =new Outs();
        outs.show();
    }
}

三、匿名内部类    （局部内部类的一种特殊格式）

前提：存在一个类（具体和抽象都可）或者接口

格式：

new  接口名/类名 ()   //本质：继承了该类或者实现了该接口的子类匿名对象
{
重写方法 ；
}

定义：

 /*new Inner()
        {
            @Override  相当于一个匿名对象，仅仅是定义了而没调用
            public void show() {
                System.out.println("函数的调用");
            }
        }*/

提前接口

package lins;

public interface Inner {
    void show();
}

实现

package lins;

public class Outer {
    int num =10;
    void method()
    {
        new Inner()//匿名对象的第一种调用方式
        {
            @Override
            public void show() {
                System.out.println("函数的调用");
                System.out.println(num);
            }
        }.show();
       Inner i= new Inner()    //匿名对象的第二种调用方式
        {                     //接口引用指向实例匿名类，实现子类构建对象
            @Override
            public void show() {
                System.out.println("函数的调用");
                System.out.println(num);
            }

         };
        i.show();
    }
}

测试

package lins;

public class Test {
    public static void main(String[] args) {
       Outer outr =new Outer();
       outr.method();

    }
}

结果

匿名函数类在项目中的应用

接口：

package practicer;

public interface jumpping {
    void jump();
}

接口实现类：

package practicer;

public class ture implements jumpping {

    @Override
    public void jump() {
        System.out.println("跳高");
    }
}

方法  接口传参

package practicer;

public class doit {
    public void method (jumpping jumpr)
    {
        jumpr.jump();
    }
}

测试：

package practicer;

public class test {
    public static void main(String[] args) {
        jumpping jump =new ture();
       doit doi =new doit();
       doi.method(jump);//第一种调用
doi.method(new jumpping()    //第二种调用
{

    @Override
    public void jump() {
        System.out.println("我能跳高");
    }
});
    }
}

结果：