内部类

内部类的分类

• 也可以分成两大类
  • 成员内部类（静态内部类、成员内部类）
  • 局部内部类（方法内部类、匿名内部类）

区别

• 如果定义在方法里面，该类就是为方法内部类或者是局部内部类

• 如果定义在方法外面，该类就是为成员内部类，如果加上static静态修饰，则该类是为静态内部类

成员内部类

案例

public class _181InteriorClass {
    private int age=20;
    public class _181NeiBuLei{
        public void get(){
            System.out.println(age);  //内部类中可以直接访问到 外部类中的成员属性（包括私有）
        }
    }
    public void _181useInterior(){
        _181NeiBuLei neiBuNei=new _181NeiBuLei();
        neiBuNei.get();
    }
}

测试及结果

public class _181Test {
    public static void main(String[] args) {
        _181InteriorClass interior=new _181InteriorClass();
        interior._181useInterior();

        //在外界想直接访问内部类
        //格式：外部类.内部类    new 外部类().new 内部类();
        //一般在企业实际开发中 外界不能直接访问内部类，内部类应该为私有的
        _181InteriorClass._181NeiBuLei neiBuNei = new _181InteriorClass().new _181NeiBuLei();
        neiBuNei.get();
    }
}

静态内部类

案例

public class _183StaticInterior {

    private static int code=200;
    public static void show(){ //要想在内部类中访问外部类的成员，必须加上静态static
        System.out.println("外部类中的show()方法");
    }

    public static class _183NeiBULei{
        public void get(){
            show();
            System.out.println("静态内部类中的方法");
            System.out.println(code);
        }
    }
    /**
     * 在我们内部类.外部类 中的静态方法，如果访问内部类
     * 则该内部类 必须是为静态
     */
    public static void main(String[] args){  //主方法中有static
        _183NeiBULei neiBULei=new _183NeiBULei();
    }
}

测试及运行结果

public class _183Test {
    public static void main(String[] args) {
        //外界如果访问 静态内部类，new 外部类.内部类()
        _183StaticInterior._183NeiBULei neiBULei=new _183StaticInterior._183NeiBULei();
        neiBULei.get();
    }
}

局部内部类

案例

public class _184LocalInterior {
    private int code=200;
    private int age=20;
    /**
     * 在方法里面定义的内部类 就是为 局部内部类(方法内部类)
     */
    public void localInterior(){
        class  _184NeiBuLei{ //局部内部类(方法内部类)
            public void neiBuLei(){
                System.out.println("我是局部内部类的方法");
                System.out.println(code);
                System.out.println(age);
                show();  //内部类中能调用外部类中的成员
            }
        }
        _184NeiBuLei neiBuLei=new _184NeiBuLei();
        neiBuLei.neiBuLei();
    }
    private void show(){
        System.out.println("外部类中的show方法");
    }
    //报错，局部内部类 只能在该方法里面访问 不能够在外界(方法外面)访问
    /*public void show(){
        _184NeiBuLei neiBuLei=new _184NeiBuLei();
        neiBuLei.neiBuLei();
    }*/
}

测试及运行结果

public class _184Test {
    public static void main(String[] args) {
        _184LocalInterior localInterior=new _184LocalInterior();
        localInterior.localInterior();
    }
}

匿名内部类

匿名内部类:new 接口或者抽象类，其实在Java编译阶段（运行程序时）。底层是自动帮我们创建了实现类，实现了该接口或者创建了子类继承了抽象类。

匿名接口

public interface _185AnonymousInterior {
    void jiekou();
}

匿名抽象类

public abstract class _185AbstrctInterior {
    public abstract void AbstrctClass();
}

测试及运行结果

public class _185Test {
    public static void main(String[] args) {
        //匿名内部类  就不需要创建实现类了
        _185AnonymousInterior anonymousInterior =new _185AnonymousInterior() {
            //重写了  接口中的方法
            @Override
            public void jiekou() {
                System.out.println("我是匿名内部类的接口方法");
            }
        };
        anonymousInterior.jiekou();
        /**
         *使用我们的匿名内部类 就不需要创建我们的实现类和子类
         * 直接通过new 内部类的形式 简化不需要创建 实现类和子类
         * 一般用于函数接口
         */
        //new出来的抽象类，底层实际上创建了我们的子类
         _185AbstrctInterior  abstrctInterior=new _185AbstrctInterior(){
             @Override
             public void AbstrctClass(){
                 System.out.println("我是匿名内部类的抽象类方法");
             }
         };
         //使用匿名内部类 是可以直接不需要写实现的
        abstrctInterior.AbstrctClass();
    }
}