java面向对象——内部类

一、简介

基本概念

当一个类的定义出现在另一个类的类体中时，那么这个类叫做内部类（Inner），而这个内部类所在的类叫做外部类（Outer）。

实际作用

当一个类存在的价值仅仅是为某一个类单独服务时，那么就可以将这个类定义为所服务类中的内部类，这样可以隐藏该类的实现细节并且可以方便的访问外部类的私有成员而不再需要提供公用的get和set方法。

内部类的构成

成员变量、成员方法、构造方法、静态成员、构造块和静态代码块、内部类

内部类的分类

• 普通内部类：直接将一个类的定义放在另外一个类的类体中
• 静态内部类：使用static关键字修饰的内部类，隶属于类层级
• 局部内部类：直接将一个类的定义放在方法体的内部时
• 匿名内部类：就是指没有名字的内部类

二、普通（成员）内部类

处于类体中的类，成为内部类；

创建普通（成员）内部类

/*
格式：

访问修饰符 class 外部类的类名{
  访问修饰符 class 内部类的类名{
    内部类的类体；
	}
}

*/

public class NormalOuter {
    private int cnt = 1;

    // 定义普通内部类，隶属于外部类的成员，并且是对象层级
    public class NormalInner{
        private int ia = 2;
        private int cnt = 3;

        public NormalInner(){
            System.out.println("普通内部类的构造方法体已执行");
        }

        public void show(){
            System.out.println("外部类中变量cnt的数值为：" + cnt);
            System.out.println("ia = " + ia);
        }

        public void show2(int cnt){
            System.out.println("形参变量cnt = " + cnt);  // 局部优先原则
            System.out.println("内部类中cnt = " + this.cnt);
            System.out.println("外部类中cnt = " + NormalOuter.this.cnt);
        }
    }

}

初始化普通（成员）内部类

public class NormalOuterTest {
    public static void main(String[] args) {
        // 1、声明NormalOuter类型的引用，指向该类型的对象
        NormalOuter no = new NormalOuter();
        // 2、声明NormalOuter类中内部类的引用，指向内部类的对象
        NormalOuter.NormalInner ni = no.new NormalInner();
        // 3、调用内部类中的show方法
        ni.show();
        ni.show2(4);
    }
}

总结

• 普通内部类和普通类一样可以定义成员变量、成员方法以及构造方法等
• 普通内部类和普通类一样可以使用final或者abstract关键字修饰
• 普通内部类还可以使用private或protected关键字进行修饰
• 普通内部类需要使用外部类对象来创建对象
• 如果内部类访问外部类中与本类内部同名的成员变量或方法时，需要使用this关键字

三、静态内部类

使用static修饰的内部类，称为静态内部类；

创建静态内部类

/*
格式：

访问修饰符 class 外部类的类名{
  访问修饰符 static class 内部类的类名{
    内部类的类体；
	}
}

*/

public class StaticOuter {
    private int cnt = 1;        // 隶属于对象层级
    private static int snt = 2; // 隶属于类层级
    public void show(){
        System.out.println("外部类show方法");
    }

    /*
    * 定义静态内部类  有static关键字修饰属于类层级
    * */
    public static class StaticInner{
        private int ia = 3;
        private static int snt = 4;

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

        public void show(){
            System.out.println("ia = " + ia);
            System.out.println("外部类中的snt = "+ snt);
//            System.out.println("外部类中的snt = "+ cnt);   //Error 静态上下文中不能访问非静态的成员，因为此时可能未创建对象
        }

        public void show2(int snt){
            System.out.println("snt = " + snt);
            System.out.println("内部类中的成员snt = " + StaticInner.snt);
            System.out.println("外部类中的成员snt = " + StaticOuter.snt);
//            StaticOuter.show();
            new StaticOuter().show();  // 调用外部类非静态方法
        }
    }
}

初始化静态内部类

public class StaticOuterTest {
    public static void main(String[] args) {

        // 1、声明StaticInner类型的引用指向该类型的对象
        StaticOuter.StaticInner si = new StaticOuter.StaticInner();
        // 2、调用show方法进行测试
        si.show();
        si.show2(5);
    }
}

总结

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

三、局部（方法）内部类

处于方法体中的类，称为局部内部类；

创建局部（方法）内部类

/*
访问修饰符 class 外部类的类名{
  访问修饰符 返回值类型 成员方法名(形参列表){
    class 内部类的类名{
      内部类的类体；
		}
	}
}
*/

public class AreaOuter {
    private int cnt = 1;
    public void show(){
        // 定义一个局部变量进行测试，从java8开始默认理解为final关键字修饰的变量
        // 虽然可以省略final关键字，但建议还是加上
        final int ic = 4;

        // 定义局部内部类，只在当前方法体的内部好使
        class AreaInner{
            private int ia = 2;

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

            public void test(){
                int ib = 3;
                System.out.println("ia = " + ia);
                System.out.println("cnt = " + cnt);
//                ic = 5; Error
                System.out.println("ic = " + ic);
            }
        }

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

初始化局部（方法）内部类

public class AreaOuterTest {
    public static void main(String[] args) {

        // 1、声明外部类类型的引用指向外部类的对象
        AreaOuter ao = new AreaOuter();
        // 2、通过show方法的调用实现局部内容的定义和使用
        ao.show();
    }
}

总结

• 局部内部类只能在该方法的内部可以使用
• 局部内部类可以在方法体内部直接创建对象
• 局部内部类不能使用访问控制符和static关键字修饰符
• 局部内部类可以使用外部方法的局部变量，但是必须是final的，由局部内部类和局部变量的声明周期不同所致

四、匿名内部类

无修饰符、类名的内部类，称为匿名内部类

创建局部（方法）内部类

public class AnonymousInterfaceTest {

    // 假设已有下面的方法，使用回调模式、匿名内部类方式调用下面的方法
    // AnonymousInterFace ai = new AnonymousInterfaceImpl();
    // 接口类型的引用指向实现类型的对象，形成了多态
    public static void test(AnonymousInterFace ai){
        // 编译阶段调用父类版本，运行调用实现类重写的版本
        ai.show();
    }

    public static void main(String[] args) {
        // 使用回调模式调用方法      回调模式：通过实现接口的方式，作为参数传入
//        AnonymousInterfaceTest.test(new AnonymousInterFace()); //Error:接口不能实例化
        AnonymousInterfaceTest.test(new AnonymousInterfaceImpl());

        System.out.println("-----------------------------------------------------------");
        // 使用匿名内部类的语法格式来得到接口类型的引用，格式为：接口/父类类型 引用变量名 = new 接口/父类类型(){ 方法的重写 };
        AnonymousInterFace ait = new AnonymousInterFace() {
            @Override
            public void show() {
                System.out.println("此处为匿名内部类的方法");
            }
        };

        // 从java8开始提出新特性lamda表达式可以简化上述代码，格式为：(参数列表) -> {方法体}
        AnonymousInterFace ait2 = () -> System.out.println("使用lamda表达式创建匿名内部类!");

        // 使用匿名内部类方式调用方法
        AnonymousInterfaceTest.test(ait);
        AnonymousInterfaceTest.test(ait2);
    }
}