内部类

内部类

概念：在一个类的内部再定义一个完整的类

特点：

编译后可生成独立的字节码文件内部类可以直接访问外部类的私有成员，而不破坏封装可为外部类提供必要的内部功能组件

成员内部类：

• 在类的内部定义，与实例变量、实例方法同级别的类

• 外部类的一个实例部分，创建内部类对象时，必须依赖外部类对象。

• 当外部类、内部类存在重名属性时，会优先访问内部类属性

• 成员内部类不能定义静态属性（可包含静态常量）

package innerclass;

public class OutClass {
    private int age=18;
    private String name="外部类属性";

    class Inner{
        private int size=182;
        private String name="内部类属性";

        //不可定义静态属性（静态常量除外）
        //private static String kk="kk";
        private static final String hh="11";

        public void sou(){
            //打印外部类属性
            System.out.println(age);

            //打印内部类属性
            System.out.println(size);

            //打印内部类与外部类同名属性
            System.out.println(name);
            System.out.println(this.name);
            System.out.println(OutClass.this.name);


        }
    }
}

package innerclass;

public class Application {
    public static void main(String[] args) {
        //创建外部类对象
        OutClass out=new OutClass();
        //通过外部类对象创建内部类对象
        OutClass.Inner inner=out.new Inner();

        //一步到位创建内部类
        OutClass.Inner inner2=new OutClass().new Inner();

        //调用内部类方法
        inner.sou();
    }
}

输出结果：
18
182
内部类属性
内部类属性
外部类属性

静态内部类

• 不依赖外部类对象，可直接创建或通过类名访问，可声明静态成员
• 只能直接访问外部类的静态成员，非静态成员需要通过实例化外部类来访问

package innerclass;

public class Outer {
    private int age=22;
    private static String name="外部类名称";

    //静态内部类：与外部类一样，等同于外部类
    static class inner{
        private String address="内部类地址";
        //可定义静态属性
        private static String phone="13728858631";

        public void sout(){
            //访问外部类的非静态属性，需实例化外部类
            Outer outer=new Outer();
            System.out.println(outer.age);
            //访问外部类的静态成员属性,可通过类名调用
            System.out.println(Outer.name);
            //访问静态内部类的属性
            System.out.println(address);
            //访问静态内部类的静态属性
            System.out.println(inner.phone);

        }

    }
}

package innerclass;

public class Application1 {
    public static void main(String[] args) {
        //创建静态内部类对象
        Outer.inner inner = new Outer.inner();
        inner.sout();
    }
}

输出结果：
22
外部类名称
内部类地址
13728858631

局部内部类

• 定义在外部类方法中，作用范围和创建对象范围仅限于当前方法
• 局部内部类访问外部类当前方法中的局部变量时，因无法保障变量的生命周期与自身相同，变量必须修饰为final
• 限制类的使用范围（只能在方法作用域中使用）

package innerclass;

public class Outer2 {
    private String name="外部类名称";
    private static int age=18;

    //成员方法
    public void sout(){
        //局部变量,局部变量不能添加修饰符
         String address="深圳";

         //局部内部类，作用范围仅限方法的作用域中
        class Inner{
            private String phone="13728858631";
            //因其作用域范围方法中，同局部变量，不能添加修饰符
            //private static String email="liudehu@qq.com";
            private  String email="liudehu@qq.com";

            public void sout2(){
                //获取外部类的属性
                System.out.println(name);
                //获取外部类的静态属性
                System.out.println(Outer2.age);
                //获取局部成员属性
                System.out.println(phone);
                System.out.println(email);

            }
        }

        Inner inner=new Inner();
        inner.sout2();
    }
}

package innerclass;

public class Application2 {
    public static void main(String[] args) {
        Outer2 outer2=new Outer2();
        outer2.sout();
    }

}

输出结果：

外部类名称
18
13728858631
liudehu@qq.com

匿名内部类

• 没有类名的局部内部类（一切特征都与局部内部类相同）
• 必须继承一个父类或者实现一个接口
• 定义类、实现类、创建对象的语法合并，只能创建 一个该类的对象
• 优点：减少代码量
• 缺点：可读性较差

package innerclass;

public interface PersonInterface {
     void eat();
}

package innerclass;

public class Application3 {
    public static void main(String[] args) {
        //局部内部类
        class Person implements PersonInterface{
            @Override
            public void eat() {
                System.out.println("局部内部类实现了接口的吃饭方法");
            }
        }
        PersonInterface p1=new Person();
        p1.eat();

        //创建匿名内部类，等同于局部内部类
        PersonInterface p2=new PersonInterface() {
            @Override
            public void eat() {
                System.out.println("匿名内部类实现了接口的吃饭方法");
            }

        };

       p2.eat();


    }
}

输出结果：

局部内部类实现了接口的吃饭方法
匿名内部类实现了接口的吃饭方法